As I've mentioned in previous posts, I've been writing my own\nC2Y Compiler / Interpreter / REPL for fun.\nOne of the first things one has to do when writing a C Compiler is to first\nwrite a C Preprocessor (also known as the CPP). Counter to what most people\nthink of the C Preprocessor, it is not a text-to-text translator. Instead\nit is a source to C token translator, with most implementations offering a\ntext output to see what it does. Historically, it might have been implemented\nas a text-to-text translator, but the C standard specifies it as a series of\nphases that ends up with C tokens that are consumed by the C parser until you\neventually end up with a C translation unit.
\nOthers have probably written about how to write a C Preprocessor before, so I\nwon't focus on that. Instead I'll focus on some fun ways I've extended the C\nPreprocessor, either to make it easier to use or just because I thought it was\ngoofy. I won't list all of them, but just the particularly interesting ones.
\nThe most straightforward extensions: builtin debugging macros.
\n__print(...) acts as a preprocessor print function, expanding its arg(s)\nand writing it to stderr, useful for debugging what a macro expands to.\nAs you only get exactly what you __print(), it can be much easier to\nsee what the preprocessor expands to without dumping the entire translation\nunit like with cpp.
\n$ printf "#define X 1\\n__print(X X)" | drcpp\n(stdin):2:1: 1 1Ever have trouble figuring out where the heck a macro was defined that is\nexpanding in some weird way? Maybe some baroque glibc macro is ruining your life?\n__where() is your friend. It writes to stderr where the macro was defined.
\n$ printf "#define X 1\\n\\n\\n\\n__where(X)" | drcpp\n(stdin):1:9: info: X definedSomething that occasionally comes up is the need to apply some transformation\nto each argument in a list. Perhaps you want to print a sequence of values\nyou have in a preprocessor sequence. The standard functional way to\nimplement this would be to write a recursive function (in the preprocessor a\nfunction-like macro), but the C standard blocks direct recursion as the\ntokens get "painted blue" and have their expansion suppressed. However, you\ngenerally don't need arbitrarily long recursion, so you can fake it by\npumping the recursion yourself for a fixed number of iterations. If you have an\naversion to disgusting preprocessor abuse, then don't look at this example:
\nI warned you
\n// map.c\n#define CAT(a, b) CAT_(a, b)\n#define CAT_(a, b) a##b\n#define NARG(...) \\\n NARG_(__VA_ARGS__ __VA_OPT__(,) 8,7,6,5,4,3,2,1,0)\n#define NARG_(_1,_2,_3,_4,_5,_6,_7,_8,N,...) N\n#define MAP_0(m)\n#define MAP_1(m, x) m(x)\n#define MAP_2(m, x, ...) m(x) MAP_1(m, __VA_ARGS__)\n#define MAP_3(m, x, ...) m(x) MAP_2(m, __VA_ARGS__)\n#define MAP_4(m, x, ...) m(x) MAP_3(m, __VA_ARGS__)\n#define MAP_5(m, x, ...) m(x) MAP_4(m, __VA_ARGS__)\n#define MAP_6(m, x, ...) m(x) MAP_5(m, __VA_ARGS__)\n#define MAP_7(m, x, ...) m(x) MAP_6(m, __VA_ARGS__)\n#define MAP_8(m, x, ...) m(x) MAP_7(m, __VA_ARGS__)\n#define __map(m, ...) \\\n CAT(MAP_, NARG(__VA_ARGS__))(m __VA_OPT__(,) __VA_ARGS__)\nint x = 1;\nint y = 2;\nint z = 3;\n\n#define PRINTINT(x) printf(#x " = %d\\n", x);\nint printf(const char*, ...);\nint main(){\n __map(PRINTINT, 1, 2, 3, 4, x, y, z)\n}Which expands to (whitespace inserted for readability):
\n// map.i\nint x = 1;\nint y = 2;\nint z = 3;\nint printf(const char*, ...);\nint main(){\n printf("1" " = %d\\n", 1); // 1 = 1\n printf("2" " = %d\\n", 2); // 2 = 2\n printf("3" " = %d\\n", 3); // 3 = 3\n printf("4" " = %d\\n", 4); // 4 = 4\n printf("x" " = %d\\n", x); // x = 1\n printf("y" " = %d\\n", y); // y = 2\n printf("z" " = %d\\n", z); // z = 3\n}This is useful, but obviously pretty disgusting and is generally quite slow as you\nare abusing preprocessor expansion, which has to scan and expand each argument of\neach function-like macro over and over again. So I added __map(macro, ...) to my C\npreprocessor:
\nWith a builtin __map(), the above example simplifies to just:
\nint x = 1;\nint y = 2;\nint z = 3;\n#define PRINTINT(x) printf(#x " = %d\\n", x);\nint printf(const char*, ...);\nint main(){\n __map(PRINTINT, 1, 2, 3, 4, x, y, z)\n}Now you don't have to mess around with faking recursion: it can apply the\nmacro to each argument once in a linear scan. And you have no arbitrary\nlimit on how many items you can map!
\nC23 made working with variadic macros more convenient and powerful with\nVA_OPT(), but some use-cases remain difficult. As demonstrated in the\nprevious section, it can be useful to "overload" a macro by its arity, but\nthis requires gross manual preprocessor pumping.
\nAnother use case is passing a count + pointer to a function if your compiler\nstill hasn't fixed C's biggest mistake, or a param count to a variadic\nfunction.
\n// sum.c\n#define CAT(a, b) CAT_(a, b)\n#define CAT_(a, b) a##b\n#define NARG(...) \\\n NARG_(__VA_ARGS__ __VA_OPT__(,) 8,7,6,5,4,3,2,1,0)\n#define NARG_(_1,_2,_3,_4,_5,_6,_7,_8,N,...) N\nint sum(size_t count, int* data){\n int result = 0;\n for(size_t i = 0; i < count; i++){\n result += data[i];\n }\n return result;\n}\n#define sum(...) sum(NARG(__VA_ARGS__), (int[]){__VA_ARGS__})\nint printf(const char*, ...);\nint main(){\n printf("%d\\n", sum(1,2,3)); // 6\n printf("%d\\n", sum(4,5)); // 9\n}Instead of going through all of this nonsense to just get the number of\nvariadic arguments (which the cpp already has!), I added a builtin macro\nVA_COUNT, so you can just get the count of variadic arguments\ndirectly.
\n// sum-drc.c\nint sum(size_t count, int* data){\n int result = 0;\n for(size_t i = 0; i < count; i++){\n result += data[i];\n }\n return result;\n}\n#define sum(...) sum(__VA_COUNT__, (int[]){__VA_ARGS__})\nint printf(const char*, ...);\nint main(){\n printf("%d\\n", sum(1,2,3)); // 6\n printf("%d\\n", sum(4,5)); // 9\n}Nicer and faster!
\nThe C Preprocessor is a powerful tool, but requires some unreadable dark\nmagic to really take advantage of it. This isn't inherent to what you want to\ndo with it though - it is merely a consequence of its underdeveloped\nmachinery. With some extensions, we can make the CPP more powerful while\nalso improving readability and making it more enjoyable to use.
\nI have more to talk about, including some true dark magic like mutable\npreprocessor state, but that's it for this post!
","headings":[{"level":2,"text":"__print()/__where()","id":"print-where"},{"level":2,"text":"__map()","id":"map"},{"level":2,"text":"__VA_COUNT__","id":"va-count"},{"level":2,"text":"Conclusion","id":"conclusion"}]}}