HP 3000 Manuals HP 3000 Manuals
Conditional Compilation
Conditional compilation directives allow you to delimit portions of code
that are compiled if a condition is true.
Syntax
conditional-directive ::=
#if constant-expression newline [group]
#ifdef identifier newline [group]
#ifndef identifier newline [group]
#else 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 are considered true if the
identifier was previously defined using a #define directive.
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
The following are examples of valid combinations of these conditional
compilation directives:
#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 */
#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 */
/* SMALL_MODEL are defined, INT_SIZE */
/* is defined to be 16 (bits). */
#ifdef DEBUG /* If DEBUG is defined, display */
printf("table element : \n"); /* the 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.