প্রিপ্রসেসর ও ম্যাক্রো — compile-এর আগে কোডের লেখা বদল

১ · Compile-এর আগে একজন লেখা-বদলকারী

পর্ব ০৩-এ আপনি toolchain-এর চার ধাপ দেখেছিলেন। প্রথম ধাপের নাম ছিল preprocessor — সে #include <stdio.h> দেখে পুরো ফাইলটি এনে বসিয়ে দেয়। gcc -E দিয়ে তার কাজের ফলও দেখেছিলেন। এই পর্বে আমরা সেই ধাপটিকেই কাছ থেকে দেখব, কারণ এখানে এমন কিছু ভুল জন্মায় যা পরে compiler বা debugger দিয়ে খুঁজে পাওয়া খুব কঠিন।

একটি তুলনা দিয়ে শুরু করি। Microsoft Word-এ “Find & Replace” আছে — “ঢাকা” খুঁজে সব জায়গায় “Dhaka” বসিয়ে দেয়। Word কিন্তু বোঝে না শব্দটা কোথায় নাম, কোথায় বাক্যের অংশ; সে শুধু অক্ষর মিলিয়ে বদলায়। Preprocessor ঠিক এই কাজটিই করে — আপনার .c ফাইলের ওপর, compiler পড়ার আগে।

Preprocessor-কে দেওয়া প্রতিটি নির্দেশকে বলে directive. চেনার উপায় সহজ — লাইনের প্রথম অক্ষর (ফাঁকা জায়গা বাদে) #. মূল directive-গুলো হলো:

Preprocessor কাজ শেষ করলে যে একটি বড় লেখা তৈরি হয় — আপনার .c ফাইল আর তার ভেতরে ঢোকা সব header মিলিয়ে — compiler সেটিকেই একটি একক হিসেবে compile করে। এই এককের নাম translation unit. পরের অংশগুলোতে শব্দটি কাজে লাগবে।

২ · #include — অন্য ফাইল এনে বসানো, আর দুবার বসলে বিপদ

#include-এর কাজ সবচেয়ে সরল: নির্দিষ্ট ফাইলটি খুঁজে তার পুরো লেখা ঠিক এই লাইনের জায়গায় বসিয়ে দেওয়া। কোনো বাছাই নেই, কোনো বুদ্ধি নেই — পুরোটাই কপি। ফাইলের নাম দুইভাবে লেখা যায়, আর পার্থক্যটা হলো কোথায় খোঁজা হবে:

অন্য কোনো ফোল্ডারে header রাখলে compiler-কে -I flag দিয়ে ঠিকানা বলে দিতে হয়, যেমন gcc -Iinclude main.c. এই খোঁজার তালিকাকে বলে include path. Header না পেলে কী হয়, পর্ব ০৩-এ দেখেছেন — preprocessor থেমে যায়, No such file or directory.

একই header দুবার ঢুকলে কী হয়

সমস্যাটা আসে বড় প্রজেক্টে। একটি ছাত্র-ফলাফল সফটওয়্যারের কথা ভাবুন। date.h-তে তারিখের একটি struct আছে। student.h-এর দরকার জন্মতারিখ, তাই সে date.h include করে। result.h-এর দরকার পরীক্ষার তারিখ, তাই সে-ও date.h include করে। আর main.c দুটো header-ই include করে। কেউ কোনো ভুল করেনি — তবু build ভেঙে যায়। নিচের ডায়াগ্রামে দেখুন কেন:

/* date.h */
struct Date { int day, month, year; };

/* student.h */
#include "date.h"
struct Student { char name[40]; struct Date birth; };

/* result.h */
#include "date.h"
struct Result { int marks; struct Date exam_day; };

/* main.c */
#include "student.h"
#include "result.h"

/* student.h থেকে → তার ভেতরের date.h থেকে: */
struct Date { int day, month, year; };
struct Student { char name[40]; struct Date birth; };

struct Date { int day, month, year; };
struct Student { char name[40]; struct Date birth; };
/* result.h থেকে → তার ভেতরের date.h থেকে আবার: */
struct Date { int day, month, year; };
struct Result { int marks; struct Date exam_day; };

$ gcc main.c -o result
In file included from result.h:1,
                 from main.c:2:
date.h:1:8: error: redefinition of 'struct Date'

#ifndef DATE_H        /* DATE_H সংজ্ঞায়িত নয়? → হ্যাঁ, ভেতরে ঢোকো */
#define DATE_H        /* এখন থেকে DATE_H আছে */

struct Date { int day, month, year; };   /* রাখা হলো */

