Preprocessor

The Preprocessor performs some processing on source code before the next 
step of compilation.

The preprocessor is a program that parses a text file and makes it submit 
to certain transformations.
These transformations can be the inclusion of a file, the deletion of a 
text block or the replacement of a text block.

The preprocessor performs these operations through specific commands that 
it reads in the file being scanned.

It is automatically called by the compiler, before compilation, to process 
the files to compile.

Preprocessor commands
   All preprocessor commands begin at the beginning of the line with the 
   pound sign ("#").
   See 'Preprocessor commands' to get all commands that control the 
   preprocessor.

   The main types of commands are the followings:
      * File inclusion:
            Text file inclusion allows you to factorize text that is common 
            to many other files (for example, type, constant, function, 
            etc.).
            The common text is usually put in a file with the extension 
            ".bi".
            Syntax:
               #include [once] "file"
                  file is the name of the file to include.
            The included file is also processed by the preprocessor.

            File inclusion also allows to include a library in the linking 
            process.
            Syntax:
               #inclib "libname"
                  libname is the name of the library file to include in the 
                  linking process.

      * Text replacement:
            The preprocessor makes it possible to define identifiers which, 
            used in the program, will be replaced textually by their value.
            Syntax:
               #define identifier body
                  where identifier is the identifier that will be used in 
                  the rest of the program, and body will be the replacement 
                  text that the preprocessor will use.
            Whenever the identifier identifier is encountered by the 
            preprocessor, it will be replaced by the text body throughout 
            the rest of the program (#undef identifier to undefine an 
            identifier previously defined).

            Defines are scoped (they are only visible in the scope they 
            were defined in).
            Namespaces on the other hand do not have any effect on the 
            visibility of the defines.

      * Compilation constants and conditional compilation:
            See the next 'Conditional Compilation' page of this section.

      * Macros:
            See the last page 'Macros' of this section.

      * Other commands:
            The preprocessor is able to perform other actions than those 
            mentioned above.
            The directives for performing these actions are listed below:
               - #assert condition (conditional directive for debugging)
               - #error error_text (directive for displaying error message)
               - #lang "lang" (directive to set compiler dialect)
               - #libpath "path" (directive to add search path for 
               libraries)
               - #line number ["name"](directive to set current line number 
               [and file name])
               - #pragma / #Cmdline (directive to set compiler options)
               - #Pragma Reserve (directive to reserve symbol name)
               - #print text (directive to print text)

Example
   Example with #include and #define:
   #include "vbcompat.bi"
   #define TEMPLATE "hh:mm:ss yyyy/mm/dd"

   Dim As String * Len(TEMPLATE) hour_date

   hour_date = Format(Now, TEMPLATE)

   Print hour_date, "(" & TEMPLATE & ")"

   Sleep
         

See also
   * Conditional Compilation
   * Macros

