jedi.inc

lansd aslda sldasdnaslda sdlandslasd

  SUPPORTS_INLINE               Compiler supports the inline directive (D9+)
  SUPPORTS_FOR_IN               Compiler supports for in loops (D9+)
  SUPPORTS_NESTED_CONSTANTS     Compiler supports nested constants (D9+)
  SUPPORTS_NESTED_TYPES         Compiler supports nested types (D9+)
  SUPPORTS_ENHANCED_RECORDS     Compiler supports class [operator|function|procedure] for record types (D9.NET, D10+)
  SUPPORTS_CLASS_FIELDS         Compiler supports class fields (D9.NET, D10+)
  SUPPORTS_CLASS_HELPERS        Compiler supports class helpers (D9.NET, D10+)
  SUPPORTS_CLASS_OPERATORS      Compiler supports class operators (D9.NET, D10+)
  SUPPORTS_STRICT               Compiler supports strict keyword (D9.NET, D10+)
  SUPPORTS_STATIC               Compiler supports static keyword (D9.NET, D10+)
  SUPPORTS_FINAL                Compiler supports final keyword (D9.NET, D10+)
  ACCEPT_DEPRECATED             Compiler supports or ignores the deprecated directive (D6+/BCB6+/FPC)
  ACCEPT_PLATFORM               Compiler supports or ignores the platform directive (D6+/BCB6+)
  ACCEPT_LIBRARY                Compiler supports or ignores the library directive (D6+/BCB6+)
  SUPPORTS_CUSTOMVARIANTS       Compiler supports custom variants (D6+/BCB6+)
  SUPPORTS_VARARGS              Compiler supports varargs (D6+/BCB6+)
  SUPPORTS_ENUMVALUE            Compiler supports assigning ordinalities to values of enums (D6+/BCB6+)
  SUPPORTS_DEPRECATED_WARNINGS  Compiler supports deprecated warnings (D6+/BCB6+)
  SUPPORTS_LIBRARY_WARNINGS     Compiler supports library warnings (D6+/BCB6+)
  SUPPORTS_PLATFORM_WARNINGS    Compiler supports platform warnings (D6+/BCB6+)
  SUPPORTS_UNSAFE_WARNINGS      Compiler supports unsafe warnings (D7)
  SUPPORTS_WEAKPACKAGEUNIT      Compiler supports the WEAKPACKAGEUNIT directive
  SUPPORTS_COMPILETIME_MESSAGES Compiler supports the MESSAGE directive
  HAS_UNIT_LIBC                 Unit Libc exists (Kylix, FPC on Linux)
  HAS_UNIT_RTLCONSTS            Unit RTLConsts exists (D6+/BCB6+)
  HAS_UNIT_TYPES                Unit Types exists (D6+/BCB6+)
  HAS_UNIT_VARIANTS             Unit Variants exists (D6+/BCB6+)
  HAS_UNIT_STRUTILS             Unit StrUtils exists (D6+/BCB6+)
  XPLATFORM_RTL                 The RTL supports crossplatform function names (e.g. RaiseLastOSError) (D6+/BCB6+/FPC)


- Compiler Settings

  The compiler settings directives indicate whether a specific compiler setting
  is in effect. This facilitates changing compiler settings locally in a more
  compact and readible manner.

  Directive              Description
  ------------------------------------------------------------------------------
  ALIGN_ON               Compiling in the A+ state (no alignment)
  BOOLEVAL_ON            Compiling in the B+ state (complete boolean evaluation)
  ASSERTIONS_ON          Compiling in the C+ state (assertions on)
  DEBUGINFO_ON           Compiling in the D+ state (debug info generation on)
  IMPORTEDDATA_ON        Compiling in the G+ state (creation of imported data references)
  LONGSTRINGS_ON         Compiling in the H+ state (string defined as AnsiString)
  IOCHECKS_ON            Compiling in the I+ state (I/O checking enabled)
  WRITEABLECONST_ON      Compiling in the J+ state (typed constants can be modified)
  LOCALSYMBOLS           Compiling in the L+ state (local symbol generation)
  TYPEINFO_ON            Compiling in the M+ state (RTTI generation on)
  OPTIMIZATION_ON        Compiling in the O+ state (code optimization on)
  OPENSTRINGS_ON         Compiling in the P+ state (variable string parameters are openstrings)
  OVERFLOWCHECKS_ON      Compiling in the Q+ state (overflow checing on)
  RANGECHECKS_ON         Compiling in the R+ state (range checking on)
  TYPEDADDRESS_ON        Compiling in the T+ state (pointers obtained using the @ operator are typed)
  SAFEDIVIDE_ON          Compiling in the U+ state (save FDIV instruction through RTL emulation)
  VARSTRINGCHECKS_ON     Compiling in the V+ state (type checking of shortstrings)
  STACKFRAMES_ON         Compiling in the W+ state (generation of stack frames)
  EXTENDEDSYNTAX_ON      Compiling in the X+ state (Delphi extended syntax enabled)
