C/C++: How should preprocessor directive work on macros argument list?

Question

Both C and C++ standards specify the following:

16.3.1 Argument substitution (C++11)

6.10.3.1 Argument substitution (C11)

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 standards require to:

(1) At 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.

To illustrate this, let's consider 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
                );
}

(1) Approach one would produce invalid code:

int global_a, global_b, global_c;

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

void AnotherFunction()
{
  FunctionName(global_a, global_b, #if ((0) > 0) global_opt);
}

(2) Approach 2 produces 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);
}

Which of the interpretations of the standards is the correct one?

I present to you a third interpretation: error: embedding a directive within macro arguments has undefined behavior. This is what GCC & Clang do. The error happens before the macro is expanded. — HolyBlackCat
@HolyBlackCat Actually, GCC 9.3.0 is compiling this code without a complain. Anyway, thanks for your comment - I rephrased the title to be more accurate. — mrn
Add -pedantic-errors, it makes GCC more standard-conformant. — HolyBlackCat
(Historical note: Some versions of GCC, circa 3.0, did make this particular case of UB a hard error. I don't remember if it ever made it into a release that way, but we got so many complaints from people who were annoyed at us breaking their code ... because they were putting #ifdefs inside the arguments to printf, and some C libraries make printf a macro. So we backed it down to a warning.) — zwol

zwol zwol · Accepted Answer · 2020-10-20T20:01:07

First, you cannot, at all, put preprocessing directives inside the arguments to a function-like macro, because of some text a little down from what you quoted:

If there are sequences of preprocessing tokens within the list of arguments that would otherwise act as preprocessing directives, the behavior is undefined.

[N1570, §6.10.3 p11].

Second, independent of that, the standard requires the behavior you called (1). This is specified by this part of the text you quoted:

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.

This sentence wouldn't make any sense if the arguments to a function-like macro were expanded before the boundaries between arguments were identified. You can also see this by experiment, with a slight modification of your code:

#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;
#define GLOBAL_OPT global_opt,
#else
#define GLOBAL_OPT /*nothing*/
#endif

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

This will compile fine if CONDITION is not defined or zero, but when CONDITION is nonzero, you will get an error along the lines of

test.c: In function ‘AnotherFunction’:
test.c:28:17: error: macro "FunctionAlias" requires 4 arguments, but only 3 given
   28 |                 );
      |                 ^

demonstrating that GLOBAL_OPT was not expanded before looking for the four arguments to FunctionAlias.

C/C++: How should preprocessor directive work on macros argument list?

2 Answers