title: C macro tricks keywords:c,macro,c11,generics # C macro tricks ## GCC preprocess macros If you need to run just macro preprocessor without running compiler use ```bash gcc -E source.c ``` this allows to see resulting source that going to be compiled, macro errors could be hard to debug, but this is first thing, test them before and then be sure that everything works. Lets continue with some more deep stuff. ## __VA_ARGS__ keyword ### Single argument macros Writting macros with single argument ```c #define F(X) X ``` #### Source So lets code just with one macro ```c #define F(X) X F(int main) F((){) F(printf("hello world\n");) F(}) ``` any kind of argument can be passed to macro, and that allows to make some tricks #### Result ```c int main (){ printf("hello world\n"); } ``` ### Multi argument macro writting macro with multiple unamed arguments ```c #define F(...) __VA_ARGS__ ``` #### Source ```c #define F(...) __VA_ARGS__ F(int main) F((){) F(printf("hello world\n");) F(}) F(1,2,3,4,5) ``` Previouse example works just fine, but if add multiple arguments the __VA_ARGS__ just prints them as a whole string #### Result ```c int main (){ printf("hello world\n"); } 1,2,3,4,5 ``` ### Mixing named arguments and unamed arguments Mixing together named and unnamed arguments ```c #define F(X,...) X __VA_ARGS ``` #### Source ```c #define F1(X,...) __VA_ARGS__ #define F2(X,...) X F1(1,2,3,4,5) F2(1,2,3,4,5) F1(int main,{my code},{more code}) F2(int main,{my code},{more code}) ``` #### Result ```c 2,3,4,5 1 {my code},{more code} int main ``` ## Define struct with macros Lets move to some more practical example lets just define macro that going to create proper C structure. C structure have this kind of syntax ```block struct { ; ; ... ... }; ``` ```c #define N #define M2(X1,X2,...) X1 X2; #define M1(X1,X2,...) X1 X2; M2(__VA_ARGS__,N,N) #define M(X,...) struct X {M1(__VA_ARGS__,N,N)}; ``` Here we pass variable arguments first macro M preprocess first arguments and pass all left-over aruments with __VA_ARGS__ to M1, M1 preprocess 2 arguments (2nd,3rd) and pass left-over arguments to next M2 macro. There is small trict to make support any number of arguments, there is defined macro N that is just empty macro, so macro M support any number of arguments and if there is not define needed amount of arguments N is passed, and if there is not enought arguments N is used. #### Source ```c #define N #define M2(X1,X2,...) X1 X2; #define M1(X1,X2,...) X1 X2; M2(__VA_ARGS__,N,N) #define M(X,...) struct X {M1(__VA_ARGS__,N,N)}; M(add,int,a,int,b); M(dirst,int,c); ``` #### Result ``` struct add {int a; int b;};; struct dirst {int c; ;};; ``` ## Detect number of arguments There is one trick that can be used to detect number of arguments passed to macro. This common example found in internet. There could be made some improvment or can be added some trickery. But for now most important feature is that it works. ```c #define PP_NARG(...) \ PP_NARG_(__VA_ARGS__,PP_RSEQ_N()) #define PP_NARG_(...) \ PP_ARG_N(__VA_ARGS__) #define PP_ARG_N( \ _1, _2, _3, _4, _5, _6, _7, _8, _9,_10, \ _11,_12,_13,_14,_15,_16,_17,_18,_19,_20, \ _21,_22,_23,_24,_25,_26,_27,_28,_29,_30, \ _31,_32,_33,_34,_35,_36,_37,_38,_39,_40, \ _41,_42,_43,_44,_45,_46,_47,_48,_49,_50, \ _51,_52,_53,_54,_55,_56,_57,_58,_59,_60, \ _61,_62,_63, N, ...) N #define PP_RSEQ_N() \ 63,62,61,60, \ 59,58,57,56,55,54,53,52,51,50, \ 49,48,47,46,45,44,43,42,41,40, \ 39,38,37,36,35,34,33,32,31,30, \ 29,28,27,26,25,24,23,22,21,20, \ 19,18,17,16,15,14,13,12,11,10, \ 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 ``` #### Source ```c #define F(...) PP_NARG(__VA_ARGS__) F(0) F() F(1,2,3,4,5) ``` #### Result ``` 1 1 5 ``` ## Variable argument macro match macro according number of arguments Detect number of arguments and match macro according to number of arguments ```c #define FUN3(X1,X2,X3,...) "there is 3" #define FUN2(X1,X2,...) "there is 2" #define FUN1(X1,...) "there is 1" #define FUNN(X,A) X ## A #define FUNN1(X,A) FUNN(X,A) #define FUN(X,...) void X ( FUNN1(FUN,PP_NARG(__VA_ARGS__))(__VA_ARGS__)) ``` #### Source ```c FUN(add,int a,int b); FUN(mul,int a,int b,int c); FUN(div,int a); ``` #### Result ```c void add ( "there is 2"); void mul ( "there is 3"); void div ( "there is 1"); ``` ## C11 generics ### Match single argument Best part of it that it can match also typdefed structures. So now macroses can contain typechecking ```c #define type_str(T) _Generic( (T), int: "int",\ long: "long",\ A: "A",\ default: "Unknown type") ``` #### Source ```c typedef struct A { } A; #define type_str(T) _Generic( (T), int: "int",\ long: "long",\ A: "A",\ default: "Unknown type") int main() { A a; printf("%s\n",type_str((long)1)); printf("%s\n",type_str((int)1)); printf("%s\n",type_str(a)); } ``` #### Result ```block long int A ``` ### Match multiple arguments ``` #define type_str(T1,T2) _Generic( (T1),\ int: _Generic((T2),int:"int int", long: "int long", float: "int float", A: "int A", default: "int UNK"),\ long: _Generic((T2),int:"long int", long: "long long", float: "long float", A: "long A", default: "long UNK"),\ float: _Generic((T2),int:"float int", long: "float long", float: "float float", A: "float A", default: "float UNK"),\ A: _Generic((T2),int:"A int", long: "A long", float: "A float", A: "A A", default: "A UNK"),\ default: "UNK UNK" ) ``` #### Source ```c typedef struct A { } A; #define type_str(T1,T2) _Generic( (T1),\ int: _Generic((T2),int:"int int", long: "int long", float: "int float", A: "int A", default: "int UNK"),\ long: _Generic((T2),int:"long int", long: "long long", float: "long float", A: "long A", default: "long UNK"),\ float: _Generic((T2),int:"float int", long: "float long", float: "float float", A: "float A", default: "float UNK"),\ A: _Generic((T2),int:"A int", long: "A long", float: "A float", A: "A A", default: "A UNK"),\ default: "UNK UNK" ) int main() { A a; printf("%s\n",type_str((long)1,1.f)); printf("%s\n",type_str((int)1,1)); printf("%s\n",type_str(a,a)); } ``` #### Result ``` long float int int A A ``` ### Generic printf ```c #define FF "%f " #define FS "%s " #define FD "%d " #define N "" #define PR2(S,T,T1,T2,...) printf(S,T,T1) #define PR1(S,T,T1,...) _Generic((T1),\ int: PR2(S FD,T,T1,__VA_ARGS__,N,N,N),\ float:PR2(S FF,T,T1,__VA_ARGS__,N,N,N),\ char*:PR2(S FS,T,T1,__VA_ARGS__,N,N,N),\ default:"") #define static_printf(T1,...) _Generic((T1),\ int: PR1(FD,T1,__VA_ARGS__,N,N,N),\ float:PR1(FF,T1,__VA_ARGS__,N,N,N),\ char*:PR1(FS,T1,__VA_ARGS__,N,N,N),\ default:"") ``` #### Source ```c int main() { A a; int b = 3, c = 4; static_printf(1, 2.f); printf("\n"); static_printf(b,c); printf("\n"); static_printf("big float",0.01f); printf("\n"); } ``` #### Result ```bash 1 2.000000 3 4 big float 0.010000 ``` ## Links 1. [https://baike.baidu.com/item/C11](https://baike.baidu.com/item/C11)