C language preprocessor behavior

Question

There are different kind of macros in C language, nested macro is one of them.

Considering a program with the following macro

#define HYPE(x,y) (SQUR(x)+SQUR(y))
#define SQUR(x)   (x*x)

Using this we can successfully compile to get the result.

As we all know the C preprocessor replaces all the occurrence of the identifiers with the replacement-string. Considering the above example I would like to know how many times the C preprocessor traverses the program to replace the macro with the replacement values. I assume it cannot be done in one go.

Answer 1

the replacement takes place, when "HYPE" is actually used. it is not expanded when the #define statement occurs.

eg:

1 #define FOO 1
2
3 void foo() {
4    printf("%d\n", FOO);
5 }

so the replacement takes place in line 5, and not in line 1. hence the answer to your question is: once.

Answer 2

A #define'd macro invocation is expanded until there are no more terms to expand, except it doesn't recurse. For example:

#define TIMES        *
#define factorial(n) ((n) == 0 ? 1 : (n) TIMES factorial((n)-1))
    // Doesn't actually work, don't use.

Suppose you say factorial(2). It will expand to ((2) == 0 ? 1 : (2) * factorial((2)-1)). Note that factorial is expanded, then TIMES is also expanded, but factorial isn't expanded again afterwards, as that would be recursion.

However, note that nesting (arguably a different type of "recursion") is in fact expanded multiple times in the same expression:

#define ADD(a,b)     ((a)+(b))
....
ADD(ADD(1,2),ADD(3,4)) // expands to ((((1)+(2)))+(((3)+(4))))