*)

{$DEFINE BORLAND}

{ Set FreePascal to Delphi mode }
{$IFDEF FPC}
  {$MODE DELPHI}
  {$ASMMODE Intel}
  {$UNDEF BORLAND}
{$ENDIF}

{$IFDEF BORLAND}
  {$IFDEF LINUX}
    {$DEFINE KYLIX}
  {$ENDIF LINUX}
{$ENDIF BORLAND}

{------------------------------------------------------------------------------}
{ VERXXX to COMPILERX, DELPHIX and BCBX mappings                               }
{------------------------------------------------------------------------------}

{$IFDEF BORLAND}
  {$IFDEF KYLIX}
    {$I kylix.inc} // FPC incompatible stuff
  {$ELSE ~KYLIX}

    {$DEFINE UNKNOWN_COMPILER_VERSION}

    {$IFDEF VER80}
      {$DEFINE COMPILER1}
      {$DEFINE DELPHI1}
      {$DEFINE DELPHICOMPILER1}
      {$DEFINE RTL80_UP}
      {$UNDEF UNKNOWN_COMPILER_VERSION}
    {$ENDIF}

    {$IFDEF VER90}
      {$DEFINE COMPILER2}
      {$DEFINE DELPHI2}
      {$DEFINE DELPHICOMPILER2}
      {$DEFINE RTL90_UP}
      {$UNDEF UNKNOWN_COMPILER_VERSION}
    {$ENDIF}

    {$IFDEF VER93}
      {$DEFINE COMPILER2}
      {$DEFINE BCB1}
      {$DEFINE BCB}
      {$DEFINE RTL93_UP}
      {$UNDEF UNKNOWN_COMPILER_VERSION}
    {$ENDIF}

    {$IFDEF VER100}
      {$DEFINE COMPILER3}
      {$DEFINE DELPHI3}
      {$DEFINE DELPHICOMPILER3}
      {$DEFINE RTL100_UP}
      {$UNDEF UNKNOWN_COMPILER_VERSION}
    {$ENDIF}

    {$IFDEF VER110}
      {$DEFINE COMPILER35}
      {$DEFINE BCB3}
      {$DEFINE RTL110_UP}
      {$UNDEF UNKNOWN_COMPILER_VERSION}
    {$ENDIF}

    {$IFDEF VER120}
      {$DEFINE COMPILER4}
      {$DEFINE DELPHI4}
      {$DEFINE DELPHICOMPILER4}
      {$DEFINE RTL120_UP}
      {$UNDEF UNKNOWN_COMPILER_VERSION}
    {$ENDIF}

    {$IFDEF VER125}
      {$DEFINE COMPILER4}
      {$DEFINE BCB4}
      {$DEFINE BCB}
      {$DEFINE RTL125_UP}
      {$UNDEF UNKNOWN_COMPILER_VERSION}
    {$ENDIF}

    {$IFDEF VER130}
      {$DEFINE COMPILER5}
      {$IFDEF BCB}
        {$DEFINE BCB5}
      {$ELSE}
        {$DEFINE DELPHI5}
        {$DEFINE DELPHICOMPILER5}
      {$ENDIF}
      {$DEFINE RTL130_UP}
      {$UNDEF UNKNOWN_COMPILER_VERSION}
    {$ENDIF}

    {$IFDEF VER140}
      {$DEFINE COMPILER6}
      {$IFDEF BCB}
        {$DEFINE BCB6}
      {$ELSE}
        {$DEFINE DELPHI6}
        {$DEFINE DELPHICOMPILER6}
      {$ENDIF}
      {$DEFINE RTL140_UP}
      {$UNDEF UNKNOWN_COMPILER_VERSION}
    {$ENDIF}

    {$IFDEF VER150}
      {$DEFINE COMPILER7}
      {$DEFINE DELPHI7}
      {$DEFINE DELPHICOMPILER7}
      {$DEFINE RTL150_UP}
      {$UNDEF UNKNOWN_COMPILER_VERSION}
    {$ENDIF}

    {$IFDEF VER160}
      {$DEFINE BDS2}
      {$DEFINE BDS}
      {$DEFINE COMPILER8}
      {$DEFINE DELPHI8}
      {$DEFINE DELPHICOMPILER8}
      {$DEFINE RTL160_UP}
      {$UNDEF UNKNOWN_COMPILER_VERSION}
    {$ENDIF}

    {$IFDEF VER170}
      {$DEFINE BDS3}
      {$DEFINE BDS}
      {$DEFINE COMPILER9}
      {$DEFINE DELPHI9}
      {$DEFINE DELPHI2005} // synonym to DELPHI9
      {$DEFINE DELPHICOMPILER9}
      {$DEFINE RTL170_UP}
      {$UNDEF UNKNOWN_COMPILER_VERSION}
    {$ENDIF}

    {$IFDEF VER180}
      {$DEFINE BDS}
      {$IFDEF VER185}
        {$DEFINE BDS5}
        {$DEFINE COMPILER11}
        {$IFDEF BCB}
          {$DEFINE BCB11}
        {$ELSE}
          {$DEFINE DELPHI11}
          {$DEFINE DELPHICOMPILER11}
        {$ENDIF}
        {$DEFINE RTL185_UP}
      {$ELSE ~~VER185}
        {$DEFINE BDS4}
        {$DEFINE COMPILER10}
        {$IFDEF BCB}
          {$DEFINE BCB10}
        {$ELSE}
          {$DEFINE DELPHI10}
          {$DEFINE DELPHICOMPILER10}
        {$ENDIF}
        {$DEFINE RTL180_UP}
      {$ENDIF ~VER185}
      {$UNDEF UNKNOWN_COMPILER_VERSION}
    {$ENDIF}

    {$IFDEF UNKNOWN_COMPILER_VERSION} // adjust for newer version
      {$DEFINE BDS5}
      {$DEFINE BDS}
      {$DEFINE COMPILER11}
      {$DEFINE DELPHI11}
      {$DEFINE DELPHICOMPILER11}
      {$DEFINE RTL185_UP}
      {$UNDEF UNKNOWN_COMPILER_VERSION}
    {$ENDIF}

  {$ENDIF ~KYLIX}

  {$IFDEF BCB}
    {$DEFINE CPPBUILDER}
    {$DEFINE BCBCOMPILER}
  {$ELSE ~BCB}
    {$DEFINE DELPHI}
    {$DEFINE DELPHICOMPILER}
  {$ENDIF ~BCB}

