X-macros: how to make the list of variables compile-time configurable?

Question

I have code similar to

#define LIST_OF_VARIABLES \
    X(value1) \
    X(value2) \
    X(value3)

as explained in https://en.wikipedia.org/wiki/X_Macro

Now I have the need to make the LIST_OF_VARIABLES configurable at compile time

So it could effectively be e.g.

#define LIST_OF_VARIABLES \
    X(default_value1) \
    X(cust_value2) \
    X(default_value3)

or e.g.

#define LIST_OF_VARIABLES \
    X(default_value1) \
    X(default_value2) \
    X(cust_value3)

depending on some macros previously defined. The LIST_OF_VARIABLES is long and the customizations are relatively small. I would not like to copy the long list for each customization, because that will cause maintenance issues (the DRY principle https://en.wikipedia.org/wiki/Don%27t_repeat_yourself). As a matter of fact the LIST_OF_VARIABLES should be in one file and the customizations elsewhere (either another file or just -D options in the Makefile)

In pseudo-code I was thinking of something like

#define X(arg) \
  #ifdef CUST_##arg  \
    Y(CUST_##arg)    \
  #else              \
    Y(DEFAULT_##arg) \
  #endif

And then use the X-macros under the name Y.

But of course that does not work, because a macro cannot contain preprocessor directives.

What would be a way to achieve this? C is a must (no templates or Boost macros), gcc specific solutions are acceptable.

Answer 1

Given further context, it appears you want to be able to cherry pick individual values from your list at compile time. I think you might be interested in a preprocessor switch, which can accomplish what you're using preprocessor conditionals for with a lot less boilerplate.

Generic preprocessor switch

Here's a brief framework:

#define GLUEI(A,B) A##B
#define GLUE(A,B) GLUEI(A,B)
#define SECONDI(A,B,...) B
#define SECOND(...) SECONDI(__VA_ARGS__,,)
#define SWITCH(NAME_, PATTERN_, DEFAULT_) SECOND(GLUE(NAME_,PATTERN_), DEFAULT_)

SWITCH macro usage

Invoke SWITCH(MY_PREFIX_,SPECIFIC_IDENTIFIER,DEFAULT_VALUE) to expand everything that is not a matching pattern to DEFAULT_VALUE. Things that are a matching pattern can expand to whatever you map them to.

To create a matching pattern, define an object like macro called MY_PREFIX_SPECIFIC_IDENTIFIER, whose replacement list consists of a single comma followed by the value you want the SWITCH to expand to in this case.

The magic here is simply that SWITCH builds a hidden token, giving it a chance to expand (well, in this implementation SECOND's indirection is also significant), and inject a new second argument to SECOND if it's defined. Nominally this new token isn't defined; in such cases, it simply becomes the first argument to SECOND, which just discards it, never to be seen again.

For example, given the above macros:

#define CONTRACT_IDENTIFIER_FOR_DEFAULT , overridden_id_for_default
#define CONTRACT_IDENTIFIER_FOR_SIGNED  , overridden_id_for_signed
SWITCH(CONTRACT_IDENTIFIER_FOR_, DRAFT     , draft      )
SWITCH(CONTRACT_IDENTIFIER_FOR_, DRAWN     , drawn      )
SWITCH(CONTRACT_IDENTIFIER_FOR_, PROOFED   , proofed    )
SWITCH(CONTRACT_IDENTIFIER_FOR_, DELIVERED , delivered  )
SWITCH(CONTRACT_IDENTIFIER_FOR_, SIGNED    , signed     )
SWITCH(CONTRACT_IDENTIFIER_FOR_, FULFILLED , fulfilled  )
SWITCH(CONTRACT_IDENTIFIER_FOR_, DEFAULT   , default    )

...will expand to:

draft
drawn
proofed
delivered
overridden_id_for_signed
fulfilled
overridden_id_for_default

Decorated X Macros

Assuming you wish to give your values names, and simply replace cherry picked values from the command line, you can make use of SWITCH to do something like this:

#define VARVALUE(N_,V_) SWITCH(VALUE_FOR_, N_, V_)

#define LIST_OF_VARIABLES \
    X(VARVALUE(value1, default_value1)) \
    X(VARVALUE(value2, default_value2)) \
    X(VARVALUE(value3, default_value3))

The VARVALUE macros will be applied first in this form. To override a specific value, you can define your pattern matcher using either a #define:

#define VALUE_FOR_value2 , custom_value2

...or on the command line/makefile:

CFLAGS += -DVALUE_FOR_value2=,custom_value2

Disable/insertion using switch macro

To support disabling individual items safely, nest two switches and add an EAT macro to catch the entry:

#define EAT(...)
#define SELECT_ITEM_MACRO_FOR_STATE_ON , X
#define X_IF_ENABLED(N_, V_) \
          SWITCH(SELECT_ITEM_MACRO_FOR_STATE_, SWITCH(ENABLE_VALUE_, N_, ON), EAT) \
          (SWITCH(VALUE_FOR_, N_, V_))

#define LIST_OF_VARIABLES \
     X_IF_ENABLED(value1, default_value1) \
     X_IF_ENABLED(value2, default_value2) \
     X_IF_ENABLED(value3, default_value3)

Just as before, individual macros can be overridden using VALUE_FOR_valuex pattern macros, but this also allows disabling items using ENABLE_VALUE_valuex macros, which can be set to anything but ,ON to disable that item.

Similarly, one way to add support for inserting values is to flip the idea:

#define ADD_ITEM_MACRO_FOR_STATE_EAT , EAT
#define X_IF_ADDED(N_) \
          SWITCH(ADD_ITEM_MACRO_FOR_STATE_, SWITCH(VALUE_FOR_, N_, EAT), X) \
          (SECOND(GLUE(VALUE_FOR_,N_)))

#define LIST_OF_VARIABLES \
     X_IF_ENABLED(value1, default_value1) \
     X_IF_ENABLED(value2, default_value2) \
     X_IF_ENABLED(value3, default_value3) \
     X_IF_ADDED(value4) \
     X_IF_ADDED(value5) \
     X_IF_ADDED(value6)

...this allows you to define VALUE_FOR_value4 as a a pattern macro, but by default will expand to nothing.

Summary

The framework supporting setting, removing, or inserting values winds up being:

#define GLUEI(A,B) A##B
#define GLUE(A,B) GLUEI(A,B)
#define SECONDI(A,B,...) B
#define SECOND(...) SECONDI(__VA_ARGS__,,)
#define SWITCH(NAME_, PATTERN_, DEFAULT_) SECOND(GLUE(NAME_,PATTERN_), DEFAULT_)
#define EAT(...)

#define SELECT_ITEM_MACRO_FOR_STATE_ON , X
#define X_IF_ENABLED(N_, V_) \
          SWITCH(SELECT_ITEM_MACRO_FOR_STATE_, SWITCH(ENABLE_VALUE_, N_, ON), EAT) \
          (SWITCH(VALUE_FOR_, N_, V_))
#define ADD_ITEM_MACRO_FOR_STATE_EAT , EAT
#define X_IF_ADDED(N_) \
          SWITCH(ADD_ITEM_MACRO_FOR_STATE_, SWITCH(VALUE_FOR_, N_, EAT), X) \
          (SECOND(GLUE(VALUE_FOR_,N_)))

Given this framework, your list macro would be comprised of a series of X(value), X_IF_ENABLED(name,default_value), and/or X_IF_ADDED(name) values, where:

• X(value) can be used to always insert a call to the X macro with value
• X_IF_ENABLED(name,default_value) will call X with default_value, allowing you to override the default based on name.
• X_IF_ADDED(name) will provide an "empty slot" with name, which will do nothing unless you override that slot.

Overriding slots is done by defining VALUE_FOR_name to expand to ,replacement. Disabling enabled slots is done by defining ENABLE_VALUE_name to expand to ,OFF.

Demo showing change, removal, addition using command line

Answer 2

Answering myself.

With help of the comments I came up with a solution that works and meets most requirements I had mentioned

With the "main code"

$cat main.c
#ifndef VALUE1
#define VALUE1 value1
#endif
#ifndef VALUE2
#define VALUE2 value2
#endif
#ifndef VALUE3
#define VALUE3 value3
#endif

#define LIST_OF_VARIABLES \
  X(VALUE1) \
  X(VALUE2) \
  X(VALUE3)

and a customization file like

$cat cust1
-DVALUE2=value2cust

the code can be compiled using (GNUmake pseudo syntax)

 $(CC) $(CFLAGS) $(shell cat cust1) main.c

Actually having the extra indirection with every value defined on a single line is good, because it allows commenting the values. That would not have been possible with the continuation lines in the single LIST_OF_VARIABLES macro.

Edit: Not true. A COMMENT(foo) macro expanding to nothing would have solved that issue, too. (Credit: Got the idea from the answer posted by @Jonathan Leffer.)

However the approach does not yet meet the following requirements I hadn't mentioned

• no ugly boilerplate code (all these #ifndef lines are not really nice)
• customization should also make it possible to drop default values from the list altogether or add completely new values (yes, this could probably be done with some ugly dummy code already now)

So not really satisfied yet with my own answer. Need to think about the approach from the Dr. Dobbs article a bit more, maybe that can be used. Open for better answers.

Answer 3

I think that what you have to do is along the lines of:

#ifdef USE_DEFAULT_VALUE1
    #define X_DEFAULT_VALUE1 X(default_value1)
#else
    #define X_DEFAULT_VALUE1 /* omitted */
#endif
#ifdef USE_DEFAULT_VALUE2
    #define X_DEFAULT_VALUE2 X(default_value2)
#else
    #define X_DEFAULT_VALUE2 /* omitted */
#endif
#ifdef USE_DEFAULT_VALUE3
    #define X_DEFAULT_VALUE3 X(default_value3)
#else
    #define X_DEFAULT_VALUE3 /* omitted */
#endif

#ifdef USE_CUST_VALUE1
    #define X_CUST_VALUE1 X(cust_value1)
#else
    #define X_CUST_VALUE1 /* omitted */
#endif
#ifdef USE_CUST_VALUE2
    #define X_CUST_VALUE2 X(cust_value2)
#else
    #define X_CUST_VALUE2 /* omitted */
#endif

#define LIST_OF_VARIABLES \
    X_DEFAULT_VALUE1 \
    X_DEFAULT_VALUE2 \
    X_DEFAULT_VALUE3 \
    X_CUST_VALUE1 \
    X_CUST_VALUE2 \

You then need to define USE_DEFAULT_VALUE1 etc as required for the specific configuration you are after.

As long as you always need the items in the same order, this is sufficient. If you need them in different orders, then you conditionally define LIST_OF_VARIABLES in the different sequences.