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.

FOO(42, 1337) does not evaluate to 1379, it evaluates to 42 + 1337. The preprocessor only performs text substitution. Only later, when the compiler performs constant folding, is this substitution made. — Adam Mihalcin
– Adam Mihalcin, Commented Apr 24, 2012 at 21:20
Duplicate of Is it possible to a Macro evaluate multiple arguments to another? — James McNellis
– James McNellis, Commented Apr 24, 2012 at 21:46
@Adam: true :-) However, my problem is a different one, as James points out. I'm not deleting the question here just in case someone else finds it by using different keywords. However, voted for a close. — Etan
– Etan, Commented Apr 24, 2012 at 21:49

Chris Dodd · Accepted Answer · 2012-04-25 16:49:03Z

4

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.

edited Apr 25, 2012 at 16:49

answered Apr 24, 2012 at 22:59

Chris Dodd

127k14 gold badges150 silver badges243 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Etan Over a year ago

Updated your answer with my final solution. Sorry, but the comments don't allow code regions to be inserted on separate lines.

Chris Dodd Over a year ago

The INVOKE macro doesn't even need the extra EXPAND calls, as the expansions from the INVOKE itself do everything you need.

Collectives™ on Stack Overflow

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

1 Answer 1

2 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

2 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related