{$ENDIF BORLAND}

{------------------------------------------------------------------------------}
{ DELPHIX_UP from DELPHIX mappings                                             }
{------------------------------------------------------------------------------}

{$IFDEF DELPHI11 }  {$DEFINE DELPHI11_UP }  {$ENDIF}
{$IFDEF DELPHI10 }  {$DEFINE DELPHI10_UP }  {$ENDIF}
{$IFDEF DELPHI9  }  {$DEFINE DELPHI9_UP  }  {$ENDIF}
{$IFDEF DELPHI8  }  {$DEFINE DELPHI8_UP  }  {$ENDIF}
{$IFDEF DELPHI7  }  {$DEFINE DELPHI7_UP  }  {$ENDIF}
{$IFDEF DELPHI6  }  {$DEFINE DELPHI6_UP  }  {$ENDIF}
{$IFDEF DELPHI5  }  {$DEFINE DELPHI5_UP  }  {$ENDIF}
{$IFDEF DELPHI4  }  {$DEFINE DELPHI4_UP  }  {$ENDIF}
{$IFDEF DELPHI3  }  {$DEFINE DELPHI3_UP  }  {$ENDIF}
{$IFDEF DELPHI2  }  {$DEFINE DELPHI2_UP  }  {$ENDIF}
{$IFDEF DELPHI1  }  {$DEFINE DELPHI1_UP  }  {$ENDIF}

{------------------------------------------------------------------------------}
{ DELPHIX_UP from DELPHIX_UP mappings                                          }
{------------------------------------------------------------------------------}

{$IFDEF DELPHI11_UP}   {$DEFINE DELPHI10_UP }  {$ENDIF}
{$IFDEF DELPHI10_UP }  {$DEFINE DELPHI9_UP  }  {$ENDIF}

