During C macro expansion, is there a special case for macros that would expand to "/*"?

Here's a relevant example. It's obviously not valid C, but I'm just dealing with the preprocessor here, so the code doesn't actually have to compile.

#define IDENTITY(x) x
#define PREPEND_ASTERISK(x) *x
#define PREPEND_SLASH(x) /x

IDENTITY(literal)
PREPEND_ASTERISK(literal)
PREPEND_SLASH(literal)
IDENTITY(*pointer)
PREPEND_ASTERISK(*pointer)
PREPEND_SLASH(*pointer)

Running gcc's preprocessor on it:

gcc -std=c99 -E macrotest.c
开发者_Go百科

This yields:

(...)

literal
*literal
/literal
*pointer
**pointer
/ *pointer

Please note the extra space in the last line.

This looks like a feature to prevent macros from expanding to "/*" to me, which I'm sure is well-intentioned. But at a glance, I couldn't find anything pertaining to this behaviour in the C99 standard. Then again, I'm inexperienced at C. Can someone shed some light on this? Where is this specified? I would guess that a compiler adhering to C99 should not just insert extra spaces during macro expansion just because it would probably prevent programming mistakes.

The source code is already tokenized before being processed by CPP.

So what you have is a / and a * token that will not be combined implicitly to a /* "token" ( since /* is not really a preprocessor token I put it in "").

If you use -E to output preprocessed source CPP needs to insert a space in order to avoid /* being read by a subsequent compiler pass.

The same feature prevents from two e.g. + signs from different macros being combined into a ++ token on output.

The only way to really paste two preprocessor tokens together is with the ## operator:

#define P(x,y) x##y

...

P(foo,bar)   

results in the token foobar

P(+,+)

results in the token ++, but

P(/,*)       

is not valid since /* is not a valid preprocessor token.

The behavior of the pre-processor is standardized. In the summary at http://en.wikipedia.org/wiki/C_preprocessor , the results you are observing are the effect of:

"3: Tokenization - The preprocessor breaks the result into preprocessing tokens and whitespace. It replaces comments with whitespace".

This takes place before:

"4: Macro Expansion and Directive Handling".