How to do a macro that creates other macros and...

[jorba101]

Using the GNU C preprocessor, I want to declare a macro able to declare other macros for me, so that I can do:

declare( ONE );
declare( TWO );
declare( THREE );

and I get following macros declared:

NUMBER_ONE (which substitutes 1)
NUMBER_TWO (which substitutes 2)
NUMBER_THREE (which substitutes 3)

e.g., right like if I had done:

#define NUMBER_ONE 1
#define NUMBER_ONE 2
#define NUMBER_ONE 3

this is, the macro would get the number accordingly to the order in which it has been declared.

I know I can do:

#define declare(NAME)  { #define NUMBER_ ## NAME 1 }

But I don't know how can I get the order in which the macros have been declared instead of the "1", e.g. something that could retrieve the order in which they have been declared.

I have gone through http://gcc.gnu.org/onlinedocs/gcc-4.3.0/cpp/ but couldn't figure out a way using that.

Anyone has got any idea?

Thanks.

[RRick]

I doubt you will be able to define a macro to define another macro, because who is going to read/decode the second macro? The second macro will need a separate pass to decode it. This is a chicken and the egg problem.

Take a look at this link for more info on preprocessors. The section on macros is cumbersome, but readable.
http://www.delorie.com/gnu/docs/gcc/cpp.html#SEC_To p

[jorba101]

Yes, right.

I really thought it was possible to define macros that defined other macros, but I see your point now.

Thanks.-

[Banfa]

You are doing it the wrong way round a trick, albeit one that can be confusing and make the code hard (impossible) to read, is to define a table of data and then redefine the defining macro to make use of the table to produce the effects you want.

so my table in a header called Table.h (for example)

[code=c]
#ifdef TABLE_DATA

TABLE_DATA(ONE, 1)
TABLE_DATA(TWO, 2)
TABLE_DATA(THRE E, 3)

#undef TABLE_DATA
#endif
[/code]

Note do not use inclusion protection round these lines because you may actually want to include the into another file more than once.

In a header somewhere

[code=c]
#define TABLE_DATA(name , value) extern const int NUMBER_ ## name;
#include "Table.h"

extern void PrintConstants( void);
[/code]

in a c file somewhere


[code=c]
#include <stdio.h>

#define TABLE_DATA(name , value) const int NUMBER_ ## name = value;
#include "Table.h"

void PrintConstants( void)
{
#define TABLE_DATA(name , value) printf("NUMBER_ " #name " = %d\n", NUMBER_ ## name);
#include "Table.h"
}
[/code]


This is a trivial example that could probably be done better a different way but I have worked with examples where the table has contained 10+ different values and the symbol has been defined 5 or 6 ways in the same file sometimes with as many as 10 lines of code per definition.

It isn't pretty, it isn't easy to understand but if the code is working, tested and robust then it does allow people using that module (rather than developing it) to have control by just altering the table data.

There are times when it is very useful.