{$IFDEF DELPHI9_UP}
  {$DEFINE DELPHI2005_UP} // synonym to DELPHI9_UP
  {$DEFINE DELPHI8_UP}
{$ENDIF}

{$IFDEF DELPHI8_UP }  {$DEFINE DELPHI7_UP }  {$ENDIF}
{$IFDEF DELPHI7_UP }  {$DEFINE DELPHI6_UP }  {$ENDIF}
{$IFDEF DELPHI6_UP }  {$DEFINE DELPHI5_UP }  {$ENDIF}
{$IFDEF DELPHI5_UP }  {$DEFINE DELPHI4_UP }  {$ENDIF}
{$IFDEF DELPHI4_UP }  {$DEFINE DELPHI3_UP }  {$ENDIF}
{$IFDEF DELPHI3_UP }  {$DEFINE DELPHI2_UP }  {$ENDIF}
{$IFDEF DELPHI2_UP }  {$DEFINE DELPHI1_UP }  {$ENDIF}

{------------------------------------------------------------------------------}
{ BCBX_UP from BCBX mappings                                                   }
{------------------------------------------------------------------------------}

{$IFDEF BCB11}  {$DEFINE BCB11_UP}  {$ENDIF}
{$IFDEF BCB10}  {$DEFINE BCB10_UP}  {$ENDIF}
{$IFDEF BCB6 }  {$DEFINE BCB6_UP }  {$ENDIF}
{$IFDEF BCB5 }  {$DEFINE BCB5_UP }  {$ENDIF}
{$IFDEF BCB4 }  {$DEFINE BCB4_UP }  {$ENDIF}
{$IFDEF BCB3 }  {$DEFINE BCB3_UP }  {$ENDIF}
{$IFDEF BCB1 }  {$DEFINE BCB1_UP }  {$ENDIF}

{------------------------------------------------------------------------------}
{ BCBX_UP from BCBX_UP mappings                                                }
{------------------------------------------------------------------------------}

{$IFDEF BCB11_UP}  {$DEFINE BCB10_UP}  {$ENDIF}
{$IFDEF BCB10_UP}  {$DEFINE BCB6_UP }  {$ENDIF}
{$IFDEF BCB6_UP }  {$DEFINE BCB5_UP }  {$ENDIF}
{$IFDEF BCB5_UP }  {$DEFINE BCB4_UP }  {$ENDIF}
{$IFDEF BCB4_UP }  {$DEFINE BCB3_UP }  {$ENDIF}
{$IFDEF BCB3_UP }  {$DEFINE BCB1_UP }  {$ENDIF}

{------------------------------------------------------------------------------}
{ BDSX_UP from BDSX mappings                                                   }
{------------------------------------------------------------------------------}

{$IFDEF BDS5 }  {$DEFINE BDS5_UP }  {$ENDIF}
{$IFDEF BDS4 }  {$DEFINE BDS4_UP }  {$ENDIF}
{$IFDEF BDS3 }  {$DEFINE BDS3_UP }  {$ENDIF}
{$IFDEF BDS2 }  {$DEFINE BDS2_UP }  {$ENDIF}

{------------------------------------------------------------------------------}
{ BDSX_UP from BDSX_UP mappings                                                }
{------------------------------------------------------------------------------}

{$IFDEF BDS5_UP }  {$DEFINE BDS4_UP }  {$ENDIF}
{$IFDEF BDS4_UP }  {$DEFINE BDS3_UP }  {$ENDIF}
{$IFDEF BDS3_UP }  {$DEFINE BDS2_UP }  {$ENDIF}

{------------------------------------------------------------------------------}
{ DELPHICOMPILERX_UP from DELPHICOMPILERX mappings                             }
{------------------------------------------------------------------------------}

{$IFDEF DELPHICOMPILER11 }  {$DEFINE DELPHICOMPILER11_UP }  {$ENDIF}
{$IFDEF DELPHICOMPILER10 }  {$DEFINE DELPHICOMPILER10_UP }  {$ENDIF}
{$IFDEF DELPHICOMPILER9  }  {$DEFINE DELPHICOMPILER9_UP  }  {$ENDIF}
{$IFDEF DELPHICOMPILER8  }  {$DEFINE DELPHICOMPILER8_UP  }  {$ENDIF}
{$IFDEF DELPHICOMPILER7  }  {$DEFINE DELPHICOMPILER7_UP  }  {$ENDIF}
{$IFDEF DELPHICOMPILER6  }  {$DEFINE DELPHICOMPILER6_UP  }  {$ENDIF}