cpp.info: Self-Referential Macros

Go forward to Argument Prescan
Go backward to Duplication of Side Effects
Go up to Macro Pitfalls
Go to the top op cpp

Self-Referential Macros

   A "self-referential" macro is one whose name appears in its
definition.  Recall that all macro definitions are rescanned for more
macros to replace.  If the self-reference were considered a use of the
macro, it would produce an infinitely large expansion.  To prevent this,
the self-reference is not considered a macro call.  It is passed into
the preprocessor output unchanged.  Let's consider an example:
     #define foo (4 + foo)
where `foo' is also a variable in your program.
   Following the ordinary rules, each reference to `foo' will expand
into `(4 + foo)'; then this will be rescanned and will expand into `(4
+ (4 + foo))'; and so on until the computer runs out of memory.
   The self-reference rule cuts this process short after one step, at
`(4 + foo)'.  Therefore, this macro definition has the possibly useful
effect of causing the program to add 4 to the value of `foo' wherever
`foo' is referred to.
   In most cases, it is a bad idea to take advantage of this feature.  A
person reading the program who sees that `foo' is a variable will not
expect that it is a macro as well.  The reader will come across the
identifier `foo' in the program and think its value should be that of
the variable `foo', whereas in fact the value is four greater.
   One common, useful use of self-reference is to create a macro which
expands to itself.  If you write
     #define EPERM EPERM
then the macro `EPERM' expands to `EPERM'.  Effectively, it is left
alone by the preprocessor whenever it's used in running text.  You can
tell that it's a macro with `#ifdef'.  You might do this if you want to
define numeric constants with an `enum', but have `#ifdef' be true for
each constant.
   If a macro `x' expands to use a macro `y', and the expansion of `y'
refers to the macro `x', that is an "indirect self-reference" of `x'.
`x' is not expanded in this case either.  Thus, if we have

#define x (4 + y) #define y (2 * x)

then `x' and `y' expand as follows:

x ==> (4 + y)
==> (4 + (2 * x))

y ==> (2 * x)
==> (2 * (4 + y))

Each macro is expanded when it appears in the definition of the other
macro, but not when it indirectly appears in its own definition.