Export (0) Print
Expand All

2.5.4 Conditional compilation directives

Visual Studio .NET 2003

The conditional compilation directives are used to conditionally include or exclude portions of a source file.

pp-conditional:
pp-if-section   pp-elif-sectionsopt   pp-else-sectionopt   pp-endif
pp-if-section:
whitespaceopt   #   whitespaceopt   if   whitespace   pp-expression   pp-new-line   conditional-sectionopt
pp-elif-sections:
pp-elif-section
pp-elif-sections   pp-elif-section
pp-elif-section:
whitespaceopt   #   whitespaceopt   elif   whitespace   pp-expression   pp-new-line   conditional-sectionopt
pp-else-section:
whitespaceopt   #   whitespaceopt   else   pp-new-line   conditional-sectionopt
pp-endif:
whitespaceopt   #   whitespaceopt   endif   pp-new-line
conditional-section:
input-section
skipped-section
skipped-section:
skipped-section-part
skipped-section   skipped-section-part
skipped-section-part:
skipped-charactersopt   new-line
pp-directive
skipped-characters:
whitespaceopt   not-number-sign   input-charactersopt
not-number-sign:
Any input-character except #

As indicated by the syntax, conditional compilation directives must be written as sets consisting of, in order, an #if directive, zero or more #elif directives, zero or one #else directive, and an #endif directive. Between the directives are conditional sections of source code. Each section is controlled by the immediately preceding directive. A conditional section may itself contain nested conditional compilation directives provided these directives form complete sets.

A pp-conditional selects at most one of the contained conditional-sections for normal lexical processing:

  • The pp-expressions of the #if and #elif directives are evaluated in order until one yields true. If an expression yields true, the conditional-section of the corresponding directive is selected.
  • If all pp-expressions yield false, and if an #else directive is present, the conditional-section of the #else directive is selected.
  • Otherwise, no conditional-section is selected.

The selected conditional-section, if any, is processed as a normal input-section: the source code contained in the section must adhere to the lexical grammar; tokens are generated from the source code in the section; and pre-processing directives in the section have the prescribed effects.

The remaining conditional-sections, if any, are processed as skipped-sections: except for pre-processing directives, the source code in the section need not adhere to the lexical grammar; no tokens are generated from the source code in the section; and pre-processing directives in the section must be lexically correct but are not otherwise processed. Within a conditional-section that is being processed as a skipped-section, any nested conditional-sections (contained in nested #if...#endif and #region...#endregion constructs) are also processed as skipped-sections.

The following example illustrates how conditional compilation directives can nest:

#define Debug      // Debugging on
#undef Trace      // Tracing off
class PurchaseTransaction
{
   void Commit() {
      #if Debug
         CheckConsistency();
         #if Trace
            WriteToLog(this.ToString());
         #endif
      #endif
      CommitHelper();
   }
}

Except for pre-processing directives, skipped source code is not subject to lexical analysis. For example, the following is valid despite the unterminated comment in the #else section:

#define Debug      // Debugging on
class PurchaseTransaction
{
   void Commit() {
      #if Debug
         CheckConsistency();
      #else
         /* Do something else
      #endif
   }
}

Note, however, that pre-processing directives are required to be lexically correct even in skipped sections of source code.

Pre-processing directives are not processed when they appear inside multi-line input elements. For example, the program:

class Hello
{
   static void Main() {
      System.Console.WriteLine(@"hello, 
#if Debug
      world
#else
      Nebraska
#endif
      ");
   }
}

results in the output:

hello,
#if Debug
      world
#else
      Nebraska
#endif

In peculiar cases, the set of pre-processing directives that is processed might depend on the evaluation of the pp-expression. The example:

#if X
   /* 
#else
   /* */ class Q { }
#endif 

always produces the same token stream (class Q { }), regardless of whether or not X is defined. If X is defined, the only processed directives are #if and #endif, due to the multi-line comment. If X is undefined, then three directives (#if, #else, #endif) are part of the directive set.

Show:
© 2014 Microsoft