CODEWITHSUNDEEP
cc-preprocessor
bph
bph

Reputation: 11258

C Preprocessor #if handling of non-integer constant

I have the following code snippet to allow me flip easily between double and float representations of floating point values:

#define FLOATINGPOINTSIZE 64

#if FLOATINGPOINTSIZE == 64
typedef double FP_TYPE;
#define FP_LIT_SUFFIX 
#else
typedef float FP_TYPE;
#define FP_LIT_SUFFIX f
#endif

At another location I had written the following:

/* set floating point limits used when initialising values that will be subject
 * to the MIN() MAX() functions
 *
 * uses values from float.h */
#if FP_TYPE == double
#define FPTYPE_MAX DBL_MAX
#define FPTYPE_MIN DBL_MIN
#else
#define FPTYPE_MAX FLT_MAX
#define FPTYPE_MIN FLT_MIN
#endif

whereas I think I should have written:

#if FLOATINGPOINTSIZE == 64

I have -Wall compiler setting to give me plenty of warnings but this didn't get flagged up as an issue. Possibly -Wall is completely independent of the preprocessor though?

My question is how is the preprocessor interpreting:

#if FP_TYPE == double

The meaning is obvious to the programmer, but I'm not sure what the preprocessor makes of it?

Its got to be a bug right?

Upvotes: 0

Views: 872

Answers (2)

R Sahu
R Sahu

Reputation: 206577

The meaning is obvious to the programmer, but I'm not sure what the preprocessor makes of it?

Its got to be a bug right?

It's a bug from a user's point of view but it is not a bug in the preprocessor.

#if FP_TYPE == double

is interpreted as

#if 0 == 0

since neither FP_TYPE nor double is a known symbol for the pre-processor.

From https://gcc.gnu.org/onlinedocs/cpp/If.html#If:

Identifiers that are not macros, which are all considered to be the number zero. This allows you to write #if MACRO instead of #ifdef MACRO, if you know that MACRO, when defined, will always have a nonzero value. Function-like macros used without their function call parentheses are also treated as zero.

Upvotes: 3

John Bollinger
John Bollinger

Reputation: 180161

I have -Wall compiler setting to give me plenty of warnings but this didn't get flagged up as an issue.

The code is valid, but you are right to be concerned.

My question is how is the preprocessor interpreting:

#if FP_TYPE == double

Good question.

The meaning is obvious to the programmer, but I'm not sure what the preprocessor makes of it?

The intended meaning seems obvious, and as the code's author, you know what you meant. But what you appear to have intended indeed is not how the preprocessor interprets that conditional.

The expression in a preprocessor conditional is interpreted as an integer constant expression. Just like in a C if statement, if the expression evaluates to 0 then the condition is considered false, and otherwise it is considered true. All macros in the expression are expanded before it is evaluated, and any remaining identifiers are replaced with 0. Details are presented in section 6.10.1 of the standard.

Supposing that there is no in-scope defnition of a macro named either FP_TYPE or double (and a typedef is not a macro definition), your conditional is equivalent to

#if 0 == 0

, which is always true.

Its got to be a bug right?

The preprocessing result will not be what you intended, so it's a bug in your code. The compiler, on the other hand, is correct to accept it.

Upvotes: 7

Related Questions