471,086 Members | 1,188 Online
Bytes | Software Development & Data Engineering Community
Post +

Home Posts Topics Members FAQ

Join Bytes to post your question to a community of 471,086 software developers and data experts.

How to define a define that defines some defines ?

Hi all,

I have the following:

/*--- SNIP ---*/

typedef struct Argument_s
{
char *address;
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.
Nov 14 '05 #1
3 10249
theotyflos <tk**@in.gr> scribbled the following:
typedef struct Argument_s
{
char *address;
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 (pa*****@cc.helsinki.fi) ------------- Finland --------\
\-- http://www.helsinki.fi/~palaste --------------------- rules! --------/
"War! Huh! Good God, y'all! What is it good for? We asked Mayor Quimby."
- Kent Brockman
Nov 14 '05 #2
theotyflos wrote:
Hi all,

I have the following:

/*--- SNIP ---*/

typedef struct Argument_s
{
char *address;
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,
char * address,
int type,
int length)
{
arg->address = address;
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

Nov 14 '05 #3
In <c1**********@oravannahka.helsinki.fi> Joona I Palaste <pa*****@cc.helsinki.fi> 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: Da*****@ifh.de
Nov 14 '05 #4

This discussion thread is closed

Replies have been disabled for this discussion.

Similar topics

14 posts views Thread by Rajan | last post: by
4 posts views Thread by Vittal | last post: by
5 posts views Thread by Kevin | last post: by
3 posts views Thread by QQ | last post: by
6 posts views Thread by David Young | last post: by
2 posts views Thread by #define中的问题 | last post: by
17 posts views Thread by niraj.tiwari | last post: by
4 posts views Thread by Mohammad Omer Nasir | last post: by
6 posts views Thread by anirbid.banerjee | last post: by
4 posts views Thread by venkat | last post: by

By using Bytes.com and it's services, you agree to our Privacy Policy and Terms of Use.

To disable or enable advertisements and analytics tracking please visit the manage ads & tracking page.