Escaping a # symbol in a #define macro?

Question

OK, without going into the gory details I want to use a #define macro that will expand to a #include but the '#' sign is confusing the preprocessor (as it thinks I want to quote an argument.)

For example, I want to do something like this:

#define MACRO(name) #include "name##foo"

And use it thus:

MACRO(Test)

Which will expand to:

#include "Testfoo"

The humble # sign is causing the preprocessor to barf. MinGW gives me the following error:

'#' is not followed by a macro parameter

I guess I need to escape the # sign but I don't if this is even possible.

Yes, macros are indeed evil...

Answer 1

This might work (it works for regular #define macros with no parameters, but I haven't tested it with macros with parameters).

#define MACRO(name) <name##foo>
#include MACRO(Test)

Answer 2

As far as I remember you cannot use another preprocessor directive in define.

Answer 3

This is because the # has special meaning when used in a macro.

#  means quote the following token (which should be a macro parameter name)
## means concatenate the preceding and following tokens.

In your situation the # is not followed by a proper token. So in your situation we need to go through a level of indiection:

#define     QUOTE(name)     #name
#define     TEST(name)      QUOTE(name ## foo)

#include TEST(scot)

Answer 4

This seems to work:

$ cat test.c
#define INC #include
#define MACRO(name) INC <name##foo>
MACRO(hello)

using cpp (the preprocessor) on this results in :

$ cpp test.c
# 1 "test.c"
# 1 "<built-in>"
# 1 "<command-line>"
# 1 "test.c"


#include <hellofoo>

Edit:

Hmmm... I do not think this actually works. cpp is fine with it but gcc is not... Actually it seems that cpp generates the correct output but then it does not see the #include and does not include the file. So maybe it works if you first run cpp manually on your source and then use gcc on the sources cpp creates.

Answer 5

The problem isn't actually getting a # symbol in the output of your preprocessor.

Apparently you want the preprocessor to reparse your file, to deal with newly created #include directives as part of macro expansion. It doesn't work that way. If a line starts with #, it's an instruction for the preprocessor and interpreted. If a line doesn't start with #, it's only subject to preprocessor transformation including macro substitution. This is a once-per-line test.

MACRO(Test)

does not start with #. Therefore it is not interpreted as a preprocessor directive; instead it's subject to macro replacement rules.

Answer 6

You can't do that. Preprocessor directives are recognized before macro expansion; if the macro expands into something that looks like a preprocessor directive, that directive will not be recognized. The best you can do is create a macro for the file name:

#define MACRO(name) "name##foo"
...
#include MACRO(Test)