Macro replacement list rescanning for replacement

Consider the following simple example:

#include<stdio.h>

const int FOO = 42;

#define FOO (42 + FOO) 

int main()
{
   printf("%d", FOO);
}

Here the output will be 84.

The printf will be expanded to:

printf("%d", 42 + 42);

This means that when the macro FOO is expanded, the expansion will stop when the second FOO is found. It will not be further expanded. Otherwise, you will end up with endless recursion resulting in: 42 + (42 + (42 + (42 + ....)

Live demo here.

The (original) macro being replaced is not FOOBAR, it's INVOKE. When you're expanding INVOKE and you find FOOBAR, you expand FOOBAR normally. However, if INVOKE had been found when expanding INVOKE, it would no longer be expanded.

Let's take the following code:

#define FOOBAR(a, b) printf(#a #b)

#define INVOKE(a, b) e1 a##b(a, b)

int main() {
    INVOKE(INV, OKE);
}

I added the e1 to the expansion of INVOKE to be able to visualise how many expansions happen. The result of preprocessing main is:

e1 INVOKE(INV, OKE);

This proves that INVOKE was expanded once and then, upon rescanning, not expanded again.

[Live example]