Is there logical short-circuiting in the C preprocessor?

Question

The gcc docs for cpp explain about the #if directive:

[...] and logical operations (&& and ||). The latter two obey the usual short-circuiting rules of standard C.

What does that mean? There is no evaluation of expressions during preprocessing, so how can it be short-circuited?

Answer 1

Very simple: undefined macros have numeric value zero, and division by zero is illegal.

#if FIXEDSIZE && CHUNKSIZE/FIXEDSIZE > 42 #define USE_CELLPOOL #endif 

---

#if does evaluate the rest of its line as an integer constant expression. Your linked documentation begins:

The ‘#if’ directive allows you to test the value of an arithmetic expression, rather than the mere existence of one macro.

That isn't a gcc extension, the Standard's syntax for #if is

#ifconstant-expression new-line groupopt.

The C99 preprocessor treats all constants as [u]intmax_t.

Answer 2

What they are referring to is && and || operators for #if

#if defined (AAA) || defined (BBB) 

If defined (AAA) is defined then defined (BBB) is never evaluated.

---

UPDATE

So running the calculation will be short circuited. For example, if you build with -Wundef to warn about the usage of undefined macros.

#if defined FOO && FOO > 1000 #endif  #if FOO > 1000 #endif 

will result in

thomas:~ jeffery$ gcc foo.c -Wundef foo.c:4:5: warning: 'FOO' is not defined, evaluates to 0 [-Wundef] #if FOO > 1000     ^ 1 warning generated. 

So the first version does not generate the undefined macro warning, because FOO > 1000 is not evaluated.

---

OLD MUSINGS

This become important if the second part is a macro which has side effects. The macro would not be evaluated, so the side effects would not take place.

---

To avoid macro abuse I'll give a somewhat sane example

#define FOO #define IF_WARN(x) _Pragma (#x) 1 #if defined(FOO) || IF_WARN(GCC warning "FOO not defined") #endif 

Now that I constructed this example, I now run into a problem. IF_WARN is always evaluated.

huh, more research needed.

---

Well foo… now that I read it again.

Macros. All macros in the expression are expanded before actual computation of the expression's value begins.