#endif

struct Date { int day, month, year; };
struct Student { char name[40]; struct Date birth; };
/* result.h → date.h: DATE_H আগেই আছে, তাই #ifndef মিথ্যা — কিছুই বসল না */
struct Result { int marks; struct Date exam_day; };
/* struct Date মাত্র একবার — build সফল */

এই কৌশলের নাম include guard. নামটি সাধারণত ফাইলের নাম বড় হাতের অক্ষরে, .-এর জায়গায় _ দিয়ে — student.h হলে STUDENT_H. বড় প্রজেক্টে নামের সংঘাত এড়াতে সামনে প্রজেক্টের নামও যোগ করা হয়, যেমন RESULTAPP_STUDENT_H.

আরেকটি ছোট উপায় আছে — header-এর প্রথম লাইনে #pragma once. এর অর্থ “এই ফাইল একটি translation unit-এ একবারই বসাও”. GCC, Clang আর Microsoft-এর compiler (MSVC) — তিনটিই এটি বোঝে, তাই বাস্তবে খুব প্রচলিত। তবে #pragma once C স্ট্যান্ডার্ডের অংশ নয়। একই ফাইল যদি দুটি ভিন্ন পথে পৌঁছানো যায় (যেমন link করা ফোল্ডার বা নেটওয়ার্ক drive), কিছু পরিস্থিতিতে compiler বুঝতে পারে না দুটো আসলে একই ফাইল। তাই যেখানে সর্বোচ্চ portability দরকার, সেখানে মানুষ এখনো guard লেখে, কেউ কেউ দুটোই।

৩ · #define দিয়ে ধ্রুবক — const আর enum-এর সাথে তুলনা

#define-এর সবচেয়ে সরল রূপ একটি নামকে একটি লেখা দিয়ে বদলায়:

#define MAX_STUDENTS 60
#define PASS_MARK    33

int marks[MAX_STUDENTS];          /* preprocessor-এর পরে: int marks[60]; */

এ ধরনের নির্দেশকে বলে macro, আর যেহেতু এটি দেখতে একটি সাধারণ নামের মতো, তাই এর পুরো নাম object-like macro. Preprocessor ফাইলের যেখানেই MAX_STUDENTS শব্দটি পায়, সেখানে 60 লিখে দেয়। একে বলে macro expansion. পর্ব ০৬-এ দেখেছেন, এভাবে magic number-কে নাম দিলে কোড পড়া সহজ হয়, আর নিয়ম বদলালে এক জায়গায় বদলালেই চলে।

কিন্তু পর্ব ০৬-এ একই কাজের জন্য const শিখেছিলেন, আর পর্ব ২২-এ enum. তাহলে কোনটি কখন? তিনটির স্বভাব পাশাপাশি দেখুন:

অভিজ্ঞ C প্রোগ্রামাররা তাই মোটামুটি এই নিয়ম মানেন:

• পূর্ণসংখ্যার ধ্রুবক, বিশেষ করে array-র মাপ বা case: enum — টাইপ আছে, scope আছে, debugger-এ দেখা যায়।
• দশমিক বা অন্য টাইপের ধ্রুবক: static const double VAT_RATE = 0.15;
• #define: যখন মানটি preprocessor-এরই লাগবে (যেমন #if MAX_STUDENTS > 100), অথবা compile করার সময় বাইরে থেকে দেওয়া হবে (gcc -DMAX_STUDENTS=80).

৪ · Function-like macro — দেখতে ফাংশন, আসলে লেখা-বদল

Macro argument-ও নিতে পারে। নামের ঠিক পরেই (মাঝে কোনো ফাঁকা জায়গা ছাড়া) বন্ধনী দিলে তৈরি হয় function-like macro:

#define SQUARE_BAD(x)  x * x

দেখতে একটি ফাংশনের মতো — SQUARE_BAD(5) দিলে 5 * 5, অর্থাৎ ২৫. কিন্তু মনে রাখুন, preprocessor হিসাব করে না, শুধু x-এর জায়গায় আপনি যা লিখেছেন হুবহু সেই লেখাটি বসায়। Argument-এ একটি যোগ চিহ্ন থাকলেই গল্প বদলে যায়। পর্ব ০৭-এর precedence মনে আছে তো? নিচে ধাপে ধাপে দেখুন compiler আসলে কী পায়:

#define SQUARE_BAD(x)  x * x

int a = 3;
int r = SQUARE_BAD(a + 1);   /* আশা: (3+1)*(3+1) = 16 */

