[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 8.9 Compiler Directives And The Preprocessor

GPC, like UCSD Pascal and BP, treats comments beginning with a ``$'` immediately following the opening ``{'` or ``(*'` as a compiler directive. As in Borland Pascal, `{$...}` and `(*$...*)` are equivalent. When a single character plus a ``+'` or ``-'` follows, this is also called a compiler switch. All of these directives are case-insensitive (but some of them have case-sensitive arguments). Directives are local and can be changed during one compilation (except include files etc. where this makes no sense).

In general, compiler directives are compiler-dependent. (E.g., only the include directive `{$I FileName}` is common to UCSD and BP.) Because of BP's popularity, GPC supports all of BP's compiler directives (and ignores those that are unnecessary on its platforms -- these are those not listed below), but it knows a lot more directives.

Some BP directives are -- of course not by chance -- just an alternative notation for C preprocessor directives. But there are differences: BP's conditional definitions (``{$define Foo}'`) go into another name space than the program's definitions. Therefore you can define conditionals and check them via `{$ifdef Foo}`, but the program will not see them as an identifier ``Foo'`, so macros do not exist in Borland Pascal.

GPC does support macros, but disables this feature when the ``--no-macros'` option or the dialect option ``--borland-pascal'` or ``--delphi'` is given, to mimic BP's behaviour. Therefore, the following program will react differently when compiled with GPC either without special options or with, e.g., the ``--borland-pascal'` option (and in the latter case, it behaves the same as when compiled with BP).

    program MacroDemo;

    const Foo = 'Borland Pascal';

    {$define Foo 'Default'}

    begin
      WriteLn (Foo)
    end.

Of course, you should not rely on such constructs in your programs. To test if the program is compiled with GPC, you can test the ``__GPC__'` conditional, and to test the dialect used in GPC, you can test conditionals like ``__BORLAND_PASCAL__'`.

In general, almost every GPC specific command line option (see section 7.1 GPC opcije osim GCC-ovih.) can be turned into a compiler directive (exceptions are those options that contain directory names, such as ``--unit-path'`, because they refer to the installation on a particular system, and therefore should be set system-wide, rather than in a source file):

    --foo       {$foo}
    --no-foo    {$no-foo}
    -Wbar       {$W bar}     { note the space after the `W' }
    -Wno-bar    {$W no-bar}

The following table lists some such examples as well as all those directives that do not correspond to command-line options or have syntactical alternatives (for convenience and/or BP compatibility).

    --[no-]short-circuit   $B+ $B- like in Borland Pascal:
                                   $B- means short-circuit Boolean
                                   operators; $B+ complete evaluation

    --[no-]io-checking     $I+ $I- like in Borland Pascal:
                                   enable/disable I/O checking

    --[no-]stack-checking  $S+ $S- like in Borland Pascal:
                                   enable/disable stack checking

    --[no-]typed-address   $T+ $T- like in Borland Pascal:
                                   make the result of the address
                                   operator and the Addr function a
                                   typed or untyped pointer

    -W[no-]warnings        $W+ $W- enable/disable warnings. Note: in
                                   `--borland-pascal' mode, the
                                   short version is disabled because
                                   $W+/$W- has a different meaning in
                                   Borland Pascal (which can safely be
                                   ignored in GPC), but the long version
                                   is still available.

    --[no-]extended-syntax $X+ $X- mostly like in Borland Pascal:
                                   enable/disable extended syntax
                                   (ignore function return values,
                                   operator definitions, `PChar',
                                   pointer arithmetic, ...)

    --borland-pascal               disable or warn about GPC features
    --extended-pascal              not supported by the standard or
    --pascal-sc                    dialect given, do not warn about its
    etc.                           ``dangerous'' features (especially BP).
                                   The dialect can be changed during one
                                   compilation via directives like,
                                   e.g., `{$borland-pascal}'.

    {$M Hello!}                    write message `Hello!' to
                                   standard error during compilation. In
                                   `--borland-pascal' mode, it is
                                   ignored it if only numbers follow
                                   (for compatibility to Borland
                                   Pascal's memory directive)

    {$define FOO}                  like in Borland Pascal:
    or                             define FOO (for conditional compilation)
    {$CIDefine FOO}                (case-insensitively)

    --cidefine=FOO                 the same on the command line

    {$CSDefine FOO}                define FOO case-sensitively

    -D FOO                         the same on the command line
    or                             Note: `--define' on the command
    --csdefine=FOO                 line is case-sensitive like in GCC,
    or                             but `{$define}' in the source code
    --define=FOO                   is case-insensitive like in BP

    {$define loop while True do}   define `loop' to be `while True do'
    or                             as a macro like in C. The name of the
    {$CIDefine loop ...}           macro is case-insensitive. Note:
                                   Macros are disabled in
                                   `--borland-pascal' mode because BP
                                   doesn't support macros.

    --cidefine="loop=..."          the same on the command line

    {$CSDefine loop ...}           define a case-sensitive macro

    --csdefine="loop=..."          the same on the command line
    or
    --define="loop=..."

    {$I FileName}                  like in Borland Pascal:
                                   include `filename.pas'
                                   (the name is converted to lower case)

    {$undef FOO}                   like in Borland Pascal: undefine FOO

    {$ifdef FOO}                   conditional compilation
      ...                          (like in Borland Pascal).
    {$else}                        Note: GPC predefines the symbol
      ...                          `__GPC__' (with two leading
    {$endif}                       and trailing underscores).

    {$include "filename.pas"}      include (case-sensitive)

    {$include <filename.pas>}      the same, but don't search in the
                                   current directory

...and all the other C preprocessor directives.

You also can use the preprocessor directives in C style, e.g. ``#include'`, but this is deprecated because of possible confusion with Borland Pascal style ``#42'` character constants. Besides, in the Pascal style, e.g. ``{$include "foo.bar"}'`, there may be more than one directive in the same line.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

This document was generated by Frank Heckenbach on May, 10 2002 using texi2html