How to defer a macro substitution in a concatenate-stringify cascade

Question

This is a follow-up question to this one (and also closer to the actual problem at hand).

If I have the following case:

#include <stdio.h>

#define FOO_ONE 12
#define FOO_TWO 34
#define BAR_ONE 56
#define BAR_TWO 78

#define FOO 99

#define STRINGIFY(mac) #mac
#define CONCAT(mac1, mac2) STRINGIFY(mac1) STRINGIFY(mac2)
#define MAKE_MAC(mac) CONCAT(mac##_ONE, mac##_TWO)

#define PRINT(mac) printf(#mac ": " MAKE_MAC(mac) "\n")

void main(int argc, char *argv[])
{
    PRINT(FOO);
    PRINT(BAR);
}

As can be seen, the stringified, concatenated macros are then substituted inside a printf() statement which itself is inside a macro.

Because FOO is defined (as 99), it happens that it is expanded before the concatenation with _ONE and _TWO, effectively creating the tokens 99_ONE and 99_TWO.

This program outputs:

FOO: 99_ONE99_TWO
BAR: 5678

How can I defer the expansion of the FOO macro (effectively, eliminating it altogether, to get the required output of:

FOO: 1234
BAR: 5678

NOTE: assume the PRINT() macro signature cannot be changed (i.e., can't add a parameter, etc.). However its implementation can be changed. Also, FOO, FOO_* and BAR_* definitions cannot be modified as well.

Answer 1

If you can do something each time FOO is used, you could first undefine the macro inorder for it expand as you want and then redefine it as in

#undef FOO
PRINT(FOO);
#define FOO 99

in which case it will expand to

printf("FOO" ": " "12" "34" "\n");

printf("BAR" ": " "56" "78" "\n");

to print what you want.

Answer 2

How can I defer the expansion of the FOO macro ... NOTE: assume the PRINT() macro signature cannot be changed (i.e., can't add a parameter, etc.)

You can't.

Macro expansions go through a series of steps:

• Argument substitution
• Paste and stringification in no particular order
• Rescan and further replacement

Argument substitution occurs with your arguments; in the case of the invocation PRINT(FOO), FOO; and it's the very first step. By the time you even get the preprocessor to recognize that something in your replacement list is a macro, you've long past argument substitution.

The rule for argument substitution is that if any of your parameters are mentioned in your replacement list, and those parameters are being neither stringified nor pasted, then the corresponding argument is fully evaluated and those mentions of the parameters are replaced with the result. In this case, PRINT(FOO), after argument substitution, results in the replacement list:

printf(#mac ": " MAKE_MAC(99) "\n")

Again, MAKE_MAC's definition doesn't matter; it's not even recognized as a macro until rescan and further replacement.

Now, without your restriction, you could defer FOO from expanding... by adding a second parameter to PRINT and pasting to it (that disqualifies it from a.s., and by the time rescan and replacement comes along it'd be invoking your next macro). But with your restriction, you're DOA.

Answer 3

The actual expansion of FOO to 99 happens at the moment when PRINT is expanded and before its body is re-scanned one more time. The relevant part of the ANSI standard is:

6.10.3.1 Argument substitution

1 After the arguments for the invocation of a function-like macro have been identified, argument substitution takes place. A parameter in the replacement list, unless preceded by a # or ## preprocessing token or followed by a ## preprocessing token (see below), is replaced by the corresponding argument after all macros contained therein have been expanded. Before being substituted, each argument’s preprocessing tokens are completely macro replaced as if they formed the rest of the preprocessing file; no other preprocessing tokens are available.

In your case you can avoid expansion of FOO (inside mac) by replacing

#define PRINT(mac) printf(#mac ": " MAKE_MAC(mac) "\n")

with

#define PRINT(mac) printf(#mac ": " CONCAT(mac##_ONE, mac##_TWO) "\n")