Errors when trying to pass comma through multiple macros - c

Question

I'm trying to pass a comma through multiple levels of macros, but the preprocessor doesn't like that...
// This is just simplified, in reality I have some other variadic function which will
// stop upon encountering the -1 and APPEND_COMMA() may add more args (like `a, b,`)
#include <stdio.h>
#define MACRO_EX(val) printf("%d %d", val -1);
#define MACRO(val) MACRO_EX(val)
#define APPEND_COMMA(a) a,
int main() {
MACRO(APPEND_COMMA(1));
return 0;
}
What exactly is causing the compile failure here?
test.c:10:8: error: too many arguments provided to function-like macro invocation
MACRO(APPEND_COMMA(1));
^
test.c:7:26: note: expanded from macro 'APPEND_COMMA'
#define APPEND_COMMA(a) a,
^
test.c:5:29: note: expanded from macro 'MACRO'
#define MACRO(val) MACRO_EX(val)
^
test.c:3:9: note: macro 'MACRO_EX' defined here
#define MACRO_EX(val) printf("%d %d", val 0);
^
test.c:10:2: error: use of undeclared identifier 'MACRO_EX'
MACRO(APPEND_COMMA(1));
^
test.c:5:20: note: expanded from macro 'MACRO'
#define MACRO(val) MACRO_EX(val)
^
2 errors generated.
The comma seems to be expanded in the called macro, so that MACRO_EX(a,) is called, which is not what I want.
I found some workaround for this by using __VA_ARGS__:
#define MACRO_EX(...) printf("%d %d", __VA_ARGS__ -1);
But I'd really prefer to pass the comma cleanly through all the macros up to the variadic function call and use cleanly named macro parameters [like I intended in my original code].
Is there any way to achieve that?

Answer 1

The only way to guarantee a comma will be passed "cleanly" through macro parameters is to wrap it in parentheses:
#define APPEND_COMMA(a) (a,)
Now the result of APPEND_COMMA will always be a single preprocessor argument.
The obvious problem with this is that it produces printf("%d %d", (1,) -1);, which is now valid preprocessor code, but no longer valid C code. This is rectified by inserting an "unpack" step into the definition of MACRO_EX:
#define IDENTITY(...) __VA_ARGS__
#define MACRO_EX(val) printf("%d %d", IDENTITY val -1);
IDENTITY will unpack the contents of val, assuming val is a parenthesised argument list, during MACRO_EX's rescan step.
What about situations where val might not be parenthesised, because it doesn't contain a comma? The answer is to not let them arise. Arguments that might contain a comma should always be wrapped, so they can always be safely unwrapped at the final point of insertion. Macros need to be designed with the knowledge of whether they anticipate single tokens or lists*. This is the preprocessor's equivalent of a static type constraint: macros like MACRO require an argument of type list, not of type atom (and the calling macros similarly need to be written with the correct type signatures in mind); on those occasions when they need a single argument only, pass them a single-element list.
* It is technically possible to design a macro that tests whether its argument is parenthesised and branches on the result, but you're getting into dark magic territory there. Stick to fixed types for clarity.