Is there a reason to NOT wrap preprocessor macros in parens?

Question

I'm writing a design document for a macro expansion language that is specifically intended for arithmetic operations on integers. I've already determined that not wrapping macros with parens can lead to unexpected behavior. Rather than expect users to practice impeccable code hygiene, implementing automatic parens will save the users time and reduce bugs.

If a preprocessor adds enclosing parentheses every time a macro is expanded, is any useful functionality lost?

Answer 1

For integer expressions, auto-wrapping in parentheses seems harmless.

For other macros, though, it would potentially break code. For instance in C, it's fairly common to see function-like macros like this:

#define swap(x,y)       \
   do {                 \
     int swap_tmp = x;  \
     y = x;             \
     x = swap_tmp;      \
   } while (0)

which would work as a regular statement, e.g.

if (condition)
  swap(x,y);
else
  swap(y,z);

Adding parentheses around swap(x,y) would break this.

Arguably, these macros are needed since the language has poor features, lacking pass-by-reference, or perhaps because the programmer wants to be sure the function is inlined for some reason. Still, they are used.

Answer 2

#define PLUS +

3 PLUS 5

Any more questions?

Answer 3

You can think of the C preprocessor as a machine that operates on lexical tokens. All of the fancy operations that it can do (e.g. string pasting, converting identifiers to strings) operate on tokens and produce tokens.

Compare this with, say, the Lisp macro system, which rewrites a tree into a tree.

Decide on the model of the macro system first. That should guide your thinking.