Using a #define-d list as input to a C preprocessor macro

Question

In an example project, I defined the macro

#define FOO(x, y) x + y   .

This works perfectly well. For example, FOO(42, 1337) is evaluated to 1379.

However, I now want to use another #define:

#define SAMPLE 42, 1337

When I now call FOO(SAMPLE), this won't work. The compiler tells me that FOO takes two arguments, but is only called with one argument.

I guess that the reason for this is that, although, the arguments of a macro are evaluated in advance of the function itself, that the preprocessor does not parse the whole instruction again after this evaluation. This is a similar to the fact that it is not possible to output additional preprocessor directives from a macro.

Is there any possibility to get the desired functionality?

Replacing the FOO macro with a C function is not a possibility. The original macro is located in third party code I cannot change, and it outputs a comma-separated list of values to be directly used in array initializers. Therefore, a C function cannot replicate the same behaviour.

If it is not possible to accomplish this task by using simple means: How would you store the (x, y) pairs in a maintainable form? In my case, there are 8 arguments. Therefore, storing the individual parts in separate #define-s is also not easy maintainable.

Answer 1

You're running into a problem where the preprocessor is not matching and expanding macros in the order you want. Now you can generally get it to do what you want by inserting some extra macros to force it to get the order right, but in order to that you need to understand what the normal order is.

• when the compiler sees the name of a macro with arguments followed by a ( it first scans in that argument list, breaking it into arguments WITHOUT recognizing or expanding any macros in the arguments.

• after parsing and separating the arguments, it then rescans each argument for macros, and expands any it finds withing the argument UNLESS the argument is used with # or ## in the macro body

• it then replaces each instance of the argument in the body with the (now possibly expanded) argument

• finally, it rescans the body for any OTHER macros that may exist with the body for expansion. In this one scan, the original macro WILL NOT be recognized and reexpanded, so you can't have recursive macro expansions

So you can get the effect you want by careful use of an EXPAND macro that takes a single argument and expands it, allowing you to force extra expansions at the right point in the process:

#define EXPAND(X)   X
#define FOO(x,y)    x + y
#define SAMPLE      42, 1337

EXPAND(FOO EXPAND((SAMPLE)))

In this case you first explicitly expand macros in the argument list, and then manually expand the resulting macro call afterwards.

Update by question poster

#define INVOKE(macro, ...) macro(__VA_ARGS__)

INVOKE(FOO, SAMPLE)

provides an extended solution that works without cluttering the code with EXPANDs.