int a = 3;
int r = a + 1 * a + 1;
/* x  *  x
   ↓     ↓
 a + 1 * a + 1   — বন্ধনী কোথাও নেই! */

a + 1 * a + 1
= a + (1 * a) + 1
= 3 + 3 + 1
= 7          /* 16 নয়! কোনো error নেই, কোনো warning নেই */

#define SQUARE(x)  ((x) * (x))

SQUARE(a + 1)   →   ((a + 1) * (a + 1))   = 16
10 / SQUARE(2)  →   10 / ((2) * (2))      = 2
/* বাইরের বন্ধনী না থাকলে 10 / (2) * (2) = 10 হতো */

int i = 5;
int r = SQUARE(i++);
/* preprocessor-এর পরে: */
int r = ((i++) * (i++));
/* i একই expression-এ দুবার বাড়ছে — undefined behavior.
   ফল 30? 25? 36? কোনো নিশ্চয়তা নেই। */

static inline int square(int x) { return x * x; }

square(a + 1)  →  x = 4, ফল 16
square(i++)    →  x = 5, ফল 25, i হলো 6  /* ঠিক একবার */
square("hi")   →  compiler error: টাইপ মেলে না — ভালো!

এবার নিজে চালিয়ে দেখুন। নিচের কোডে একই কাজ macro আর inline function — দুইভাবে করা হয়েছে। MAX macro-টি দুই স্তরে বন্ধনীসহ “সঠিকভাবে” লেখা, তবু একটি অবাক করা ফল দেয়:

#include <stdio.h>

#define SQUARE_BAD(x) x * x
#define SQUARE(x)     ((x) * (x))
#define MAX(a, b)     ((a) > (b) ? (a) : (b))

static inline int max_int(int a, int b) { return a > b ? a : b; }

int main(void) {
    int a = 3;
    printf("SQUARE_BAD(a + 1) = %d\n", SQUARE_BAD(a + 1));
    printf("SQUARE(a + 1)     = %d\n", SQUARE(a + 1));

    int i = 5, j = 5;
    int m1 = MAX(i++, 0);       /* macro */
    int m2 = max_int(j++, 0);   /* function */
    printf("macro : m1 = %d, i = %d\n", m1, i);
    printf("inline: m2 = %d, j = %d\n", m2, j);
    return 0;
}

৫ · কয়েক লাইনের macro আর do { } while (0) কৌশল

কখনো macro দিয়ে একাধিক কাজ করাতে ইচ্ছে হয় — ধরুন একটি বিন্দুর দুটি স্থানাঙ্ক শূন্য করা। লম্বা macro কয়েক লাইনে লিখতে চাইলে প্রতিটি লাইনের শেষে \ দিতে হয়, কারণ preprocessor-এর কাছে একটি directive মানে একটি লাইন। এখন প্রশ্ন হলো, ভেতরের কয়েকটি statement-কে কীভাবে মোড়াবেন? তিনটি চেষ্টা ধাপে ধাপে দেখুন:

#define RESET(p)  (p).x = 0; (p).y = 0

if (out_of_screen)
    RESET(pt);

/* preprocessor-এর পরে: */
if (out_of_screen)
    pt.x = 0;
pt.y = 0;     /* ← if-এর বাইরে! সবসময় চলে */

#define RESET(p)  { (p).x = 0; (p).y = 0; }

if (out_of_screen)
    RESET(pt);

/* preprocessor-এর পরে: */
if (out_of_screen)
    { pt.x = 0; pt.y = 0; };   /* ঠিক আছে… আপাতত */

if (out_of_screen)
    RESET(pt);
else
    moves++;

/* preprocessor-এর পরে: */
if (out_of_screen)
    { pt.x = 0; pt.y = 0; };   /* ← এই ; দিয়ে if শেষ */
else                          /* error: 'else' without a previous 'if' */
    moves++;

#define RESET(p)            \
    do {                    \
        (p).x = 0;          \
        (p).y = 0;          \
    } while (0)

if (out_of_screen)
    do { pt.x = 0; pt.y = 0; } while (0);   /* ; এখানে লাগবেই */
else
    moves++;                                /* ঠিকঠাক compile হয় */

তাহলে macro কেন, যখন static inline আছে?

C99 থেকে C-তে inline keyword আছে। ছোট ফাংশনের সামনে static inline লিখে header-এ রাখলে compiler চাইলে ফাংশন-ডাকার জায়গায় সরাসরি ফাংশনের কোড বসিয়ে দেয় — পর্ব ০৩-এ যাকে inlining বলেছিলাম। এতে macro-র গতির সুবিধা পাওয়া যায়, কিন্তু তার কোনো ফাঁদ থাকে না:

