Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

Is it possible to iterate over arguments in variadic macros?

I was wondering if it is possible to iterate over arguments passed to a variadic macro in C99 or using any GCC extensions ?

For e.g. is it possible to write a generic macro that takes a structure and its fields passed as arguments and prints offset of each field within the structure ?

Something like this:

 struct a {     int a;     int b;     int c; };  /* PRN_STRUCT_OFFSETS will print offset of each of the fields     within structure passed as the first argument. */  int main(int argc, char *argv[]) {     PRN_STRUCT_OFFSETS(struct a, a, b, c);      return 0; } 
like image 944
vshenoy Avatar asked Dec 09 '09 07:12

vshenoy


People also ask

Can you supply more than one argument in a macro call?

Yes. If you try untouchable(foo,first) you get an error because the macro only sees two parameters but was expecting 4.

How do you define Variadic arguments?

Here is an example: #define eprintf(...) fprintf (stderr, __VA_ARGS__) This kind of macro is called variadic. When the macro is invoked, all the tokens in its argument list after the last named argument (this macro has none), including any commas, become the variable argument.

What is #__ Va_args __?

16.3.An identifier __VA_ARGS__ that occurs in the replacement list shall be treated as if it were a parameter, and the variable arguments shall form the preprocessing tokens used to replace it. this is the same for varags as it is for normal parameters.


1 Answers

Here is my homework of the day, it's based on macro tricks and today I particularly learnt about __VA_NARG__ invented by Laurent Deniau. Anyway, the following sample code works up to 8 fields for the sake of clarity. Just extend the code by duplicating if you need more (this is because the preprocessor doesn't feature recursion, as it reads the file only once).

#include <stdio.h> #include <stddef.h>  struct a {   int a;   int b;   int c; };  struct b {   int a;   int b;   int c;   int d; };  #define STRINGIZE(arg)  STRINGIZE1(arg) #define STRINGIZE1(arg) STRINGIZE2(arg) #define STRINGIZE2(arg) #arg  #define CONCATENATE(arg1, arg2)   CONCATENATE1(arg1, arg2) #define CONCATENATE1(arg1, arg2)  CONCATENATE2(arg1, arg2) #define CONCATENATE2(arg1, arg2)  arg1##arg2  /* PRN_STRUCT_OFFSETS will print offset of each of the fields   within structure passed as the first argument.  */ #define PRN_STRUCT_OFFSETS_1(structure, field, ...) printf(STRINGIZE(structure)":"STRINGIZE(field)"-%d\n", offsetof(structure, field)); #define PRN_STRUCT_OFFSETS_2(structure, field, ...)\   printf(STRINGIZE(structure)":"STRINGIZE(field)"-%d\n", offsetof(structure, field));\   PRN_STRUCT_OFFSETS_1(structure, __VA_ARGS__) #define PRN_STRUCT_OFFSETS_3(structure, field, ...)\   printf(STRINGIZE(structure)":"STRINGIZE(field)"-%d\n", offsetof(structure, field));\   PRN_STRUCT_OFFSETS_2(structure, __VA_ARGS__) #define PRN_STRUCT_OFFSETS_4(structure, field, ...)\   printf(STRINGIZE(structure)":"STRINGIZE(field)"-%d\n", offsetof(structure, field));\   PRN_STRUCT_OFFSETS_3(structure, __VA_ARGS__) #define PRN_STRUCT_OFFSETS_5(structure, field, ...)\   printf(STRINGIZE(structure)":"STRINGIZE(field)"-%d\n", offsetof(structure, field));\  PRN_STRUCT_OFFSETS_4(structure, __VA_ARGS__) #define PRN_STRUCT_OFFSETS_6(structure, field, ...)\   printf(STRINGIZE(structure)":"STRINGIZE(field)"-%d\n", offsetof(structure, field));\   PRN_STRUCT_OFFSETS_5(structure, __VA_ARGS__) #define PRN_STRUCT_OFFSETS_7(structure, field, ...)\   printf(STRINGIZE(structure)":"STRINGIZE(field)"-%d\n", offsetof(structure, field));\   PRN_STRUCT_OFFSETS_6(structure, __VA_ARGS__) #define PRN_STRUCT_OFFSETS_8(structure, field, ...)\   printf(STRINGIZE(structure)":"STRINGIZE(field)"-%d\n", offsetof(structure, field));\   PRN_STRUCT_OFFSETS_7(structure, __VA_ARGS__)  #define PRN_STRUCT_OFFSETS_NARG(...) PRN_STRUCT_OFFSETS_NARG_(__VA_ARGS__, PRN_STRUCT_OFFSETS_RSEQ_N()) #define PRN_STRUCT_OFFSETS_NARG_(...) PRN_STRUCT_OFFSETS_ARG_N(__VA_ARGS__)  #define PRN_STRUCT_OFFSETS_ARG_N(_1, _2, _3, _4, _5, _6, _7, _8, N, ...) N  #define PRN_STRUCT_OFFSETS_RSEQ_N() 8, 7, 6, 5, 4, 3, 2, 1, 0  #define PRN_STRUCT_OFFSETS_(N, structure, field, ...) CONCATENATE(PRN_STRUCT_OFFSETS_, N)(structure, field, __VA_ARGS__)  #define PRN_STRUCT_OFFSETS(structure, field, ...) PRN_STRUCT_OFFSETS_(PRN_STRUCT_OFFSETS_NARG(field, __VA_ARGS__), structure, field, __VA_ARGS__)  int main(int argc, char *argv[]) {   PRN_STRUCT_OFFSETS(struct a, a, b, c);   printf("\n");   PRN_STRUCT_OFFSETS(struct b, a, b, c, d);    return 0; } 

