How to write a while loop with the C preprocessor? - c
I am asking this question from an educational/hacking point of view, (I wouldn't really want to code like this).
Is it possible to implement a while loop only using C preprocessor directives. I understand that macros cannot be expanded recursively, so how would this be accomplished?
If you want to implement a while loop, you will need to use recursion in the preprocessor. The easiest way to do recursion is to use a deferred expression. A deferred expression is an expression that requires more scans to fully expand:
#define EMPTY()
#define DEFER(id) id EMPTY()
#define OBSTRUCT(id) id DEFER(EMPTY)()
#define EXPAND(...) __VA_ARGS__
#define A() 123
A() // Expands to 123
DEFER(A)() // Expands to A () because it requires one more scan to fully expand
EXPAND(DEFER(A)()) // Expands to 123, because the EXPAND macro forces another scan
Why is this important? Well when a macro is scanned and expanding, it creates a disabling context. This disabling context will cause a token, that refers to the currently expanding macro, to be painted blue. Thus, once its painted blue, the macro will no longer expand. This is why macros don't expand recursively. However, a disabling context only exists during one scan, so by deferring an expansion we can prevent our macros from becoming painted blue. We will just need to apply more scans to the expression. We can do that using this EVAL macro:
#define EVAL(...) EVAL1(EVAL1(EVAL1(__VA_ARGS__)))
#define EVAL1(...) EVAL2(EVAL2(EVAL2(__VA_ARGS__)))
#define EVAL2(...) EVAL3(EVAL3(EVAL3(__VA_ARGS__)))
#define EVAL3(...) EVAL4(EVAL4(EVAL4(__VA_ARGS__)))
#define EVAL4(...) EVAL5(EVAL5(EVAL5(__VA_ARGS__)))
#define EVAL5(...) __VA_ARGS__
Next, we define some operators for doing some logic(such as if, etc):
#define CAT(a, ...) PRIMITIVE_CAT(a, __VA_ARGS__)
#define PRIMITIVE_CAT(a, ...) a ## __VA_ARGS__
#define CHECK_N(x, n, ...) n
#define CHECK(...) CHECK_N(__VA_ARGS__, 0,)
#define NOT(x) CHECK(PRIMITIVE_CAT(NOT_, x))
#define NOT_0 ~, 1,
#define COMPL(b) PRIMITIVE_CAT(COMPL_, b)
#define COMPL_0 1
#define COMPL_1 0
#define BOOL(x) COMPL(NOT(x))
#define IIF(c) PRIMITIVE_CAT(IIF_, c)
#define IIF_0(t, ...) __VA_ARGS__
#define IIF_1(t, ...) t
#define IF(c) IIF(BOOL(c))
Now with all these macros we can write a recursive WHILE macro. We use a WHILE_INDIRECT macro to refer back to itself recursively. This prevents the macro from being painted blue, since it will expand on a different scan(and using a different disabling context). The WHILE macro takes a predicate macro, an operator macro, and a state(which is the variadic arguments). It keeps applying this operator macro to the state until the predicate macro returns false(which is 0).
#define WHILE(pred, op, ...) \
IF(pred(__VA_ARGS__)) \
( \
OBSTRUCT(WHILE_INDIRECT) () \
( \
pred, op, op(__VA_ARGS__) \
), \
__VA_ARGS__ \
)
#define WHILE_INDIRECT() WHILE
For demonstration purposes, we are just going to create a predicate that checks when number of arguments are 1:
#define NARGS_SEQ(_1,_2,_3,_4,_5,_6,_7,_8,N,...) N
#define NARGS(...) NARGS_SEQ(__VA_ARGS__, 8, 7, 6, 5, 4, 3, 2, 1)
#define IS_1(x) CHECK(PRIMITIVE_CAT(IS_1_, x))
#define IS_1_1 ~, 1,
#define PRED(x, ...) COMPL(IS_1(NARGS(__VA_ARGS__)))
Next we create an operator, which we will just concat two tokens. We also create a final operator(called M) that will process the final output:
#define OP(x, y, ...) CAT(x, y), __VA_ARGS__
#define M(...) CAT(__VA_ARGS__)
Then using the WHILE macro:
M(EVAL(WHILE(PRED, OP, x, y, z))) //Expands to xyz
Of course, any kind of predicate or operator can be passed to it.
Take a look at the Boost preprocessor library, which allows you to write loops in the preprocessor, and much more.
You use recursive include files. Unfortunately, you can't iterate the loop more than the maximum depth that the preprocessor allows.
It turns out that C++ templates are Turing Complete and can be used in similar ways. Check out Generative Programming
I use meta-template programming for this purpose, its fun once you get a hang of it. And very useful at times when used with discretion. Because as mentioned its turing complete, to the point where you can even cause the compiler to get into an infinite loop, or stack-overflow! There is nothing like going to get some coffee just to find your compilation is using up 30+ gigabytes of memory and all the CPU to compile your infinite loop code!
well, not that it's a while loop, but a counter loop, nonetheless the loop is possible in clean CPP (no templates and no C++)
#ifdef pad_always
#define pad(p,f) p##0
#else
#define pad0(p,not_used) p
#define pad1(p,not_used) p##0
#define pad(p,f) pad##f(p,)
#endif
// f - padding flag
// p - prefix so far
// a,b,c - digits
// x - action to invoke
#define n0(p,x)
#define n1(p,x) x(p##1)
#define n2(p,x) n1(p,x) x(p##2)
#define n3(p,x) n2(p,x) x(p##3)
#define n4(p,x) n3(p,x) x(p##4)
#define n5(p,x) n4(p,x) x(p##5)
#define n6(p,x) n5(p,x) x(p##6)
#define n7(p,x) n6(p,x) x(p##7)
#define n8(p,x) n7(p,x) x(p##8)
#define n9(p,x) n8(p,x) x(p##9)
#define n00(f,p,a,x) n##a(pad(p,f),x)
#define n10(f,p,a,x) n00(f,p,9,x) x(p##10) n##a(p##1,x)
#define n20(f,p,a,x) n10(f,p,9,x) x(p##20) n##a(p##2,x)
#define n30(f,p,a,x) n20(f,p,9,x) x(p##30) n##a(p##3,x)
#define n40(f,p,a,x) n30(f,p,9,x) x(p##40) n##a(p##4,x)
#define n50(f,p,a,x) n40(f,p,9,x) x(p##50) n##a(p##5,x)
#define n60(f,p,a,x) n50(f,p,9,x) x(p##60) n##a(p##6,x)
#define n70(f,p,a,x) n60(f,p,9,x) x(p##70) n##a(p##7,x)
#define n80(f,p,a,x) n70(f,p,9,x) x(p##80) n##a(p##8,x)
#define n90(f,p,a,x) n80(f,p,9,x) x(p##90) n##a(p##9,x)
#define n000(f,p,a,b,x) n##a##0(f,pad(p,f),b,x)
#define n100(f,p,a,b,x) n000(f,p,9,9,x) x(p##100) n##a##0(1,p##1,b,x)
#define n200(f,p,a,b,x) n100(f,p,9,9,x) x(p##200) n##a##0(1,p##2,b,x)
#define n300(f,p,a,b,x) n200(f,p,9,9,x) x(p##300) n##a##0(1,p##3,b,x)
#define n400(f,p,a,b,x) n300(f,p,9,9,x) x(p##400) n##a##0(1,p##4,b,x)
#define n500(f,p,a,b,x) n400(f,p,9,9,x) x(p##500) n##a##0(1,p##5,b,x)
#define n600(f,p,a,b,x) n500(f,p,9,9,x) x(p##600) n##a##0(1,p##6,b,x)
#define n700(f,p,a,b,x) n600(f,p,9,9,x) x(p##700) n##a##0(1,p##7,b,x)
#define n800(f,p,a,b,x) n700(f,p,9,9,x) x(p##800) n##a##0(1,p##8,b,x)
#define n900(f,p,a,b,x) n800(f,p,9,9,x) x(p##900) n##a##0(1,p##9,b,x)
#define n0000(f,p,a,b,c,x) n##a##00(f,pad(p,f),b,c,x)
#define n1000(f,p,a,b,c,x) n0000(f,p,9,9,9,x) x(p##1000) n##a##00(1,p##1,b,c,x)
#define n2000(f,p,a,b,c,x) n1000(f,p,9,9,9,x) x(p##2000) n##a##00(1,p##2,b,c,x)
#define n3000(f,p,a,b,c,x) n2000(f,p,9,9,9,x) x(p##3000) n##a##00(1,p##3,b,c,x)
#define n4000(f,p,a,b,c,x) n3000(f,p,9,9,9,x) x(p##4000) n##a##00(1,p##4,b,c,x)
#define n5000(f,p,a,b,c,x) n4000(f,p,9,9,9,x) x(p##5000) n##a##00(1,p##5,b,c,x)
#define n6000(f,p,a,b,c,x) n5000(f,p,9,9,9,x) x(p##6000) n##a##00(1,p##6,b,c,x)
#define n7000(f,p,a,b,c,x) n6000(f,p,9,9,9,x) x(p##7000) n##a##00(1,p##7,b,c,x)
#define n8000(f,p,a,b,c,x) n7000(f,p,9,9,9,x) x(p##8000) n##a##00(1,p##8,b,c,x)
#define n9000(f,p,a,b,c,x) n8000(f,p,9,9,9,x) x(p##9000) n##a##00(1,p##9,b,c,x)
#define n00000(f,p,a,b,c,d,x) n##a##000(f,pad(p,f),b,c,d,x)
#define n10000(f,p,a,b,c,d,x) n00000(f,p,9,9,9,9,x) x(p##10000) n##a##000(1,p##1,b,c,d,x)
#define n20000(f,p,a,b,c,d,x) n10000(f,p,9,9,9,9,x) x(p##20000) n##a##000(1,p##2,b,c,d,x)
#define n30000(f,p,a,b,c,d,x) n20000(f,p,9,9,9,9,x) x(p##30000) n##a##000(1,p##3,b,c,d,x)
#define n40000(f,p,a,b,c,d,x) n30000(f,p,9,9,9,9,x) x(p##40000) n##a##000(1,p##4,b,c,d,x)
#define n50000(f,p,a,b,c,d,x) n40000(f,p,9,9,9,9,x) x(p##50000) n##a##000(1,p##5,b,c,d,x)
#define n60000(f,p,a,b,c,d,x) n50000(f,p,9,9,9,9,x) x(p##60000) n##a##000(1,p##6,b,c,d,x)
#define n70000(f,p,a,b,c,d,x) n60000(f,p,9,9,9,9,x) x(p##70000) n##a##000(1,p##7,b,c,d,x)
#define n80000(f,p,a,b,c,d,x) n70000(f,p,9,9,9,9,x) x(p##80000) n##a##000(1,p##8,b,c,d,x)
#define n90000(f,p,a,b,c,d,x) n80000(f,p,9,9,9,9,x) x(p##90000) n##a##000(1,p##9,b,c,d,x)
#define cycle5(c1,c2,c3,c4,c5,x) n##c1##0000(0,,c2,c3,c4,c5,x)
#define cycle4(c1,c2,c3,c4,x) n##c1##000(0,,c2,c3,c4,x)
#define cycle3(c1,c2,c3,x) n##c1##00(0,,c2,c3,x)
#define cycle2(c1,c2,x) n##c1##0(0,,c2,x)
#define cycle1(c1,x) n##c1(,x)
#define concat(a,b,c) a##b##c
#define ck(arg) a[concat(,arg,-1)]++;
#define SIZEOF(x) (sizeof(x) / sizeof((x)[0]))
void check5(void)
{
int i, a[32769];
for (i = 0; i < SIZEOF(a); i++) a[i]=0;
cycle5(3,2,7,6,9,ck);
for (i = 0; i < SIZEOF(a); i++) if (a[i] != 1) printf("5: [%d] = %d\n", i+1, a[i]);
}
Here's an abuse of the rules that would get it done legally. Write your own C preprocessor. Make it interpret some #pragma directives the way you want.
I found this scheme useful when the compiler got cranky and wouldn't unroll certain loops for me
#define REPEAT20(x) { x;x;x;x;x;x;x;x;x;x;x;x;x;x;x;x;x;x;x;x;}
REPEAT20( val = pleaseconverge(val) );
But IMHO, if you need something much more complicated than that, then you should write your own pre-preprocessor. Your pre-preprocessor could for instance generate an appropriate header file for you, and it is easy enough to include this step in a Makefile to have everything compile smoothly by a single command. I've done it.
Related
C - X Macro Self Iteration / Expansion
I am curious if any of you can think of a way upon macro expansion to repeat the macro itself. Here is an incredibly small scale version of an overall bigger problem: #include<stdio.h> #define LETTERS\ X(A)\ X(B)\ X(C)\ X(D) #define X(L) #L int main(int nargs,char** args) { printf("%s\n",LETTERS); return 0; } Output: ABCD Desired output: AABCD BABCD CABCD DABCD The desired output is clearly similar to a nested (N^2) loop over whatever input data. The stringification doesn't matter, it's only there for compilation. There are some obvious and some not so obvious solutions to the desired output. One is to make a complete copy of the macro, then between each X element, you simply refer to the copy. This would be wasteful and I don't want to do it. Obviously you can't refer to the macro itself due to recursion. I have made many attempts to find a decent solution, and won't list all of them as it would take up way too much time. I am open to solutions that use other macros to repeat or expand the original, or solutions that use janky forms of recursion. #include<stdio.h> #define LETTERS_COPY\ X(A)\ X(B)\ X(C)\ X(D) #define LETTERS\ X(A)\ LETTERS_COPY\ X(B)\ LETTERS_COPY\ X(C)\ LETTERS_COPY\ X(D)\ LETTERS_COPY #define X(L) #L int main(int nargs,char** args) { printf("%s\n",LETTERS); return 0; } Again, this builds just fine and works, but requires a complete duplicate of the original data, interjecting itself between each X element.
If you use an iterating macro, like how one is defined in the P99 macro utility collection, then it becomes much easier to solve. Since we intend to define an iterating macro, we don't need X-macros on the letters anymore. #define LETTERS \ A \ ,B \ ,C \ ,D Below is a simplified iterating macro that supports up to 5 arguments. Hopefully you see how to extend the implementation if you need more. #define XX(X, ...) \ XX_X(__VA_ARGS__, XX_5, XX_4, XX_3, XX_2, XX_1) \ (X, __VA_ARGS__) #define XX_X(_1,_2,_3,_4,_5,X,...) X #define XX_1(X, _) X(_) #define XX_2(X, _, ...) X(_) XX_1(X, __VA_ARGS__) #define XX_3(X, _, ...) X(_) XX_2(X, __VA_ARGS__) #define XX_4(X, _, ...) X(_) XX_3(X, __VA_ARGS__) #define XX_5(X, _, ...) X(_) XX_4(X, __VA_ARGS__) So, if you invoke XX(X, LETTERS), it will expand into the X-macro version of LETTERS you had before. The magic of the XX() macro is the meta nature of the XX_X() macro, which selects the right numeric macro to use. The numeric macro is passed in reverse order to the XX_X() macro when it is invoked by XX(). This makes it so that XX_X() selects a lower numeric macro if __VA_ARGS__ contains fewer arguments. Now, we create a macro to turn the argument into a string: #define STR(X) STR_(X) #define STR_(X) #X This allows you to easily create the string with all your letters. And printing your iterative output just needs another macro. int main () { const char *letters = XX(STR, LETTERS); #define LETTERS_PRINT(X) printf("%s%s\n", #X, letters); XX(LETTERS_PRINT, LETTERS) } We see that the solution applies XX() twice. Once to create the string of all your letters. Once to create the output, which is prepending each letter to the combined letters. Try it online!
For anyone wondering, the best I could do was make a second X macro that takes 2 args, and the outer list becomes a function macro that takes a single arg. This lets you pass data to the list, and to the second x macro, while still being able to unpack either X macro however you like. #include<stdio.h> #define _CAT(A,B) A##B #define CAT(A,B) _CAT(A,B) #define _STR(S) #S #define STR(S) _STR(S) #define LETTERS(L)\ XX(L,X(A))\ XX(L,X(B))\ XX(L,X(C))\ XX(L,X(D)) int main(int nargs,char** args) { #define X(L) L #define XX(L1,L2) STR(CAT(L1,L2)) printf("%s\n",LETTERS(A)); printf("%s\n",LETTERS(B)); printf("%s\n",LETTERS(C)); printf("%s\n",LETTERS(D)); #undef XX #undef X return 0; }
#ifdef inside a #define?
I'm initializing an array of structures with the help of a define like this: #define FLAGCODE(name) { #name, MNT_ ## name } struct { const char *name; uint64_t flag; } flagcodes[] = { FLAGCODE(ACLS), FLAGCODE(ASYNC), ... This works nicely, and now I'd like to add a check, whether each flag (such as MNT_ACLS) is defined without inserting an #ifdef and #endif for each symbol by hand? That is, I want the macro FLAGCODE(name) to expand into (an equivalent of): #ifdef MNT_ ##name { # name, MNT_ ##name }, #endif Exempli gratia, if name is NOATIME, the code shall become: #ifdef MNT_NOATIME { "NOATIME", MNT_NOATIME }, #endif Yes, I realize, that this would mean double pass through preprocessor, and so is unlikely to be possible -- without a custom code-generator... But still...
There is a solution but highly not recommended! You could do funny things with C-preprocessor (cf. Macro to replace nested for loops and links in the question). But I repeat it: Don't do it. It is a cpp abuse. In two words, you have to create your own #ifdef with macro. In the code below, ISDEF is an "operator" to check if the flag is defined and #if has been redefined: IIF (To understand, all explanations are here: https://github.com/pfultz2/Cloak/wiki/C-Preprocessor-tricks,-tips,-and-idioms) #define PRIMITIVE_CAT(a, ...) a ## __VA_ARGS__ #define COMMA , #define IIF(c) PRIMITIVE_CAT(IIF_, c) #define IIF_0(t, ...) __VA_ARGS__ #define IIF_1(t, ...) t #define CHECK_N(x, n, ...) n #define CHECK(...) CHECK_N(__VA_ARGS__, 0,) #define PROBE(x) x, 1, #define ISDEF(x) CHECK(PRIMITIVE_CAT(ISDEF_, x)) #define ISDEF_ PROBE(~) #define FLAGCODE(name) IIF(ISDEF(name))({ #name COMMA MNT_ ## name }COMMA) #define ACLS #define FLAGDEFINED int main() { struct { const char *name; uint64_t flag; } flagcodes[] = { FLAGCODE(ACLS) FLAGCODE(ASYNC) FLAGCODE(FLAGDEFINED) FLAGCODE(FLAGNOTDEFINED) ... You could also do a list with your flags (cf. MAP part in http://jhnet.co.uk/articles/cpp_magic). Enjoy but do not go overboard with preprocessor. Following the very good comment of Chris Dodd, 1 : This tricks works if the flag is define as empty (#define FLAGDEFINED). It does not work with, for example, #define FLAGDEFINED 1 or #define FLAGDEFINED xxx. 2 : CPP_ prefix has been added and name is changed by CPP_FLAG #define CPP_PRIMITIVE_CAT(CPP_a, ...) CPP_a ## __VA_ARGS__ #define CPP_COMMA , #define CPP_IIF(CPP_c) CPP_PRIMITIVE_CAT(CPP_IIF_, CPP_c) #define CPP_IIF_0(CPP_t, ...) __VA_ARGS__ #define CPP_IIF_1(CPP_t, ...) CPP_t #define CPP_CHECK_N(CPP_x, CPP_n, ...) CPP_n #define CPP_CHECK(...) CPP_CHECK_N(__VA_ARGS__, 0,) #define CPP_PROBE(CPP_x) CPP_x, 1, #define CPP_ISDEF(CPP_x) CPP_CHECK(CPP_PRIMITIVE_CAT(CPP_ISDEF_, CPP_x)) #define CPP_ISDEF_ CPP_PROBE(~) #define CPP_FLAGCODE(CPP_FLAG) CPP_IIF(CPP_ISDEF(CPP_FLAG))({ #CPP_FLAG CPP_COMMA MNT_ ## CPP_FLAG }CPP_COMMA) #define ACLS #define FLAGDEFINED
C Macros: How to map another macro to variadic arguments?
I'd like to know how to apply a unary function (or another macro) to variadic arguments of a macro, like int f(int a); #define apply(args...) <the magic> apply(a, b, c) which unrolls f(a) f(b) f(c) Note that the number of arguments is unknown.
The code below is working for what you've asked for with up to 1024 arguments and without using additional stuff like boost. It defines an EVAL(...) and also a MAP(m, first, ...) macro to do recursion and to use for each iteration the macro m with the next parameter first. With the use of that, your apply(...) looks like: #define apply(...) EVAL(MAP(apply_, __VA_ARGS__)). It is mostly copied from C Pre-Processor Magic. It is also great explained there. You can also download these helper macros like EVAL(...) at this git repository, there are also a lot of explanation in the actual code. It is variadic so it takes the number of arguments you want. But I changed the FIRST and the SECOND macro as it uses a Gnu extension like it is in the source I've copied it from. This is said in the comments below by #HWalters: Specifically, 6.10.3p4: "Otherwise [the identifier-list ends in a ...] there shall be more arguments in the invocation than there are parameters in the macro definition (excluding the ...)". Main function part: int main() { int a, b, c; apply(a, b, c) /* Expands to: f(a); f(b); f(c); */ return 0; } Macro definitions: #define FIRST_(a, ...) a #define SECOND_(a, b, ...) b #define FIRST(...) FIRST_(__VA_ARGS__,) #define SECOND(...) SECOND_(__VA_ARGS__,) #define EMPTY() #define EVAL(...) EVAL1024(__VA_ARGS__) #define EVAL1024(...) EVAL512(EVAL512(__VA_ARGS__)) #define EVAL512(...) EVAL256(EVAL256(__VA_ARGS__)) #define EVAL256(...) EVAL128(EVAL128(__VA_ARGS__)) #define EVAL128(...) EVAL64(EVAL64(__VA_ARGS__)) #define EVAL64(...) EVAL32(EVAL32(__VA_ARGS__)) #define EVAL32(...) EVAL16(EVAL16(__VA_ARGS__)) #define EVAL16(...) EVAL8(EVAL8(__VA_ARGS__)) #define EVAL8(...) EVAL4(EVAL4(__VA_ARGS__)) #define EVAL4(...) EVAL2(EVAL2(__VA_ARGS__)) #define EVAL2(...) EVAL1(EVAL1(__VA_ARGS__)) #define EVAL1(...) __VA_ARGS__ #define DEFER1(m) m EMPTY() #define DEFER2(m) m EMPTY EMPTY()() #define IS_PROBE(...) SECOND(__VA_ARGS__, 0) #define PROBE() ~, 1 #define CAT(a,b) a ## b #define NOT(x) IS_PROBE(CAT(_NOT_, x)) #define _NOT_0 PROBE() #define BOOL(x) NOT(NOT(x)) #define IF_ELSE(condition) _IF_ELSE(BOOL(condition)) #define _IF_ELSE(condition) CAT(_IF_, condition) #define _IF_1(...) __VA_ARGS__ _IF_1_ELSE #define _IF_0(...) _IF_0_ELSE #define _IF_1_ELSE(...) #define _IF_0_ELSE(...) __VA_ARGS__ #define HAS_ARGS(...) BOOL(FIRST(_END_OF_ARGUMENTS_ __VA_ARGS__)()) #define _END_OF_ARGUMENTS_() 0 #define MAP(m, first, ...) \ m(first) \ IF_ELSE(HAS_ARGS(__VA_ARGS__))( \ DEFER2(_MAP)()(m, __VA_ARGS__) \ )( \ /* Do nothing, just terminate */ \ ) #define _MAP() MAP #define apply_(x) f(x); #define apply(...) EVAL(MAP(apply_, __VA_ARGS__)) To test macro expansion it is useful to use gcc with the command line argument -E: $ gcc -E srcFile.c because your're getting concrete error messages and understand what's going on.
Everything is possible in C if you throw enough ugly macros at it. For example, you can have an ugly function-like macro: #include <stdio.h> int f (int a) { printf("%d\n", a); } #define SIZEOF(arr) (sizeof(arr) / sizeof(*arr)) #define apply(...) \ { \ int arr[] = {__VA_ARGS__}; \ for(size_t i=0; i<SIZEOF(arr); i++) \ { \ f(arr[i]); \ } \ } int main (void) { apply(1, 2, 3); } Notice that 1) This would be much better off as a variadic function, and 2) it would be even better if you get rid of the variadic nonsense entirely and simply make a function such as int f (size_t n, int array[n])
C Preprocessor: Stringify int with leading zeros?
I've seen this topic which describes the "stringify" operation by doing: #define STR_HELPER(x) #x #define STR(x) STR_HELPER(x) #define MAJOR_VER 2 #define MINOR_VER 6 #define MY_FILE "/home/user/.myapp" STR(MAJOR_VER) STR(MINOR_VER) Is it possible to stringify with leading zeros? Let's say my MAJOR_REV needs to be two characters "02" in this case and MINOR_REV 4 characters "0006" If I do: #define MAJOR_VER 02 #define MINOR_VER 0006 The values will be treated as octal elsewhere in the application, which I don't want.
No clean nor handy way to do it. Just as a challenge, here a possible "solution": 1) create a header file (e.g. "smartver.h") containing: #undef SMARTVER_HELPER_ #undef RESVER #if VER < 10 #define SMARTVER_HELPER_(x) 000 ## x #elif VER < 100 #define SMARTVER_HELPER_(x) 00 ## x #elif VER < 1000 #define SMARTVER_HELPER_(x) 0 ## x #else #define SMARTVER_HELPER_(x) x #endif #define RESVER(x) SMARTVER_HELPER_(x) 2) In your source code, wherever you need a version number with leading zeroes: #undef VER #define VER ...your version number... #include "smartver.h" at this point, the expression RESVER(VER) is expanded as a four-digit sequence of character, and the expression STR(RESVER(VER)) is the equivalent string (NOTE: I have used the STR macro you posted in you answer). The previous code matches the case of minor version in your example,it's trivial to modify it to match the "major version" case. But in truth I would use a simple external tool to produce the required strings.
I believe in the example provided by the question sprintf is the correct answer. That said, there are a few instances where you really want to do this and with C preprocessor if there is a will and somebody stupid enough to write the code there is typically a way. I wrote the macro FORMAT_3_ZERO(a) which creates a three digit zero padded number using brute force. It is in the file preprocessor_format_zero.h found at https://gist.github.com/lod/cd4c710053e0aeb67281158bfe85aeef as it is too large and ugly to inline. Example usage #include "preprocessor_format_zero.h" #define CONCAT_(a,b) a#b #define CONCAT(a,b) CONCAT_(a,b) #define CUSTOM_PACK(a) cp_ ## a __attribute__( \ (section(CONCAT(".cpack.", FORMAT_3_ZERO(a))), \ aligned(1), used)) const int CUSTOM_PACK(23);
y combinator and the C preprocessor
As far as I know y combinator is useful if you want to write a recursive function without using recursion explicitly. The C preprocessor does not support recursion. Can we implement the y combinator in C preprocessor in order to support recursion? Thanks.
In fact this is completely possible, please see my project CSP Git Repo, this is a LISP interpreter COMPLETELY implemented on C macro preprocessor, and of course you can implement Y combinator on it. Hope you to and some tests/example if you are interested in it. Here is the most relevant part. (from csp.h) It successfully implements closure and lambda, which gives support for implementing fixed point combinators. #define EVAL_e(x) x #define _be(y) y) #define ZIP(x) _n() (x,_be #define _PAIR(x,y) _e( __PAIR(x,y)) #define __PAIR(x,y) _E COND((NULL SAFE_CDR(x)((SAFE_CAR(x) SAFE_CAR(y))))((T)((SAFE_CAR (x) SAFE_CAR (y)) _e(_PAIR2(_e SAFE_CDR(x),_e SAFE_CDR(y)))))) #define _PAIR2(x,y) _E COND((NULL SAFE_CDR(x)((SAFE_CAR(x) SAFE_CAR(y))))((T)((SAFE_CAR (x) SAFE_CAR (y)) _e(_PAIR3(_e SAFE_CDR(x),_e SAFE_CDR(y)))))) #define _PAIR3(x,y) _E COND((NULL SAFE_CDR(x)((SAFE_CAR(x) SAFE_CAR(y))))((T)((SAFE_CAR (x) SAFE_CAR (y)) _e(_PAIR4(_e SAFE_CDR(x),_e SAFE_CDR(y)))))) #define _PAIR4(x,y) _E COND((NULL SAFE_CDR(x)((SAFE_CAR(x) SAFE_CAR(y))))((T)((SAFE_CAR (x) SAFE_CAR (y)) _e(DELAY_INT_54(__PAIR_R) ()(SAFE_CDR(x) SAFE_CDR(y)))))) #define __PAIR_R() _$pair #define TEST_R() TEST #define TEST(x) test #define _PAIR_e(x) x #define _$pair(x) _PAIR_e(_PAIR ZIP x) #define PAIR_EVAL(...) PAIR_EVAL2(PAIR_EVAL2(PAIR_EVAL2(__VA_ARGS__))) #define PAIR_EVAL2(...) PAIR_EVAL3(PAIR_EVAL3(PAIR_EVAL3(__VA_ARGS__))) #define PAIR_EVAL3(...) PAIR_EVAL4(PAIR_EVAL4(PAIR_EVAL4(__VA_ARGS__))) #define PAIR_EVAL4(...) PAIR_EVAL_E(PAIR_EVAL_E(PAIR_EVAL_E(__VA_ARGS__))) #define PAIR_EVAL_E(...) __VA_ARGS__ #define $pair(x) PAIR_EVAL(_$pair(x)) #define $zipped_evlis_R() $zipped_evlis #define EVLIS_e_R() EVLIS_e #define EVLIS_e(x) x #define _EVLIS_ZIP(...) _n() (__VA_ARGS__,_BE #define _BE(...) __VA_ARGS__) #define _EVLIS_R() _EVLIS #define _EVLIS_E(...) __VA_ARGS__ #define _EVLIS_N(...) #define _EVLIS_B _EVLIS_E (_EVLIS_N,_EVLIS_E(_EVLIS_N,_EVLIS_N)) #define ___EVLIS(a,b,k,...) k($zipped_eval((b),(a)) DELAY_INT_2(_EVLIS_R)()(a)) #define __EVLIS(a,b,...) ___EVLIS(a,b,__VA_ARGS__ _EVLIS_E) #define _EVLIS_EVAL_E(...) __VA_ARGS__ #define _EVLIS_EVAL_5(...) _EVLIS_EVAL_E(_EVLIS_EVAL_E(_EVLIS_EVAL_E(__VA_ARGS__))) #define _EVLIS_EVAL_4(...) _EVLIS_EVAL_5(_EVLIS_EVAL_5(_EVLIS_EVAL_5(__VA_ARGS__))) #define _EVLIS_EVAL_3(...) _EVLIS_EVAL_4(_EVLIS_EVAL_4(_EVLIS_EVAL_4(__VA_ARGS__))) #define _EVLIS_EVAL_2(...) _EVLIS_EVAL_3(_EVLIS_EVAL_3(_EVLIS_EVAL_3(__VA_ARGS__))) #define _EVLIS_EVAL(...) _EVLIS_EVAL_2(_EVLIS_EVAL_2(_EVLIS_EVAL_2(__VA_ARGS__))) #define _EVLIS(x) __EVLIS _EVLIS_ZIP(x) #define $zipped_evlis(x,y) _EVLIS_EVAL(_EVLIS y x (_EVLIS_B)) #define $zipped_eval_R() $zipped_eval #define $zipped_eval(e,a) /**sth irrelevant**/ ($eq(SAFE_CAR SAFE_CAR e (lambda))\ (DELAY_INT_26(EVAL_e_R)() DELAY_INT_23($zipped_eval_R)()(\ EVAL_e(EVAL_e(EVAL_e(EVAL_e(SAFE_CAR SAFE_CDR SAFE_CDR SAFE_CAR e)))),\ EVAL_e(APPEND DELAY_INT_13($pair_R)()(EVAL_e(EVAL_e(EVAL_e(SAFE_CAR SAFE_CDR SAFE_CAR e)))\ (DELAY_INT_19($zipped_evlis_R)()(EVAL_e(_e EVAL_e(SAFE_CDR e)), a)))a)))\ /**end of eval recursion**/ #define $pair_R() $pair #define EVAL_e_R() EVAL_e #define $eval_E(...) __VA_ARGS__ #define $eval_expand5(...) $eval_E($eval_E($eval_E(__VA_ARGS__))) #define $eval_expand4(...) $eval_expand5($eval_expand5($eval_expand5(__VA_ARGS__))) #define $eval_expand3(...) $eval_expand4($eval_expand4($eval_expand4(__VA_ARGS__))) #define $eval_expand2(...) $eval_expand3($eval_expand3($eval_expand3(__VA_ARGS__))) #define $eval_expand(...) $eval_expand2($eval_expand2($eval_expand2(__VA_ARGS__))) #define $zeval(x,y) $eval_expand($zipped_eval(x,y))
Y combinator is a higher-order function and it needs a higher-order function support in the language to implement an explicit recursion substitution. Therefore, for particular tasks this can be done in Scheme, SML and other functional languages. Let's talk about C preprocessor later, but what about C itself? It could be possible to use higher order functions in C as we can pass function references as function arguments and return them to emulate higher-order functions. However, the lack of closures support in the language does not allow to implement Y combinator. As preprocessor is even more restrictive that C, there is no way to implement Y combinator which is based on lambda calculus concepts. The application of Y combinator can be achieved only in functional programming languages with higher-order functions full support. C preprocessor is very straightforward as it does only string substitution in a text. I would not try to apply any concepts from lambda calculus and functional programming to it.