শেষ সারিটিই macro-র একটি আসল সুবিধা — টাইপ না জেনেই কাজ করা। তবে বেশিরভাগ বাস্তব কোডে দু-একটি টাইপই লাগে। Linux kernel-এর coding style নির্দেশিকাতেও পরিষ্কার লেখা আছে: ফাংশনের মতো দেখতে macro-র চেয়ে inline ফাংশন সাধারণত ভালো। Macro রাখুন সেই কাজগুলোর জন্য যা ফাংশন পারেই না — পরের দুটি অংশে সেগুলো দেখব।

৬ · Conditional compilation — এক কোড, আলাদা প্রোগ্রাম

Preprocessor-এর সবচেয়ে কাজের ক্ষমতা সম্ভবত এটি: শর্ত অনুযায়ী কোডের একটি অংশ রাখা বা পুরোপুরি মুছে ফেলা। একে বলে conditional compilation. সাধারণ if চলে প্রোগ্রাম চলার সময়; কিন্তু #if কাজ করে compile-এর আগে, আর যে অংশ বাদ পড়ে, সেটি compiler কখনো দেখেই না — চূড়ান্ত প্রোগ্রামে তার একটি বাইটও থাকে না।

শর্তে ব্যবহৃত নামগুলো আসে দুই জায়গা থেকে। কিছু compiler নিজেই সংজ্ঞায়িত করে রাখে — যেমন Windows-এ (MSVC বা MinGW, ৩২ বা ৬৪ বিট যা-ই হোক) _WIN32, Linux-এ __linux__, macOS-এ __APPLE__. আর কিছু আপনি build কমান্ডে দেন: gcc -DDEBUG app.c মানে “ফাইলের একদম শুরুতে #define DEBUG 1 লেখা আছে ধরে নাও”. একই app.c থেকে কী কী আলাদা প্রোগ্রাম তৈরি হয়, দেখুন:

#include <stdio.h>

#if defined(_WIN32)
    #define CLEAR_CMD "cls"
#elif defined(__linux__) || defined(__APPLE__)
    #define CLEAR_CMD "clear"
#else
    #error "Unknown platform: please define CLEAR_CMD"
#endif

int main(void) {
#ifdef DEBUG
    printf("[debug] build date: %s\n", __DATE__);
#endif
    printf("Screen clear command: %s\n", CLEAR_CMD);
    return 0;
}

/* stdio.h-এর শত শত লাইন … */

int main(void) {
    printf("Screen clear command: %s\n", "clear");
    return 0;
}
/* debug লাইনটির কোনো চিহ্নই নেই */

/* stdio.h-এর শত শত লাইন … */

int main(void) {
    printf("[debug] build date: %s\n", "Oct 16 2026");
    printf("Screen clear command: %s\n", "clear");
    return 0;
}

/* stdio.h-এর শত শত লাইন … */

int main(void) {
    printf("Screen clear command: %s\n", "cls");
    return 0;
}

$ gcc app.c
app.c:8:6: error: #error "Unknown platform: please define CLEAR_CMD"
    8 |     #error "Unknown platform: please define CLEAR_CMD"
      |      ^~~~~

৭ · প্রোগ্রাম নিজের ঠিকানা বলে — __FILE__, __LINE__, __func__ ও assert

কিছু macro আপনাকে লিখতে হয় না, compiler নিজেই প্রস্তুত রাখে। এদের বলে predefined macro. সবচেয়ে কাজের কয়েকটি:

__func__ নিয়ে একটি সূক্ষ্ম কিন্তু সত্যিকারের পার্থক্য আছে। এটি C99-এ যোগ হওয়া একটি predefined identifier — macro নয়। কারণটা যৌক্তিক: preprocessor ফাংশন কী তা-ই জানে না, তাই সে ফাংশনের নাম বসাতে পারে না। কাজটি করে compiler নিজে, যেন প্রতিটি ফাংশনের শুরুতে লুকিয়ে static const char __func__[] = "average"; লেখা আছে। ব্যবহারে পার্থক্য সামান্য, কিন্তু একটি জিনিস মনে রাখুন: #ifdef __func__ লিখলে সেটি সবসময় মিথ্যা হবে।

__LINE__ আর __FILE__-এর আসল জাদু দেখা যায় macro-র ভেতরে ব্যবহার করলে। Macro খোলা হয় যেখানে ডাকা হয়েছে সেখানে, তাই __LINE__ বসায় ডাকার জায়গার লাইন নম্বর — একটি ফাংশন কখনো এটি পারত না। নিচের প্রোগ্রামে একটি ছোট LOG macro আছে, যা শুধু debug build-এ কাজ করে:

#include <stdio.h>

#define DEBUG   /* delete this line for a release build */

#ifdef DEBUG
#define LOG(msg) printf("[%s:%d %s] %s\n", __FILE__, __LINE__, __func__, msg)
#else
#define LOG(msg) do { } while (0)
#endif
#define SHOW(expr) printf(#expr " = %d\n", (expr))

static int average(int total, int count) {
    LOG("average() called");
    if (count == 0) { LOG("count is zero, returning 0"); return 0; }
    return total / count;
}

int main(void) {
    SHOW(average(250, 5));
    SHOW(average(10, 0));
    return 0;
}

assert — “এটা কখনো মিথ্যা হওয়ার কথা নয়”

Standard library-র <assert.h>-এ আছে assert, যা আসলে এই কৌশলেরই একটি পেশাদার রূপ। assert(count > 0); লিখলে প্রোগ্রাম চলার সময় শর্তটি যাচাই হয়। মিথ্যা হলে প্রোগ্রাম সঙ্গে সঙ্গে থামে, আর stderr-এ এমন কিছু ছাপে:

app: result.c:27: average: Assertion `count > 0' failed.
Aborted

শর্তের হুবহু লেখা, ফাইল, লাইন, ফাংশন — সবই এসেছে #, __FILE__, __LINE__ আর __func__ থেকে। আর release build-এ -DNDEBUG দিলে NDEBUG সংজ্ঞায়িত হয়, তখন প্রতিটি assert খুলে কিছুই হয় না — সম্পূর্ণ বাদ, কোনো খরচ নেই। CMake-এর মতো build system-এর Release মোড সাধারণত নিজে থেকেই -DNDEBUG যোগ করে।

৮ · # আর ## — লেখাকে string বানানো, শব্দ জোড়া দেওয়া

Macro-র ভেতরে দুটি বিশেষ অপারেটর আছে, যা শুধু preprocessor বোঝে। দুটোই “লেখা নিয়ে কাজ” — আর ঠিক এ ধরনের কাজ ফাংশন দিয়ে করা অসম্ভব।

একটি বাস্তব উদাহরণ: একটি দোকানের হিসাবের প্রোগ্রামে অর্ডারের অবস্থা enum-এ রাখা আছে — PENDING, PAID, DELIVERED. Log-এ সংখ্যা 1 না দেখিয়ে নাম "PAID" দেখাতে চাইলে প্রতিটির জন্য হাতে string লিখতে হয়, আর নতুন অবস্থা যোগ করলে দুই জায়গায় বদলাতে হয়। # দিয়ে একটি তালিকা থেকেই enum আর নামের string — দুটোই তৈরি করা যায়, ফলে দুটো কখনো অমিল হয় না। এই কৌশলকে বলে “X-macro”; বড় C প্রজেক্টে বহুল ব্যবহৃত।

৯ · AI-এর যুগে — macro কোডে AI যেসব ভুল করে

Macro এমন একটি জায়গা যেখানে AI-এর লেখা কোড “দেখতে ঠিক” লাগে, কিন্তু বিপদ লুকিয়ে থাকে লেখা খোলার পরে। কারণ AI কোডটি একটি লেখা হিসেবে দেখে — আপনার build কমান্ডে কোন -D flag আছে, কোন header কোন পথে দুবার ঢুকছে, তা সে জানে না। পুরোনো টিউটোরিয়ালে ভরা ইন্টারনেট থেকে শেখায় AI প্রায়ই সেই যুগের অভ্যাসও নিয়ে আসে।

Macro-ওয়ালা কোড হাতে পেলে — যাচাইয়ের চেকলিস্ট

• gcc -E file.c চালিয়ে সন্দেহজনক জায়গায় compiler আসলে কী লেখা পাচ্ছে, নিজের চোখে দেখেছি
• প্রতিটি function-like macro-তে parameter ও পুরো সংজ্ঞা — দুই স্তরে বন্ধনী আছে
• কোনো macro-র argument-এ ++, -- বা ফাংশন-ডাক নেই
• কয়েক লাইনের macro do { … } while (0) দিয়ে মোড়ানো, শেষে ; নেই
• প্রতিটি header-এ include guard বা #pragma once আছে
• assert-এর ভেতরে কোনো আসল কাজ নেই, আর -DDEBUG ও -DNDEBUG — দুইভাবেই build করে চালিয়ে দেখেছি