Conditional Compilation

Syntax

conditional-directive ::=
    #if     constant-expression newline [group]
    #ifdef  identifier newline [group]
    #ifndef identifier newline [group]
    #else   newline [group]
    #elif   constant-expression newline [group]
    #endif

Here, constant-expression may also contain the defined operator:

defined identifier
defined (identifier)

Description

You can use #if, #ifdef, or #ifndef to mark the beginning of the block of code that will only be compiled conditionally. An #else directive optionally sets aside an alternative group of statements. You mark the end of the block using an #endif directive. The structure of the conditional compilation directives can be shown using the #if directive:

#if constant-expression
 .
 .
 .
/* (Code that compiles if the expression evaluates
    to a nonzero value.) */
#else
 .
 .

 .
/* (Code that compiles if the expression evaluates
    to a zero value.) */
#endif

The constant-expression is like other C integral constant expressions except that all arithmetic is carried out in long int precision. Also, the expressions cannot use the sizeof operator, a cast, or an enumeration constant.

You can use the defined operator in the #if directive to use expressions that evaluate to 0 or 1 within a preprocessor line. This saves you from using nested preprocessing directives.

The parentheses around the identifier are optional. For example:

  #if defined (MAX) && ! defined (MIN)
   .
   .
   .

Without using the defined operator, you would have to include the following two directives to perform the above example:

 #ifdef max
 #ifndef min

The #if preprocessing directive has the form:

  #if constant-expression

Use #if to test an expression. The compiler evaluates the expression in the directive. If it is true (a nonzero value), the code following the directive is included. If the expression evaluates to false (a zero value), the compiler ignores the code up to the next #else, #endif, or #elif directive.

All macro identifiers that appear in the constant-expression are replaced by their current replacement lists before the expression is evaluated. All defined expressions are replaced with either 1 or 0 depending on their operands.

Whichever directive you use to begin the condition (#if, #ifdef, or #ifndef), you must use #endif to end the if-section.

The following preprocessing directives are used to test for a definition:

#ifdef identifier
#ifndef identifier

They behave like the #if directive but #ifdef is considered true if the identifier was previously defined using a #define directive or the -D option. #ifndef is considered true if the identifier is not yet defined.

You can nest these constructions. Delimit portions of the source program using conditional directives at the same level of nesting, or with a -D option on the command line.

Use the #else directive to specify an alternative section of code to be compiled if the #if, #ifdef, or #ifndef conditions fail. The code after the #else directive is compiled if the code following any of the if directives does not compile.

The #elif constant-expression directive tests whether a condition of the previous #if, #ifdef, or #ifndef was false. #elif is syntactically the same as the #if directive and can be used in place of an #else directive.

Examples

Valid combinations of these conditional compilation directives follow:

#ifdef SWITCH
                 /* compiled if SWITCH is defined */
#else
                 /* compiled if SWITCH is undefined */
#endif                /* end of if */
 
#if defined(THING)
                 /* compiled if THING is defined */
#endif                /* end of if */
 
#if A>47
                 /* compiled if A evaluates > 47 */
#else
#if A < 20
                 /* compiled if A evaluates < 20 */
#else
                 /* compiled if A >= 20 and <= 47 */
#endif                /* end of if, A < 20 */
#endif                /* end of if, A > 47 */

Examples

#ifdef (HP9000_S800)    /* If HP9000_S800 is defined, INT_SIZE */
#define INT_SIZE 32     /* is defined to be 32 (bits).         */
#elif defined (HPVECTRA) && defined (SMALL_MODEL)
#define INT_SIZE 16     /* Otherwise, if HPVECTRA and */
#endif                  /* SMALL_MODEL are defined, INT_SIZE is */
                        /* defined to be 16 (bits).             */

#ifdef DEBUG             /* If DEBUG is defined, display the  */
   printf("table element : \n"); /* table elements.           */
   for (i=0; i < MAX_TABLE_SIZE; ++i)
      printf("%d  %f\n", i, table[i]);
#endif

	NOTE: The #elif directive is only supported in ANSI mode.