Dear C++ Community,

I have recently came across an interesting problem that might be related to a subject for improvement in the C++ Standard. It is related to macro replacement, so rather an "old C stuff". But not only C++ shares this features with C, but also C++ Standard shares the wording with C standard in this area, especially below paragraph.

16.3.1 Argument substitution

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.

One can interpret this paragraph as if the standard required to:

1. First identify macro arguments (comma separated) and then expand all the macros contained in each argument separately,
   

or

2. Expand all the macros contained in the argument list and then identify each argument.

In fact, the first approach is represented by one of the most widely-used commercial static analyzers (for C), while the second one is apparently applied by GCC as well as some other commercial compiler vendors.

This sample code:

#define CONDITION (0)

#if (CONDITION > 0)
#define FunctionAlias(par_a, par_b, par_opt, par_c) \
          FunctionName(par_a, par_b, par_opt, par_c)
#else
#define FunctionAlias(par_a, par_b, par_c) \
          FunctionName(par_a, par_b, par_c)
#endif

int global_a, global_b, global_c;
#if (CONDITION > 0)
int global_opt;
#endif

void FunctionName(int a, int b, int c)
{
}
 
void AnotherFunction()
{
   FunctionAlias(
                  global_a,
                  global_b,
                  #if (CONDITION > 0)
                  global_opt,
                  #endif
                  global_c
                );
}

is transformed by GCC preprocessor to valid C code:

int global_a, global_b, global_c;

void FunctionName(int a, int b, int c)
{
}

void AnotherFunction()
{
   FunctionName(global_a, global_b, global_c)
                 ;
}

However, the preprocessor embedded in the analyzer produces:

/*    12 */ int global_a, global_b, global_c;
/*    17 */ void FunctionName(int a, int b, int c)
/*    18 */ {
/*    19 */ }
/*    21 */ void AnotherFunction()
/*    22 */ {
/*    30 */    FunctionName(global_a, global_b, #if ((0) > 0) global_opt);
/*    31 */ }

1. What is your opinion on which of the interpretations above is in line with the intentions of the authors of the quoted paragraph?

2. Do you share my impression that the paragraph is not precise enough for the reader to strongly decide which approach is the right one?

Thank you in advance for your answers.

Best regards,