which prints out:

struct a:a-0 struct a:b-4 struct a:c-8  struct b:a-0 struct b:b-4 struct b:c-8 struct b:d-12 

EDIT: Here is a slightly different version that tries to be more generic. The FOR_EACH(what, ...) macro applies what to every other argument in the variable argument list.

So, you just have to define a macro that takes a single argument like this:

#define DO_STUFF(x) foo(x) 

which is going to be applied to every argument in the list. So, for your typical example you need to hack a bit but it still remains concise:

#define PRN_STRUCT_OFFSETS_(structure, field) printf(STRINGIZE(structure)":"STRINGIZE(field)" - offset = %d\n", offsetof(structure, field)); #define PRN_STRUCT_OFFSETS(field) PRN_STRUCT_OFFSETS_(struct a, field) 

And you apply it like this:

FOR_EACH(PRN_STRUCT_OFFSETS, a, b, c); 

Finally, a complete sample program:

#include <stdio.h> #include <stddef.h>  struct a {   int a;   int b;   int c; };  #define STRINGIZE(arg)  STRINGIZE1(arg) #define STRINGIZE1(arg) STRINGIZE2(arg) #define STRINGIZE2(arg) #arg  #define CONCATENATE(arg1, arg2)   CONCATENATE1(arg1, arg2) #define CONCATENATE1(arg1, arg2)  CONCATENATE2(arg1, arg2) #define CONCATENATE2(arg1, arg2)  arg1##arg2  #define FOR_EACH_1(what, x, ...) what(x) #define FOR_EACH_2(what, x, ...)\   what(x);\   FOR_EACH_1(what,  __VA_ARGS__); #define FOR_EACH_3(what, x, ...)\   what(x);\   FOR_EACH_2(what, __VA_ARGS__); #define FOR_EACH_4(what, x, ...)\   what(x);\   FOR_EACH_3(what,  __VA_ARGS__); #define FOR_EACH_5(what, x, ...)\   what(x);\  FOR_EACH_4(what,  __VA_ARGS__); #define FOR_EACH_6(what, x, ...)\   what(x);\   FOR_EACH_5(what,  __VA_ARGS__); #define FOR_EACH_7(what, x, ...)\   what(x);\   FOR_EACH_6(what,  __VA_ARGS__); #define FOR_EACH_8(what, x, ...)\   what(x);\   FOR_EACH_7(what,  __VA_ARGS__);  #define FOR_EACH_NARG(...) FOR_EACH_NARG_(__VA_ARGS__, FOR_EACH_RSEQ_N()) #define FOR_EACH_NARG_(...) FOR_EACH_ARG_N(__VA_ARGS__)  #define FOR_EACH_ARG_N(_1, _2, _3, _4, _5, _6, _7, _8, N, ...) N  #define FOR_EACH_RSEQ_N() 8, 7, 6, 5, 4, 3, 2, 1, 0  #define FOR_EACH_(N, what, x, ...) CONCATENATE(FOR_EACH_, N)(what, x, __VA_ARGS__) #define FOR_EACH(what, x, ...) FOR_EACH_(FOR_EACH_NARG(x, __VA_ARGS__), what, x, __VA_ARGS__)  #define PRN_STRUCT_OFFSETS_(structure, field) printf(STRINGIZE(structure)":"STRINGIZE(field)" - offset = %d\n", offsetof(structure, field)); #define PRN_STRUCT_OFFSETS(field) PRN_STRUCT_OFFSETS_(struct a, field)  int main(int argc, char *argv[]) {   FOR_EACH(PRN_STRUCT_OFFSETS, a, b, c);   printf("\n");    return 0; } 
like image 179
Gregory Pakosz Avatar answered Sep 23 '22 19:09

Gregory Pakosz