Velocity Reviews > How to define a define that defines some defines ?

# How to define a define that defines some defines ?

theotyflos
Guest
Posts: n/a

 02-19-2004
Hi all,

I have the following:

/*--- SNIP ---*/

typedef struct Argument_s
{
int type;
int length;
} ARGUMENT;

#define Function(F) int F( int ArgCount, ARGUMENT ArgVector[] )

#define First ArgVector[0]
#define First_T First.type
#define First_L First.length
#define Second ArgVector[1]
#define Second_T Second.type
#define Second_L Second.length
#define Third ArgVector[2]
#define Third_T Third.type
#define Third_L Third.length

Function(One)
{
/* do something with First_A */
/* do something with First_T */
/* do something with First_L */
/* do something with Second_A */
/* do something with Second_T */
/* do something with Second_L */
/* do something with Third_A */
/* do something with Third_T */
/* do something with Third_L */
/* etc etc */
}

#define Apple ArgVector[0]
#define Apple_T Apple.type
#define Apple_L Apple.length
#define Orange ArgVector[1]
#define Orange_T Orange.type
#define Orange_L Orange.length

Function(Two)
{
/* do something with Apple_A */
/* do something with Apple_T */
/* do something with Apple_L */
/* do something with Orange_A */
/* do something with Orange_T */
/* do something with Orange_L */
/* etc etc */
}

/*--- SNIP ---*/

The question is: Is there a way instead of writing all those #defines
for the arguments (First, Second, etc), to write something like:

#define Arg(n) #define Arg ArgVector[n] \
#define Arg##_A Arg.address \
#define Arg##_T Arg.type \
#define Arg##_L Arg.length

and define the arguments like this:

Arg First(0)
Arg Second(1)
Arg Third(2)
Function(One)
.....
Arg Apple(0)
Arg Orange(1)
Function(Two)
.....

Thanks in advance everyone.

Joona I Palaste
Guest
Posts: n/a

 02-19-2004
theotyflos <(E-Mail Removed)> scribbled the following:
> typedef struct Argument_s
> {
> int type;
> int length;
> } ARGUMENT;

> #define Function(F) int F( int ArgCount, ARGUMENT ArgVector[] )

> #define First ArgVector[0]
> #define First_A First.address
> #define First_T First.type
> #define First_L First.length
> #define Second ArgVector[1]
> #define Second_A Second.address
> #define Second_T Second.type
> #define Second_L Second.length
> #define Third ArgVector[2]
> #define Third_A Third.address
> #define Third_T Third.type
> #define Third_L Third.length

> #define Apple ArgVector[0]
> #define Apple_A Apple.address
> #define Apple_T Apple.type
> #define Apple_L Apple.length
> #define Orange ArgVector[1]
> #define Orange_A Orange.address
> #define Orange_T Orange.type
> #define Orange_L Orange.length

> The question is: Is there a way instead of writing all those #defines
> for the arguments (First, Second, etc), to write something like:

> #define Arg(n) #define Arg ArgVector[n] \
> #define Arg##_A Arg.address \
> #define Arg##_T Arg.type \
> #define Arg##_L Arg.length

> and define the arguments like this:

> Arg First(0)
> Arg Second(1)
> Arg Third(2)
> Function(One)
> ....
> Arg Apple(0)
> Arg Orange(1)
> Function(Two)
> ....

No. The preprocessor is a one-pass utility. It is impossible for it to
#define its own directives.

--
/-- Joona Palaste ((E-Mail Removed)) ------------- Finland --------\
\-- http://www.helsinki.fi/~palaste --------------------- rules! --------/
"War! Huh! Good God, y'all! What is it good for? We asked Mayor Quimby."
- Kent Brockman

Dan Pop
Guest
Posts: n/a

 02-19-2004
In <c12d21\$1g6\$(E-Mail Removed)> Joona I Palaste <(E-Mail Removed)> writes:

>No. The preprocessor is a one-pass utility. It is impossible for it to
>#define its own directives.

But it (usually) can be invoked twice, the second invocation processing
the output of the first one. However, I have yet to find a *good*
reason for this approach...

Dan
--
Dan Pop
DESY Zeuthen, RZ group
Email: http://www.velocityreviews.com/forums/(E-Mail Removed)

Thomas Matthews
Guest
Posts: n/a

 02-19-2004
theotyflos wrote:

> Hi all,
>
> I have the following:
>
> /*--- SNIP ---*/
>
> typedef struct Argument_s
> {
> int type;
> int length;
> } ARGUMENT;
>
> #define Function(F) int F( int ArgCount, ARGUMENT ArgVector[] )
>
> #define First ArgVector[0]
> #define First_A First.address
> #define First_T First.type
> #define First_L First.length
> #define Second ArgVector[1]
> #define Second_A Second.address
> #define Second_T Second.type
> #define Second_L Second.length
> #define Third ArgVector[2]
> #define Third_A Third.address
> #define Third_T Third.type
> #define Third_L Third.length
>
> Function(One)
> {
> /* do something with First_A */
> /* do something with First_T */
> /* do something with First_L */
> /* do something with Second_A */
> /* do something with Second_T */
> /* do something with Second_L */
> /* do something with Third_A */
> /* do something with Third_T */
> /* do something with Third_L */
> /* etc etc */
> }
>
> #define Apple ArgVector[0]
> #define Apple_A Apple.address
> #define Apple_T Apple.type
> #define Apple_L Apple.length
> #define Orange ArgVector[1]
> #define Orange_A Orange.address
> #define Orange_T Orange.type
> #define Orange_L Orange.length
>
> Function(Two)
> {
> /* do something with Apple_A */
> /* do something with Apple_T */
> /* do something with Apple_L */
> /* do something with Orange_A */
> /* do something with Orange_T */
> /* do something with Orange_L */
> /* etc etc */
> }
>
> /*--- SNIP ---*/
>
> The question is: Is there a way instead of writing all those #defines
> for the arguments (First, Second, etc), to write something like:
>
> #define Arg(n) #define Arg ArgVector[n] \
> #define Arg##_A Arg.address \
> #define Arg##_T Arg.type \
> #define Arg##_L Arg.length
>
> and define the arguments like this:
>
> Arg First(0)
> Arg Second(1)
> Arg Third(2)
> Function(One)
> ....
> Arg Apple(0)
> Arg Orange(1)
> Function(Two)
> ....
>
>
> Thanks in advance everyone.

Looks like a better design is to have a function that
accesses the structures:
void Set_Arguments(struct Argument_s * arg,
int type,
int length)
{
arg->type = type;
arg->length = length;
return;
}

One could "Take it up a notch" by using constant identifiers:
#if NO_ENUMERATIONS
#define APPLE 0
#define ORANGE 1
#define WATERMELON 2
#else
enum {APPLE, ORANGE, WATERMELON};
#endif

struct Argument_s fruits[5];

/* ... */
Set_Arguments(&fruit[APPLE], "hello", 1, 25);

--
Thomas Matthews

C++ newsgroup welcome message:
http://www.slack.net/~shiva/welcome.txt
C++ Faq: http://www.parashift.com/c++-faq-lite
C Faq: http://www.eskimo.com/~scs/c-faq/top.html
alt.comp.lang.learn.c-c++ faq:
http://www.raos.demon.uk/acllc-c++/faq.html
Other sites:
http://www.josuttis.com -- C++ STL Library book