The C Preprocessor

Related material. The GATE 2027 CS syllabus does not name the preprocessor separately. It is included because it is part of the syllabus item "Programming in C": C programs in questions use #define and #include.

Before a C file is compiled, it passes through the preprocessor, which works on tokens rather than on C expressions or types. It removes comments, joins lines ending in a backslash, copies in header files (#include), replaces macro names by their definitions (#define), and keeps or drops blocks of code (#if, #ifdef). The compiler proper sees the preprocessing result rather than active macro invocations. A name suppressed from recursive expansion may remain as an ordinary identifier.

Because the preprocessor substitutes text without knowing C's precedence or evaluation rules, macros produce well-known output pitfalls: SQUARE(2 + 3) that is not 25, or an argument evaluated twice. This note covers the directives, object-like and function-like macros and their expansion rules, the # and ## operators, conditional compilation, include guards, and the trade-offs between macros and functions.

Conventions: C11; expansions shown are those of gcc -std=c11 -E, and outputs are for gcc on x86-64 Linux.

Translation proceeds in phases. In outline: physical lines are joined where a line ends in \; the source is split into preprocessing tokens and each comment is replaced by one space; then directives are executed and macros expanded; then string literals are concatenated and the result is compiled. A directive is a line whose first non-blank character is #; it ends at the end of the line.

Every later occurrence of the identifier PI as a token is replaced by 3.14159. Replacement does not happen inside string literals or character constants, or inside a longer identifier such as PIE. There is no type and no storage; the compiler sees only the number.

The parameter list must follow the macro name with no space: #define F (x) x defines an object-like macro F whose replacement is (x) x, so F(3) becomes (x) x(3).

At a use such as SQ(2 + 3), the argument tokens 2 + 3 are substituted for x as tokens, not as a value:

Rule: parenthesise every parameter in the replacement and the whole replacement.

Assume a counter initially 0 and next() increments it by one and returns the new value. next() appears twice in the expansion. It is called once in the comparison and, because the result is greater than 0, again in the chosen branch: m is 2 and the counter is 2. A function max(next(), 0) would call next() once. With an argument like i++, the double evaluation can even be undefined behaviour: SQ(i++) expands to ((i++) * (i++)), two unsequenced modifications of i (Undefined, Unspecified and Implementation-Defined Behaviour).

Restrictions. The macro requires side-effect-free modifiable int lvalues and must not capture a caller identifier named t_; for example SWAP(x,t_) is unsafe. The wrapper is not general macro hygiene. For real C11 code prefer static inline void swap_int(int *a, int *b) { int t = *a; *a = *b; *b = t; } with pointers to distinct live int objects, then call swap_int(&a,&b).

The do { ... } while (0) wrapper makes the macro a single statement that still needs its trailing semicolon, so it works inside if ... else. With plain braces, SWAP(a, b); would leave an extra ; statement before else, which is a syntax error.

After substitution the result is rescanned for more macro names, but a macro's own name is not replaced again while it is being expanded. So #define f(x) x + f(x) gives f(1) $\to$ 1 + f(1), and the remaining f(1) is left for the compiler (as a call to a function f, if one exists).

A header may be included more than once in a translation unit, directly or through other headers. Defining the same structure type twice is an error, so headers are guarded:

The second inclusion finds POINT_H already defined and skips the body. Without a guard, including such a header twice makes gcc stop with the error "redefinition of 'struct pt'".

__FILE__ (current file name as a string), __LINE__ (current line number), __DATE__, __TIME__, __STDC__ (1 on a conforming implementation), and __STDC_VERSION__ (201112L for C11). They are useful in diagnostics such as assert, which is itself a macro.

C99 inline functions give most of the speed of macros with the safety of functions.

All expansions below are those of gcc -E; all outputs are for C11 with gcc on x86-64 Linux.

Example 1. SQ_BAD(2 + 3) prints 11, SQ(2 + 3) prints 25, 100 / SQ(5) prints 4.

Example 2. 10 * DBL(3) with #define DBL(x) (x) + (x) expands to 10 * (3) + (3), which is 33, not 60, because the whole replacement was not parenthesised.

Example 3. MAX(next(), 0) gives 2 with the counter at 2.

Example 4. if (a < b) SWAP(a, b); else a = 0; with a = 1, b = 2 leaves a = 2, b = 1.

Example 5. STR(N) is "N"; XSTR(N) is "42".

Example 6. AREA(1.0) prints 3.14 with %.2f; __STDC_VERSION__ is 201112L under -std=c11.