restemplate/indy/Protocols/IdCompilerDefines.inc

1687 lines
43 KiB
PHP

{$IFDEF CONDITIONALEXPRESSIONS}
// Must be at the top...
{$IF CompilerVersion >= 24.0}
{$LEGACYIFEND ON}
{$IFEND}
{$ENDIF}
// General
// Make this $DEFINE to use the 16 color icons required by Borland
// or DEFINE to use the 256 color Indy versions
{.$DEFINE Borland}
// S.G. 4/9/2002: IPv4/IPv6 general switch (for defaults only)
{$DEFINE IdIPv4}
{$DEFINE INDY100}
{$DEFINE 10_6_2} //so developers can IFDEF for this specific version
// When invoking DCC on the command-line, use the -DBCB
// parameter when generating C++Builder output files!
{$IFDEF BCB}
{$DEFINE CBUILDER}
{$ELSE}
{$DEFINE DELPHI}
{$ENDIF}
{$UNDEF USE_OPENSSL}
{$UNDEF STATICLOAD_OPENSSL}
{$UNDEF USE_ZLIB_UNIT}
{$UNDEF USE_SSPI}
// $DEFINE the following if the global objects in the IdStack and IdThread
// units should be freed on finalization
{.$DEFINE FREE_ON_FINAL}
{$UNDEF FREE_ON_FINAL}
// Make sure the following is $DEFINE'd only for suitable environments
// as specified further below. This works in conjunction with the
// FREE_ON_FINAL define above.
{$UNDEF REGISTER_EXPECTED_MEMORY_LEAK}
// FastMM is natively available in BDS 2006 and higher. $DEFINE the
// following if FastMM has been installed manually in earlier versions
{.$DEFINE USE_FASTMM4}
{$UNDEF USE_FASTMM4}
// $DEFINE the following if MadExcept has been installed manually in
// BDS 2005 or earlier (System.RegisterExpectedMemoryLeak() was introduced
// in BDS 2006)
{.$DEFINE USE_MADEXCEPT}
{$UNDEF USE_MADEXCEPT}
// Make sure the following are $DEFINE'd only for Delphi/C++Builder 2009 onwards
// as specified further below. The VCL is fully Unicode, where the 'String'
// type maps to System.UnicodeString, not System.AnsiString anymore
{$UNDEF STRING_IS_UNICODE}
{$UNDEF STRING_IS_ANSI}
{$UNDEF STRING_UNICODE_MISMATCH}
// Make sure the following are $DEFINE'd only for suitable environments
// as specified further below. Delphi/C++Builder Mobile/NextGen compilers
// do not support Ansi data types anymore, and is moving away from raw
// pointers as well.
{$DEFINE HAS_AnsiString}
{$DEFINE HAS_AnsiChar}
{$DEFINE HAS_PAnsiChar}
{$UNDEF HAS_PPAnsiChar}
{$UNDEF NO_ANSI_TYPES}
{$UNDEF USE_MARSHALLED_PTRS}
{$UNDEF HAS_MarshaledAString}
{$UNDEF USE_OBJECT_ARC}
// Make sure the following is $DEFINE'd only for suitable environments
// as specified further below.
{$UNDEF STRING_IS_IMMUTABLE}
{$UNDEF HAS_DIRECTIVE_ZEROBASEDSTRINGS}
// Make sure the following are $DEFINE'd only for suitable environments
// as specified further below.
{$UNDEF HAS_TEncoding}
{$UNDEF HAS_TEncoding_GetEncoding_ByEncodingName}
{$UNDEF HAS_Exception_RaiseOuterException}
{$UNDEF HAS_System_ReturnAddress}
{$UNDEF HAS_TCharacter}
{$UNDEF HAS_TInterlocked}
{$UNDEF HAS_TNetEncoding}
// Make sure that this is defined only for environments where we are using
// the iconv library to charactor conversions.
{.$UNDEF USE_ICONV}
//Define for Delphi cross-compiler targetting Posix
{$UNDEF USE_VCL_POSIX}
{$UNDEF HAS_ComponentPlatformsAttribute}
{$UNDEF HAS_ComponentPlatformsAttribute_Win32}
{$UNDEF HAS_ComponentPlatformsAttribute_Win64}
{$UNDEF HAS_ComponentPlatformsAttribute_OSX32}
{$UNDEF HAS_ComponentPlatformsAttribute_iOS_Simulator}
{$UNDEF HAS_ComponentPlatformsAttribute_Android}
{$UNDEF HAS_ComponentPlatformsAttribute_Linux32}
{$UNDEF HAS_ComponentPlatformsAttribute_iOS_Device}
{$UNDEF HAS_ComponentPlatformsAttribute_iOS_Device32}
{$UNDEF HAS_ComponentPlatformsAttribute_Linux64}
{$UNDEF HAS_ComponentPlatformsAttribute_WinNX32}
{$UNDEF HAS_ComponentPlatformsAttribute_WinIoT32}
{$UNDEF HAS_ComponentPlatformsAttribute_iOS_Device64}
{$UNDEF HAS_DIRECTIVE_WARN_DEFAULT}
// Define for Delphi to auto-generate platform-appropriate '#pragma link' statements in HPP files
{$UNDEF HAS_DIRECTIVE_HPPEMIT_LINKUNIT}
// detect compiler versions
// TODO: to detect features in Delphi/C++Builder v6 and later, use CompilerVersion
// and RTLVersion constants instead of VERXXX defines. We still support v5, which
// does not have such constants.
// Delphi 4
{$IFDEF VER120}
{$DEFINE DCC}
{$DEFINE VCL_40}
{$DEFINE DELPHI_4}
{$ENDIF}
// C++Builder 4
{$IFDEF VER125}
{$DEFINE DCC}
{$DEFINE VCL_40}
{$DEFINE CBUILDER_4}
{$ENDIF}
// Delphi & C++Builder 5
{$IFDEF VER130}
{$DEFINE DCC}
{$DEFINE VCL_50}
{$IFDEF CBUILDER}
{$DEFINE CBUILDER_5}
{$ELSE}
{$DEFINE DELPHI_5}
{$ENDIF}
{$ENDIF}
//Delphi & C++Builder 6
{$IFDEF VER140}
{$DEFINE DCC}
{$DEFINE VCL_60}
{$IFDEF CBUILDER}
{$DEFINE CBUILDER_6}
{$ELSE}
{$DEFINE DELPHI_6}
{$ENDIF}
{$ENDIF}
//Delphi 7
{$IFDEF VER150}
{$DEFINE DCC}
{$DEFINE VCL_70}
{$DEFINE DELPHI_7} // there was no C++ Builder 7
{$ENDIF}
//Delphi 8
{$IFDEF VER160}
{$DEFINE DCC}
{$DEFINE VCL_80}
{$DEFINE DELPHI_8} // there was no C++ Builder 8
{$ENDIF}
//Delphi 2005
{$IFDEF VER170}
{$DEFINE DCC}
{$DEFINE VCL_2005}
{$DEFINE DELPHI_2005} // there was no C++Builder 2005
{$ENDIF}
// NOTE: CodeGear decided to make Highlander be a non-breaking release
// (no interface changes, thus fully backwards compatible without any
// end user code changes), so VER180 applies to both BDS 2006 and
// Highlander prior to the release of RAD Studio 2007. Use VER185 to
// identify Highlanger specifically.
//Delphi & C++Builder 2006
//Delphi & C++Builder 2007 (Highlander)
{$IFDEF VER180}
{$DEFINE DCC}
{$DEFINE VCL_2006}
{$IFDEF CBUILDER}
{$DEFINE CBUILDER_2006}
{$ELSE}
{$DEFINE DELPHI_2006}
{$ENDIF}
{$ENDIF}
//Delphi & C++Builder 2007 (Highlander)
{$IFDEF VER185}
{$DEFINE DCC}
{$UNDEF VCL_2006}
{$DEFINE VCL_2007}
{$IFDEF CBUILDER}
{$UNDEF CBUILDER_2006}
{$DEFINE CBUILDER_2007}
{$ELSE}
{$UNDEF DELPHI_2006}
{$DEFINE DELPHI_2007}
{$ENDIF}
{$ENDIF}
// BDS 2007 NET personality uses VER190 instead of 185.
//Delphi .NET 2007
{$IFDEF VER190}
{$DEFINE DCC}
{$IFDEF CIL}
//Delphi 2007
{$DEFINE VCL_2007}
{$DEFINE DELPHI_2007}
{$ENDIF}
{$ENDIF}
//Delphi & C++Builder 2009 (Tiburon)
{$IFDEF VER200}
{$DEFINE DCC}
{$DEFINE VCL_2009}
{$IFDEF CBUILDER}
{$DEFINE CBUILDER_2009}
{$ELSE}
{$DEFINE DELPHI_2009}
{$ENDIF}
{$ENDIF}
//Delphi & C++Builder 2010 (Weaver)
{$IFDEF VER210}
{$DEFINE DCC}
{$DEFINE VCL_2010}
{$IFDEF CBUILDER}
{$DEFINE CBUILDER_2010}
{$ELSE}
{$DEFINE DELPHI_2010}
{$ENDIF}
{$ENDIF}
//Delphi & C++Builder XE (Fulcrum)
{$IFDEF VER220}
//REMOVE DCC DEFINE after the next Fulcrum beta.
//It will be defined there.
{$IFNDEF DCC}
{$DEFINE DCC}
{$ENDIF}
{$DEFINE VCL_XE}
{$IFDEF CBUILDER}
{$DEFINE CBUILDER_XE}
{$ELSE}
{$DEFINE DELPHI_XE}
{$ENDIF}
{$ENDIF}
// DCC is now defined by the Delphi compiler starting in XE2
//Delphi & CBuilder XE2 (Pulsar)
{$IFDEF VER230}
{$DEFINE VCL_XE2}
{$IFDEF CBUILDER}
{$DEFINE CBUILDER_XE2}
{$ELSE}
{$DEFINE DELPHI_XE2}
{$ENDIF}
{$ENDIF}
//Delphi & CBuilder XE3 (Waterdragon)
//Delphi & CBuilder XE3.5 (Quintessence - early betas only)
{$IFDEF VER240}
{$DEFINE VCL_XE3}
{$IFDEF CBUILDER}
{$DEFINE CBUILDER_XE3}
{$ELSE}
{$DEFINE DELPHI_XE3}
{$ENDIF}
{$ENDIF}
//Delphi & CBuilder XE4 (Quintessence)
{$IFDEF VER250}
{$UNDEF VCL_XE3}
{$DEFINE VCL_XE4}
{$IFDEF CBUILDER}
{$UNDEF CBUILDER_XE3}
{$DEFINE CBUILDER_XE4}
{$ELSE}
{$UNDEF DELPHI_XE3}
{$DEFINE DELPHI_XE4}
{$ENDIF}
{$ENDIF}
//Delphi & CBuilder XE5 (Zephyr)
{$IFDEF VER260}
{$DEFINE VCL_XE5}
{$IFDEF CBUILDER}
{$DEFINE CBUILDER_XE5}
{$ELSE}
{$DEFINE DELPHI_XE5}
{$ENDIF}
{$ENDIF}
//Delphi & CBuilder AppMethod
//AppMethod is just XE5 for mobile only, VCL is removed
{$IFDEF VER265}
{$DEFINE VCL_XE5}
{$IFDEF CBUILDER}
{$DEFINE CBUILDER_XE5}
{$ELSE}
{$DEFINE DELPHI_XE5}
{$ENDIF}
{$ENDIF}
//Delphi & CBuilder XE6 (Proteus)
{$IFDEF VER270}
{$DEFINE VCL_XE6}
{$IFDEF CBUILDER}
{$DEFINE CBUILDER_XE6}
{$ELSE}
{$DEFINE DELPHI_XE6}
{$ENDIF}
{$ENDIF}
//Delphi & CBuilder XE7 (Carpathia)
{$IFDEF VER280}
{$DEFINE VCL_XE7}
{$IFDEF CBUILDER}
{$DEFINE CBUILDER_XE7}
{$ELSE}
{$DEFINE DELPHI_XE7}
{$ENDIF}
{$ENDIF}
//Delphi & CBuilder XE8 (Elbrus)
{$IFDEF VER290}
{$DEFINE VCL_XE8}
{$IFDEF CBUILDER}
{$DEFINE CBUILDER_XE8}
{$ELSE}
{$DEFINE DELPHI_XE8}
{$ENDIF}
{$ENDIF}
//Delphi & CBuilder 10.0 Seattle (Aitana)
{$IFDEF VER300}
{$DEFINE VCL_SEATTLE}
{$IFDEF CBUILDER}
{$DEFINE CBUILDER_SEATTLE}
{$ELSE}
{$DEFINE DELPHI_SEATTLE}
{$ENDIF}
{$ENDIF}
// Delphi.NET
// Covers D8+
{$IFDEF CIL}
// Platform specific conditional. Used for platform specific code.
{$DEFINE DOTNET}
{$DEFINE STRING_IS_UNICODE}
{$DEFINE STRING_IS_IMMUTABLE}
{.$DEFINE HAS_Int8}
{.$DEFINE HAS_UInt8}
{$DEFINE HAS_Int16}
{$DEFINE HAS_UInt16}
{$DEFINE HAS_Int32}
{$DEFINE HAS_UInt32}
{$DEFINE HAS_UInt64}
{$ENDIF}
// Kylix
//
//Important: Don't use CompilerVersion here as IF's are evaluated before
//IFDEF's and Kylix 1 does not have CompilerVersion defined at all.
{$IFNDEF FPC}
{$IFDEF LINUX}
{$DEFINE UNIX}
{$IFDEF CONDITIONALEXPRESSIONS}
{$IF (RTLVersion >= 14.0) and (RTLVersion <= 14.5) }
{$DEFINE KYLIX}
{$IF RTLVersion = 14.5}
{$DEFINE KYLIX_3}
{$ELSEIF RTLVersion >= 14.2}
{$DEFINE KYLIX_2}
{$ELSE}
{$DEFINE KYLIX_1}
{$IFEND}
{$IFEND}
{$ENDIF}
{$ENDIF}
{$ENDIF}
{$IFDEF KYLIX}
{$DEFINE VCL_60}
{$DEFINE INT_THREAD_PRIORITY}
{$DEFINE CPUI386}
{$UNDEF USE_BASEUNIX}
{$IFDEF KYLIX_3}
{$DEFINE KYLIX_3_OR_ABOVE}
{$ENDIF}
{$IFDEF KYLIX_3_OR_ABOVE}
{$DEFINE KYLIX_2_OR_ABOVE}
{$ELSE}
{$IFDEF KYLIX_2}
{$DEFINE KYLIX_2_OR_ABOVE}
{$ENDIF}
{$ENDIF}
{$IFDEF KYLIX_2_OR_ABOVE}
{$DEFINE KYLIX_1_OR_ABOVE}
{$ELSE}
{$IFDEF KYLIX_1}
{$DEFINE KYLIX_1_OR_ABOVE}
{$ENDIF}
{$ENDIF}
{$IFNDEF KYLIX_3_OR_ABOVE}
{$DEFINE KYLIXCOMPAT}
{$ENDIF}
{$IFDEF KYLIX_2_OR_ABOVE}
{$DEFINE USE_ZLIB_UNIT}
{$ENDIF}
{$ENDIF}
// FPC (2+)
{$IFDEF FPC}
// TODO: In FreePascal 4.2.0+, a Delphi-like UnicodeString type is supported.
// However, String/(P)Char do not map to UnicodeString/(P)WideChar unless
// either {$MODE DelphiUnicode} or {$MODESWITCH UnicodeStrings} is used.
// We should consider enabling one of them so Indy uses the same Unicode logic
// in Delphi 2009+ and FreePascal 4.2.0+ and reduces IFDEFs (in particular,
// STRING_UNICODE_MISMATCH, see further below). However, FreePascal's RTL
// is largely not UnicodeString-enabled yet...
{$MODE Delphi}
//note that we may need further defines for widget types depending on
//what we do and what platforms we support in FPC.
//I'll let Marco think about that one.
{$IFDEF UNIX}
{$DEFINE USE_BASEUNIX}
{$IFDEF LINUX}
//In Linux for I386, you can choose between a Kylix-libc API or
//the standard RTL Unix API. Just pass -dKYLIXCOMPAT to the FPC compiler.
//I will see what I can do about the Makefile.
{$IFDEF KYLIXCOMPAT}
{$IFDEF CPUI386}
{$UNDEF USE_BASEUNIX}
{$ENDIF}
{$ENDIF}
{$ENDIF}
{$IFDEF USE_BASEUNIX}
{$UNDEF KYLIXCOMPAT}
{$ENDIF}
{$ENDIF}
// FPC_FULLVERSION was added in FPC 2.2.4
// Have to use Defined() or else Delphi compiler chokes, since it
// evaluates $IF statements before $IFDEF statements...
{$MACRO ON} // must be on in order to use versioning macros
{$IF DEFINED(FPC_FULLVERSION) AND (FPC_FULLVERSION >= 20701)}
{$DEFINE FPC_2_7_1_OR_ABOVE}
{$IFEND}
{$IF DEFINED(FPC_FULLVERSION) AND (FPC_FULLVERSION >= 20604)}
{$DEFINE FPC_2_6_4_OR_ABOVE}
{$IFEND}
{$IF DEFINED(FPC_FULLVERSION) AND (FPC_FULLVERSION >= 20602)}
{$DEFINE FPC_2_6_2_OR_ABOVE}
{$IFEND}
{$IF DEFINED(FPC_FULLVERSION) AND (FPC_FULLVERSION >= 20600)}
{$DEFINE FPC_2_6_0_OR_ABOVE}
{$IFEND}
{$IF DEFINED(FPC_FULLVERSION) AND (FPC_FULLVERSION >= 20404)}
{$DEFINE FPC_2_4_4_OR_ABOVE}
{$IFEND}
{$IF DEFINED(FPC_FULLVERSION) AND (FPC_FULLVERSION >= 20402)}
{$DEFINE FPC_2_4_2_OR_ABOVE}
{$IFEND}
{$IF DEFINED(FPC_FULLVERSION) AND (FPC_FULLVERSION >= 20400)}
{$DEFINE FPC_2_4_0_OR_ABOVE}
{$IFEND}
{$IF DEFINED(FPC_FULLVERSION) AND (FPC_FULLVERSION >= 20204)}
{$DEFINE FPC_2_2_4_OR_ABOVE}
{$IFEND}
{$IF DEFINED(FPC_FULLVERSION) AND (FPC_FULLVERSION >= 20202)}
{$DEFINE FPC_2_2_2_OR_ABOVE}
{$IFEND}
{$IF DEFINED(FPC_FULLVERSION) AND (FPC_FULLVERSION >= 20105)}
{$DEFINE FPC_2_1_5_OR_ABOVE}
{$IFEND}
// just in case
{$IFDEF FPC_2_7_1}
{$DEFINE FPC_2_7_1_OR_ABOVE}
{$ENDIF}
{$IFDEF FPC_2_6_4}
{$DEFINE FPC_2_6_4_OR_ABOVE}
{$ENDIF}
{$IFDEF FPC_2_6_2}
{$DEFINE FPC_2_6_2_OR_ABOVE}
{$ENDIF}
{$IFDEF FPC_2_6_0}
{$DEFINE FPC_2_6_0_OR_ABOVE}
{$ENDIF}
{$IFDEF FPC_2_4_4}
{$DEFINE FPC_2_4_4_OR_ABOVE}
{$ENDIF}
{$IFDEF FPC_2_4_2}
{$DEFINE FPC_2_4_2_OR_ABOVE}
{$ENDIF}
{$IFDEF FPC_2_4_0}
{$DEFINE FPC_2_4_0_OR_ABOVE}
{$ENDIF}
{$IFDEF FPC_2_2_4}
{$DEFINE FPC_2_2_4_OR_ABOVE}
{$ENDIF}
{$IFDEF FPC_2_2_2}
{$DEFINE FPC_2_2_2_OR_ABOVE}
{$ENDIF}
{$IFDEF FPC_2_1_5}
{$DEFINE FPC_2_1_5_OR_ABOVE}
{$ENDIF}
{$IFDEF FPC_2_7_1_OR_ABOVE}
{$DEFINE FPC_2_6_4_OR_ABOVE}
{$ELSE}
{$IFDEF FPC_2_6_4}
{$DEFINE FPC_2_6_4_OR_ABOVE}
{$ENDIF}
{$ENDIF}
{$IFDEF FPC_2_6_4_OR_ABOVE}
{$DEFINE FPC_2_6_2_OR_ABOVE}
{$ELSE}
{$IFDEF FPC_2_6_2}
{$DEFINE FPC_2_6_2_OR_ABOVE}
{$ENDIF}
{$ENDIF}
{$IFDEF FPC_2_6_2_OR_ABOVE}
{$DEFINE FPC_2_6_0_OR_ABOVE}
{$ELSE}
{$IFDEF FPC_2_6_0}
{$DEFINE FPC_2_6_0_OR_ABOVE}
{$ENDIF}
{$ENDIF}
{$IFDEF FPC_2_6_0_OR_ABOVE}
{$DEFINE FPC_2_4_4_OR_ABOVE}
{$ELSE}
{$IFDEF FPC_2_4_4}
{$DEFINE FPC_2_4_4_OR_ABOVE}
{$ENDIF}
{$ENDIF}
{$IFDEF FPC_2_4_4_OR_ABOVE}
{$DEFINE FPC_2_4_2_OR_ABOVE}
{$ELSE}
{$IFDEF FPC_2_4_2}
{$DEFINE FPC_2_4_2_OR_ABOVE}
{$ENDIF}
{$ENDIF}
{$IFDEF FPC_2_4_2_OR_ABOVE}
{$DEFINE FPC_2_4_0_OR_ABOVE}
{$ELSE}
{$IFDEF FPC_2_4_0}
{$DEFINE FPC_2_4_0_OR_ABOVE}
{$ENDIF}
{$ENDIF}
{$IFDEF FPC_2_4_0_OR_ABOVE}
{$DEFINE FPC_2_2_4_OR_ABOVE}
{$ELSE}
{$IFDEF FPC_2_2_4}
{$DEFINE FPC_2_2_4_OR_ABOVE}
{$ENDIF}
{$ENDIF}
{$IFDEF FPC_2_2_4_OR_ABOVE}
{$DEFINE FPC_2_2_2_OR_ABOVE}
{$ELSE}
{$IFDEF FPC_2_2_2}
{$DEFINE FPC_2_2_2_OR_ABOVE}
{$ENDIF}
{$ENDIF}
{$IFDEF FPC_2_2_2_OR_ABOVE}
{$DEFINE FPC_2_2_0_OR_ABOVE}
{$ELSE}
{$IFDEF VER2_2}
{$DEFINE FPC_2_2_0_OR_ABOVE}
{$ENDIF}
{$ENDIF}
{$IFDEF FPC_2_2_0_OR_ABOVE}
{$DEFINE FPC_2_1_5_OR_ABOVE}
{$ELSE}
{$IFDEF FPC_2_1_5}
{$DEFINE FPC_2_1_5_OR_ABOVE}
{$ENDIF}
{$ENDIF}
{.$IFDEF FPC_2_7_1_OR_ABOVE}
// support for RawByteString and UnicodeString
{.$DEFINE VCL_2009}
{.$DEFINE DELPHI_2009}
{.$ELSE}
{$DEFINE VCL_70}
{$DEFINE DELPHI_7}
{.$ENDIF}
{$ENDIF}
// end FPC
{$IFDEF VCL_SEATTLE}
{$DEFINE VCL_SEATTLE_OR_ABOVE}
{$ENDIF}
{$IFDEF VCL_SEATTLE_OR_ABOVE}
{$DEFINE VCL_XE8_OR_ABOVE}
{$ELSE}
{$IFDEF VCL_XE8}
{$DEFINE VCL_XE8_OR_ABOVE}
{$ENDIF}
{$ENDIF}
{$IFDEF VCL_XE8_OR_ABOVE}
{$DEFINE VCL_XE7_OR_ABOVE}
{$ELSE}
{$IFDEF VCL_XE7}
{$DEFINE VCL_XE7_OR_ABOVE}
{$ENDIF}
{$ENDIF}
{$IFDEF VCL_XE7_OR_ABOVE}
{$DEFINE VCL_XE6_OR_ABOVE}
{$ELSE}
{$IFDEF VCL_XE6}
{$DEFINE VCL_XE6_OR_ABOVE}
{$ENDIF}
{$ENDIF}
{$IFDEF VCL_XE6_OR_ABOVE}
{$DEFINE VCL_XE5_OR_ABOVE}
{$DEFINE VCL_XE5_UPDATE2_OR_ABOVE}
{$ELSE}
{$IFDEF VCL_XE5}
{$DEFINE VCL_XE5_OR_ABOVE}
// TODO: figure out how to detect this version
{.$DEFINE VCL_XE5_UPDATE2_OR_ABOVE}
{$ENDIF}
{$ENDIF}
{$IFDEF VCL_XE5_OR_ABOVE}
{$DEFINE VCL_XE4_OR_ABOVE}
{$ELSE}
{$IFDEF VCL_XE4}
{$DEFINE VCL_XE4_OR_ABOVE}
{$ENDIF}
{$ENDIF}
{$IFDEF VCL_XE4_OR_ABOVE}
{$DEFINE VCL_XE3_OR_ABOVE}
{$ELSE}
{$IFDEF VCL_XE3}
{$DEFINE VCL_XE3_OR_ABOVE}
{$ENDIF}
{$ENDIF}
{$IFDEF VCL_XE3_OR_ABOVE}
{$DEFINE VCL_XE2_OR_ABOVE}
{$ELSE}
{$IFDEF VCL_XE2}
{$DEFINE VCL_XE2_OR_ABOVE}
{$ENDIF}
{$ENDIF}
{$IFDEF VCL_XE2_OR_ABOVE}
{$DEFINE VCL_XE_OR_ABOVE}
{$ELSE}
{$IFDEF VCL_XE}
{$DEFINE VCL_XE_OR_ABOVE}
{$ENDIF}
{$ENDIF}
{$IFDEF VCL_XE_OR_ABOVE}
{$DEFINE VCL_2010_OR_ABOVE}
{$ELSE}
{$IFDEF VCL_2010}
{$DEFINE VCL_2010_OR_ABOVE}
{$ENDIF}
{$ENDIF}
{$IFDEF VCL_2010_OR_ABOVE}
{$DEFINE VCL_2009_OR_ABOVE}
{$ELSE}
{$IFDEF VCL_2009}
{$DEFINE VCL_2009_OR_ABOVE}
{$ENDIF}
{$ENDIF}
{$IFDEF VCL_2009_OR_ABOVE}
{$DEFINE VCL_2007_OR_ABOVE}
{$ELSE}
{$IFDEF VCL_2007}
{$DEFINE VCL_2007_OR_ABOVE}
{$ENDIF}
{$ENDIF}
{$IFDEF VCL_2007_OR_ABOVE}
{$DEFINE VCL_2006_OR_ABOVE}
{$ELSE}
{$IFDEF VCL_2006}
{$DEFINE VCL_2006_OR_ABOVE}
{$ENDIF}
{$ENDIF}
{$IFDEF VCL_2006_OR_ABOVE}
{$DEFINE VCL_2005_OR_ABOVE}
{$ELSE}
{$IFDEF VCL_2005}
{$DEFINE VCL_2005_OR_ABOVE}
{$ENDIF}
{$ENDIF}
{$IFDEF VCL_2005_OR_ABOVE}
{$DEFINE VCL_8_OR_ABOVE}
{$ELSE}
{$IFDEF VCL_80}
{$DEFINE VCL_8_OR_ABOVE}
{$ENDIF}
{$ENDIF}
{$IFDEF VCL_8_OR_ABOVE}
{$DEFINE VCL_7_OR_ABOVE}
{$ELSE}
{$IFDEF VCL_70}
{$DEFINE VCL_7_OR_ABOVE}
{$ENDIF}
{$ENDIF}
{$IFDEF VCL_7_OR_ABOVE}
{$DEFINE VCL_6_OR_ABOVE}
{$ELSE}
{$IFDEF VCL_60}
{$DEFINE VCL_6_OR_ABOVE}
{$ENDIF}
{$ENDIF}
{$IFDEF VCL_6_OR_ABOVE}
{$DEFINE VCL_5_OR_ABOVE}
{$ELSE}
{$IFDEF VCL_50}
{$DEFINE VCL_5_OR_ABOVE}
{$ENDIF}
{$ENDIF}
{$IFDEF VCL_5_OR_ABOVE}
{$DEFINE VCL_4_OR_ABOVE}
{$ELSE}
{$IFDEF VCL_40}
{$DEFINE VCL_4_OR_ABOVE}
{$ENDIF}
{$ENDIF}
// Normalize Delphi compiler defines to match FPC for consistency:
//
// CPU32 - any 32-bit CPU
// CPU64 - any 64-bit CPU
// WINDOWS - any Windows platform (32-bit, 64-bit, CE)
// WIN32 - Windows 32-bit
// WIN64 - Windows 64-bit
// WINCE - Windows CE
//
// Consult the "Free Pascal Programmer's Guide", Appendix G for the complete
// list of defines that are used. Do not work on this unless you understand
// what the FreePascal developers are doing. Not only do you have to
// descriminate with operating systems, but also with chip architectures
// are well.
//
// DCC Pulsar+ define the following values:
// ASSEMBLER
// DCC
// CONDITIONALEXPRESSIONS
// NATIVECODE
// UNICODE
// MACOS
// MACOS32
// MACOS64
// MSWINDOWS
// WIN32
// WIN64
// LINUX
// POSIX
// POSIX32
// CPU386
// CPUX86
// CPUX64
//
// Kylix defines the following values:
// LINUX
// (others??)
//
{$IFNDEF FPC}
// TODO: We need to use ENDIAN_BIG for big endian chip architectures,
// such as 680x0, PowerPC, Sparc, and MIPS, once DCC supports them,
// provided it does not already define its own ENDIAN values by then...
{$DEFINE ENDIAN_LITTLE}
{$IFNDEF VCL_6_OR_ABOVE}
{$DEFINE MSWINDOWS}
{$ENDIF}
{$IFDEF MSWINDOWS}
{$DEFINE WINDOWS}
{$ENDIF}
// TODO: map Pulsar's non-Windows platform defines...
{$IFDEF VCL_XE2_OR_ABOVE}
{$IFDEF CPU386}
//any 32-bit CPU
{$DEFINE CPU32}
//Intel 386 compatible chip architecture
{$DEFINE CPUI386}
{$ENDIF}
{$IFDEF CPUX86}
{$DEFINE CPU32}
{$ENDIF}
{$IFDEF CPUX64}
//any 64-bit CPU
{$DEFINE CPU64}
//AMD64 compatible chip architecture
{$DEFINE CPUX86_64} //historical name for AMD64
{$DEFINE CPUAMD64}
{$ENDIF}
{$ELSE}
{$IFNDEF DOTNET}
{$IFNDEF KYLIX}
{$DEFINE I386}
{$ENDIF}
{$ENDIF}
{$DEFINE CPU32}
{$ENDIF}
{$ENDIF}
{$IFDEF DOTNET}
//differences in DotNET Framework versions.
{$IFDEF VCL_2007_OR_ABOVE}
{$DEFINE DOTNET_2}
{$DEFINE DOTNET_2_OR_ABOVE}
{$ELSE}
{$DEFINE DOTNET_1_1}
{$ENDIF}
{$DEFINE DOTNET_1_1_OR_ABOVE}
// Extra include used in D7 for testing. Remove later when all comps are
// ported. Used to selectively exclude non ported parts. Allowed in places
// IFDEFs are otherwise not permitted.
{$DEFINE DOTNET_EXCLUDE}
{$ENDIF}
// Check for available features
{$IFDEF CBUILDER}
// When generating a C++ HPP file, if a class has no explicit constructor
// defined and contains compiler-managed members (xxxString, TDateTime,
// Variant, DelphiInterface, etc), the HPP will contain a forwarding
// inline constructor that implicitally initializes those managed members,
// which will overwrite any non-default initializations performed inside
// of InitComponent() overrides! In this situation, the workaround is to
// define an explicit constructor that forwards to the base class constructor
// manually.
{$DEFINE WORKAROUND_INLINE_CONSTRUCTORS}
{$ENDIF}
{$IFDEF VCL_5_OR_ABOVE}
{$IFNDEF FPC}
{$IFNDEF KYLIX}
{$DEFINE HAS_RemoveFreeNotification}
{$ENDIF}
{$ENDIF}
{$DEFINE HAS_GetObjectProp}
{$DEFINE HAS_TObjectList}
{$ENDIF}
{$IFDEF VCL_6_OR_ABOVE}
{$DEFINE HAS_PCardinal}
{$DEFINE HAS_PByte}
{$DEFINE HAS_PWord}
{$DEFINE HAS_PPointer}
{$DEFINE HAS_TList_Assign}
{$DEFINE HAS_sLineBreak}
{$DEFINE HAS_RaiseLastOSError}
{$DEFINE HAS_SysUtils_IncludeExcludeTrailingPathDelimiter}
{$DEFINE HAS_SysUtils_DirectoryExists}
{$DEFINE HAS_UNIT_DateUtils}
{$DEFINE HAS_UNIT_StrUtils}
{$DEFINE HAS_UNIT_Types}
{$DEFINE HAS_TryStrToInt}
{$DEFINE HAS_TryStrToInt64}
{$DEFINE HAS_TryEncodeDate}
{$DEFINE HAS_TryEncodeTime}
{$DEFINE HAS_ENUM_ELEMENT_VALUES}
{$IFNDEF FPC}
{$DEFINE HAS_IInterface}
{$DEFINE HAS_TSelectionEditor}
{$DEFINE HAS_TStringList_CaseSensitive}
{$IFNDEF KYLIX}
{$DEFINE HAS_DEPRECATED}
{$DEFINE HAS_SYMBOL_PLATFORM}
{$DEFINE HAS_UNIT_PLATFORM}
{$IFNDEF VCL_8_OR_ABOVE}
// Delphi 6 and 7 have an annoying bug that if a class method is declared as
// deprecated, the compiler will emit a "symbol is deprecated" warning
// on the method's implementation! So we will have to wrap implementations
// of deprecated methods with {$WARN SYMBOL_DEPRECATED OFF} directives
// to disable that warning.
{$DEFINE DEPRECATED_IMPL_BUG}
{$ENDIF}
{$ENDIF}
{$ENDIF}
{$IFNDEF DOTNET}
//Widget defines are omitted in .NET
{$DEFINE VCL_60_PLUS}
{$ENDIF}
{$ENDIF}
{$IFDEF VCL_7_OR_ABOVE}
{$IFNDEF FPC}
{$DEFINE HAS_UInt64}
{$DEFINE HAS_NAMED_THREADS}
{$DEFINE HAS_TStrings_ValueFromIndex}
{$ENDIF}
{$DEFINE HAS_TFormatSettings}
{$DEFINE HAS_PosEx}
{$IFNDEF VCL_70}
// not implemented in D7
{$DEFINE HAS_STATIC_TThread_Queue}
{$ENDIF}
{$IFNDEF CIL}
{$IFNDEF VCL_80}
// not implemented in D8 or .NET
{$DEFINE HAS_STATIC_TThread_Synchronize}
{$ENDIF}
{$ENDIF}
{$ELSE}
{$IFDEF CBUILDER_6}
{$DEFINE HAS_NAMED_THREADS}
{$ENDIF}
{$ENDIF}
{$IFNDEF VCL_2005_OR_ABOVE}
{$IFDEF DCC}
{$DEFINE HAS_InterlockedCompareExchange_Pointers}
{$ENDIF}
{$ENDIF}
{$IFDEF VCL_2006_OR_ABOVE}
{$DEFINE USE_INLINE}
{$DEFINE HAS_2PARAM_FileAge}
{$DEFINE HAS_System_RegisterExpectedMemoryLeak}
{$IFNDEF FREE_ON_FINAL}
{$IFNDEF DOTNET}
{$DEFINE REGISTER_EXPECTED_MEMORY_LEAK}
{$ENDIF}
{$ENDIF}
// UInt64 is emitted as signed __int64 instead of unsigned __int64 in HPP files
{$IFDEF CBUILDER}
{$DEFINE BROKEN_UINT64_HPPEMIT}
{$ENDIF}
{$ENDIF}
{$IFDEF VCL_2007_OR_ABOVE}
{$IFNDEF CBUILDER_2007}
// class properties are broken in C++Builder 2007, causing AVs at compile-time
{$DEFINE HAS_CLASSPROPERTIES}
{$ENDIF}
// Native(U)Int exist but are buggy, so do not use them yet
{.$DEFINE HAS_NativeInt}
{.$DEFINE HAS_NativeUInt}
{$DEFINE HAS_StrToInt64Def}
{$DEFINE HAS_DWORD_PTR}
{$DEFINE HAS_ULONG_PTR}
{$DEFINE HAS_ULONGLONG}
{$DEFINE HAS_PGUID}
{$DEFINE HAS_PPAnsiChar}
{$DEFINE HAS_CurrentYear}
{$IFNDEF DOTNET}
{$DEFINE HAS_TIMEUNITS}
{$ENDIF}
{$ENDIF}
{$IFDEF VCL_2009_OR_ABOVE}
{$IFNDEF DOTNET}
{$DEFINE STRING_IS_UNICODE}
{$DEFINE HAS_UnicodeString}
{$DEFINE HAS_TEncoding}
{$DEFINE HAS_TCharacter}
{$DEFINE HAS_InterlockedCompareExchangePointer}
{$DEFINE HAS_WIDE_TCharArray}
{$DEFINE HAS_UNIT_AnsiStrings}
{$DEFINE HAS_PUInt64}
{$IFDEF VCL_2009}
// TODO: need to differentiate between RTM and Update 1
// FmtStr() is broken in RTM but was fixed in Update 1
{$DEFINE BROKEN_FmtStr}
{$ENDIF}
{$ENDIF}
{$DEFINE HAS_CLASSVARS}
{$DEFINE HAS_DEPRECATED_MSG}
{$DEFINE HAS_TBytes}
// Native(U)Int are still buggy, so do not use them yet
{.$DEFINE HAS_NativeInt}
{.$DEFINE HAS_NativeUInt}
{$DEFINE HAS_Int8}
{$DEFINE HAS_UInt8}
{$DEFINE HAS_Int16}
{$DEFINE HAS_UInt16}
{$DEFINE HAS_Int32}
{$DEFINE HAS_UInt32}
// UInt64 is now emitted as unsigned __int64 in HPP files
{$IFDEF CBUILDER}
{$UNDEF BROKEN_UINT64_HPPEMIT}
{$ENDIF}
{$IFDEF DCC}
{$IFDEF WINDOWS}
// Exception.RaiseOuterException() is only available on Windows at this time
{$DEFINE HAS_Exception_RaiseOuterException}
{$ENDIF}
{$ENDIF}
{$ENDIF}
{$IFDEF VCL_2010_OR_ABOVE}
{$DEFINE HAS_CLASSCONSTRUCTOR}
{$DEFINE HAS_CLASSDESTRUCTOR}
{$DEFINE HAS_DELAYLOAD}
{$DEFINE HAS_TThread_NameThreadForDebugging}
{$DEFINE DEPRECATED_TThread_SuspendResume}
// Native(U)Int are finally ok to use now
{$DEFINE HAS_NativeInt}
{$DEFINE HAS_NativeUInt}
{$DEFINE HAS_USHORT}
{$ENDIF}
{$IFDEF VCL_XE_OR_ABOVE}
{$DEFINE HAS_TFormatSettings_Object}
{$DEFINE HAS_LocaleCharsFromUnicode}
{$DEFINE HAS_UnicodeFromLocaleChars}
{$DEFINE HAS_PVOID}
{$DEFINE HAS_ULONG64}
{$DEFINE HAS_TEncoding_GetEncoding_ByEncodingName}
{$IFDEF DCC}
// Exception.RaiseOuterException() is now available on all platforms
{$DEFINE HAS_Exception_RaiseOuterException}
{$ENDIF}
{$IFNDEF DOTNET}
{$DEFINE HAS_TInterlocked}
{$ENDIF}
{$ENDIF}
{$IFDEF VCL_XE2_OR_ABOVE}
{$DEFINE HAS_SIZE_T}
{$DEFINE HAS_PSIZE_T}
{$DEFINE HAS_LONG}
{$DEFINE HAS_ComponentPlatformsAttribute}
{$DEFINE HAS_ComponentPlatformsAttribute_Win32}
{$DEFINE HAS_ComponentPlatformsAttribute_Win64}
{$DEFINE HAS_ComponentPlatformsAttribute_OSX32}
{$DEFINE HAS_System_ReturnAddress}
{$DEFINE HAS_DIRECTIVE_WARN_DEFAULT}
{$ENDIF}
{$IFDEF VCL_XE3_OR_ABOVE}
{$DEFINE HAS_DIRECTIVE_ZEROBASEDSTRINGS}
{$DEFINE HAS_SysUtils_TStringHelper}
{$IFDEF NEXTGEN}
{$DEFINE DCC_NEXTGEN}
{$DEFINE HAS_MarshaledAString}
{$DEFINE USE_MARSHALLED_PTRS}
{$IFDEF AUTOREFCOUNT}
{$DEFINE USE_OBJECT_ARC}
{$ENDIF}
{$ENDIF}
{$ENDIF}
{$IFDEF VCL_XE4_OR_ABOVE}
{$DEFINE HAS_AnsiStrings_StrPLCopy}
{$DEFINE HAS_AnsiStrings_StrLen}
{$DEFINE HAS_Character_TCharHelper}
{$DEFINE HAS_ComponentPlatformsAttribute_iOS_Simulator}
{$DEFINE HAS_ComponentPlatformsAttribute_iOS_Device}
// technically, these are present in XE4, but they are not used yet
{.$DEFINE HAS_ComponentPlatformsAttribute_Android}
{.$DEFINE HAS_ComponentPlatformsAttribute_Linux32}
{.$DEFINE HAS_ComponentPlatformsAttribute_WinNX32}
{$ENDIF}
{$IFDEF VCL_XE5_OR_ABOVE}
{$DEFINE HAS_ComponentPlatformsAttribute_Android}
{$ENDIF}
{$IFDEF VCL_XE5_UPDATE2_OR_ABOVE}
{$DEFINE HAS_DIRECTIVE_HPPEMIT_LINKUNIT}
{$ENDIF}
{$IFDEF VCL_XE7_OR_ABOVE}
{$DEFINE HAS_TNetEncoding}
{$ENDIF}
{$IFDEF VCL_XE8_OR_ABOVE}
{$DEFINE HAS_ComponentPlatformsAttribute_iOS_Device32}
{$DEFINE HAS_ComponentPlatformsAttribute_iOS_Device64}
// technically, these are present in XE8, but they are not used yet
{.$DEFINE HAS_ComponentPlatformsAttribute_Linux64}
{.$DEFINE HAS_ComponentPlatformsAttribute_WinIoT32}
{$ENDIF}
// Delphi XE+ cross-compiling
{$IFNDEF FPC}
{$IFDEF POSIX}
{$IF RTLVersion >= 22.0}
{$DEFINE UNIX}
{$UNDEF USE_BASEUNIX}
{$DEFINE VCL_CROSS_COMPILE}
{$DEFINE USE_VCL_POSIX}
{$IFEND}
{$ENDIF}
{$IFDEF LINUX}
{$IFDEF CONDITIONALEXPRESSIONS}
{$IF RTLVersion >= 22.0}
{$DEFINE VCL_CROSS_COMPILE}
{$DEFINE USE_VCL_POSIX}
{$IFEND}
{$ENDIF}
{$ENDIF}
{$ENDIF}
{$IFDEF VCL_CROSS_COMPILE}
{$UNDEF KYLIXCOMPAT}
{$ELSE}
{$IFDEF KYLIXCOMPAT}
{$linklib c}
{$ENDIF}
{$ENDIF}
{$IFDEF FPC}
{$DEFINE USE_INLINE}
{$DEFINE USE_CLASSINLINE}
{$DEFINE USE_TBitBtn} //use Bit Buttons instead of Buttons
{$DEFINE FPC_REINTRODUCE_BUG}
{$DEFINE FPC_CIRCULAR_BUG}
{$DEFINE NO_REDECLARE}
{$DEFINE BYTE_COMPARE_SETS}
{$DEFINE HAS_QWord} // TODO: when was QWord introduced?
{$DEFINE HAS_PQWord} // TODO: when was PQWord introduced?
{$IFDEF FPC_2_1_5_OR_ABOVE}
{$DEFINE HAS_UInt64}
{.$DEFINE HAS_PUInt64} // TODO: is this defined?
{$ENDIF}
{$IFDEF FPC_2_2_0_OR_ABOVE}
{$DEFINE HAS_InterlockedCompareExchange_Pointers}
{$ENDIF}
{$IFDEF FPC_2_2_2_OR_ABOVE}
{$DEFINE HAS_SharedPrefix}
{$ENDIF}
{$IFDEF FPC_2_2_4_OR_ABOVE}
// size_t and psize_t are only available on Unix systems (FreeBSD, Linux, etc)
{$IFDEF UNIX}
{$DEFINE HAS_SIZE_T}
{$DEFINE HAS_PSIZE_T}
{$ENDIF}
{$ENDIF}
{$DEFINE HAS_PtrInt}
{$DEFINE HAS_PtrUInt}
{$DEFINE HAS_PGUID}
{$DEFINE HAS_LPGUID}
{$DEFINE HAS_PPAnsiChar}
{$DEFINE HAS_ENUM_ELEMENT_VALUES}
{$IFDEF WINDOWS}
{$DEFINE HAS_ULONG_PTR}
{.$DEFINE HAS_ULONGLONG} // TODO: is this defined?
{$ENDIF}
{$DEFINE HAS_UNIT_ctypes}
{$DEFINE HAS_sLineBreak}
{$IFDEF FPC_HAS_UNICODESTRING}
{$DEFINE HAS_UnicodeString}
{$ELSE}
{$IFDEF FPC_2_4_0_OR_ABOVE}
{$DEFINE HAS_UnicodeString}
{$ENDIF}
{$ENDIF}
{$IFDEF FPC_2_4_4_OR_ABOVE}
{$DEFINE DEPRECATED_TThread_SuspendResume}
{$DEFINE HAS_DEPRECATED} // TODO: when was deprecated introduced?
{$DEFINE HAS_DEPRECATED_MSG}
{$ENDIF}
{$IFDEF FPC_2_6_0_OR_ABOVE}
{$DEFINE HAS_NativeInt}
{$DEFINE HAS_NativeUInt}
{$ENDIF}
{$IFDEF FPC_2_6_2_OR_ABOVE}
{$DEFINE HAS_Int8}
{$DEFINE HAS_UInt8}
{$DEFINE HAS_Int16}
{$DEFINE HAS_UInt16}
{$DEFINE HAS_Int32}
{$DEFINE HAS_UInt32}
{$ENDIF}
{$IFDEF FPC_2_6_4_OR_ABOVE}
{$DEFINE HAS_PInt8}
{$DEFINE HAS_PUInt8}
{$DEFINE HAS_PInt16}
{$DEFINE HAS_PUInt16}
{$DEFINE HAS_PInt32}
{$DEFINE HAS_PUInt32}
{$ENDIF}
{$IFDEF FPC_UNICODESTRINGS}
{$DEFINE STRING_IS_UNICODE}
{$ENDIF}
{$ENDIF}
{$IFDEF DOTNET}
{$DEFINE WIDGET_WINFORMS}
{$ELSE}
{$DEFINE WIDGET_VCL_LIKE} // LCL included.
{$DEFINE WIDGET_VCL_LIKE_OR_KYLIX}
{$IFDEF FPC}
{$DEFINE WIDGET_LCL}
{$ELSE}
{$IFDEF KYLIX}
{$DEFINE WIDGET_KYLIX}
{$ELSE}
{$DEFINE WIDGET_VCL}
{$ENDIF}
{$ENDIF}
{$ENDIF}
// .NET and Delphi 2009+ support UNICODE strings natively!
//
// FreePascal 2.4.0+ supports UnicodeString, but does not map its
// native String type to UnicodeString except when {$MODE DelphiUnicode}
// or {$MODESWITCH UnicodeStrings} is enabled. However, UNICODE is not
// defined in that mode yet until its RTL has been updated to support
// UnicodeString. STRING_UNICODE_MISMATCH is defined when the native
// String/Char types do not map to the same types that APIs are expecting
// based on whether UNICODE is defined or not.
//
// NOTE: Do not define UNICODE here. The compiler defines
// the symbol automatically.
{$IFDEF STRING_IS_UNICODE}
{$IFNDEF UNICODE}
{$DEFINE STRING_UNICODE_MISMATCH}
{$ENDIF}
{$ELSE}
{$DEFINE STRING_IS_ANSI}
{$IFDEF UNICODE}
{$DEFINE STRING_UNICODE_MISMATCH}
{$ENDIF}
{$ENDIF}
{$IFDEF DCC_NEXTGEN}
{$DEFINE NO_ANSI_TYPES}
{.$DEFINE STRING_IS_IMMUTABLE} // Strings are NOT immutable in NEXTGEN yet
{$IFDEF USE_OBJECT_ARC}
// TODO: move these to an appropriate section. Not doing this yet because
// it is a major interface change to switch to Generics and we should
// maintain backwards compatibility with earlier compilers for the time
// being. Defining them only here for now because the non-Generic versions
// of these classes have become deprecated by ARC and so we need to start
// taking advantage of the Generics versions...
{$DEFINE HAS_UNIT_Generics_Collections}
{$DEFINE HAS_UNIT_Generics_Defaults}
{$DEFINE HAS_GENERICS_TDictionary}
{$DEFINE HAS_GENERICS_TList}
{$DEFINE HAS_GENERICS_TObjectList}
{$DEFINE HAS_GENERICS_TThreadList}
// TArray<T>.Copy() was introduced in XE7 but was buggy. It was fixed in XE8:
//
// RSP-9763 TArray.Copy<T> copies from destination to source for unmanaged types
// https://quality.embarcadero.com/browse/RSP-9763
//
{$IFDEF VCL_XE8_OR_ABOVE}
{$DEFINE HAS_GENERICS_TArray_Copy}
{$ENDIF}
{$ENDIF}
{$ENDIF}
{$IFDEF NO_ANSI_TYPES}
{$UNDEF HAS_AnsiString}
{$UNDEF HAS_AnsiChar}
{$UNDEF HAS_PAnsiChar}
{$UNDEF HAS_PPAnsiChar}
{$UNDEF HAS_UNIT_AnsiStrings}
{$UNDEF HAS_AnsiStrings_StrPLCopy}
{$ENDIF}
{$IFDEF WIN32}
{$DEFINE WIN32_OR_WIN64}
{$ENDIF}
{$IFDEF WIN64}
{$DEFINE WIN32_OR_WIN64}
{$ENDIF}
{$IFDEF WIN32_OR_WIN64}
{$DEFINE USE_OPENSSL}
{$DEFINE USE_ZLIB_UNIT}
{$IFNDEF DCC_NEXTGEN}
{$DEFINE USE_SSPI}
{$IFDEF STRING_IS_UNICODE}
{$DEFINE SSPI_UNICODE}
{$ENDIF}
{$ENDIF}
{$ENDIF}
// High-performance counters are not reliable on multi-core systems, and have
// been known to cause problems with TIdIOHandler.ReadLn() timeouts in Windows
// XP SP3, both 32-bit and 64-bit. Refer to these discussions for more info:
//
// http://www.virtualdub.org/blog/pivot/entry.php?id=106
// http://blogs.msdn.com/oldnewthing/archive/2008/09/08/8931563.aspx
//
// Do not enable thus unless you know it will work correctly on your systems!
{$IFDEF WINDOWS}
{.$DEFINE USE_HI_PERF_COUNTER_FOR_TICKS}
{$ENDIF}
{$IFDEF UNIX}
{$DEFINE USE_OPENSSL}
{$DEFINE USE_ZLIB_UNIT}
{$ENDIF}
{$IFDEF MACOS}
{$DEFINE HAS_getifaddrs}
{$ENDIF}
{$IFDEF IOS}
{$DEFINE HAS_getifaddrs}
{$DEFINE USE_OPENSSL}
{$IFDEF CPUARM}
// RLebeau: For iOS devices, OpenSSL cannot be used as an external library,
// it must be statically linked into the app. For the iOS simulator, this
// is not true. Users who want to use OpenSSL in iOS device apps will need
// to add the static OpenSSL library to the project and then include the
// IdSSLOpenSSLHeaders_static unit in their uses clause. It hooks up the
// statically linked functions for the IdSSLOpenSSLHeaders unit to use...
{$DEFINE STATICLOAD_OPENSSL}
{$ENDIF}
{$ENDIF}
{$IFDEF FPC_REQUIRES_PROPER_ALIGNMENT}
{$DEFINE REQUIRES_PROPER_ALIGNMENT}
{$ENDIF}
//
//iconv defines section.
{$DEFINE USE_ICONV_UNIT}
{$DEFINE USE_ICONV_ENC}
{$IFDEF UNIX}
{$DEFINE USE_ICONV}
{$IFDEF USE_BASEUNIX}
{$IFDEF FPC}
{$UNDEF USE_ICONV_UNIT}
{$ELSE}
{$UNDEF USE_ICONV_ENC}
{$ENDIF}
{$ENDIF}
{$IFDEF KYLIXCOMPAT}
//important!! Iconv functions are defined in the libc.pas Kylix compatible unit.
{$UNDEF USE_ICONV_ENC}
{$UNDEF USE_ICONV_UNIT}
{$ENDIF}
{$ENDIF}
{$IFDEF NETWARELIBC}
{$DEFINE USE_ICONV}
//important!!! iconv functions are defined in the libc.pas Novell Netware header.
//Do not define USE_ICONV_UNIT
{$UNDEF USE_ICONV_UNIT}
{$UNDEF USE_ICONV_ENC}
{$ENDIF}
{$UNDEF USE_SAFELOADLIBRARY}
{$IFDEF WINDOWS}
{$UNDEF USE_ICONV_ENC}
{$DEFINE USE_SAFELOADLIBRARY}
{$ENDIF}
{$UNDEF USE_INVALIDATE_MOD_CACHE}
{$UNDEF USE_SAFELOADLIBRARY}
//This must come after the iconv defines because this compiler targets a Unix-like
//operating system. One key difference is that it does have a TEncoding class.
//If this comes before the ICONV defines, it creates problems.
//This also must go before the THandle size calculations.
{$IFDEF VCL_CROSS_COMPILE}
{$IFDEF POSIX}
{$DEFINE BSD}
{$DEFINE USE_SAFELOADLIBRARY}
{$DEFINE USE_INVALIDATE_MOD_CACHE}
{$ENDIF}
//important!!! iconv functions are defined in the libc.pas Novell Netware header.
//Do not define USE_ICONVUNIT
{$UNDEF USE_ICONV}
{$UNDEF USE_ICONV_UNIT}
{$UNDEF USE_ICONV_ENC}
{$DEFINE INT_THREAD_PRIORITY}
{$ENDIF}
{$IFNDEF USE_ICONV}
{$UNDEF USE_ICONV_UNIT}
{$UNDEF USE_ICONV_ENC}
{$ENDIF}
//IMPORTANT!!!!
//
//Do not remove this!!! This is to work around a conflict. In DCC, MACOS
//will mean OS X. In FreePascal, the DEFINE MACOS means MacIntosh System OS Classic.
{$IFDEF DCC}
// DCC defines MACOS for both iOS and OS X platforms, need to differentiate
{$IFDEF MACOS}
{$IFNDEF IOS}
{$DEFINE DARWIN}
{$ENDIF}
{$ENDIF}
{$ENDIF}
{$IFDEF FPC}
{$IFDEF MACOS}
{$DEFINE MACOS_CLASSIC}
{$ENDIF}
{$ENDIF}
{
BSD 4.4 introduced a minor API change. sa_family was changed from a 16bit
word to an 8 bit byte and an 8 bit byte field named sa_len was added.
}
//Place this only after DARWIN has been defined for Delphi MACOS
{$IFDEF FREEBSD}
{$DEFINE SOCK_HAS_SINLEN}
{$ENDIF}
{$IFDEF DARWIN}
{$DEFINE SOCK_HAS_SINLEN}
{$ENDIF}
{$IFDEF HAIKU}
{$DEFINE SOCK_HAS_SINLEN}
{$ENDIF}
{$IFDEF MORPHOS}
{$DEFINE SOCK_HAS_SINLEN}
{$ENDIF}
// Do NOT remove these IFDEF's. They are here because InterlockedExchange
// only handles 32bit values. Some Operating Systems may have 64bit
// THandles. This is not always tied to the platform architecture.
{$IFDEF AMIGA}
{$DEFINE THANDLE_CPUBITS}
{$ENDIF}
{$IFDEF ATARI}
{$DEFINE THANDLE_32}
{$ENDIF}
{$IFDEF BEOS}
{$DEFINE THANDLE_32}
{$ENDIF}
{$IFDEF BSD}
//I think BSD might handle FreeBSD, NetBSD, OpenBSD, and Darwin
{$IFDEF IOS}
{$IFDEF CPUARM32}
{$DEFINE CPU32}
{$DEFINE THANDLE_32}
{$ELSE}
{$IFDEF CPUARM64}
{$DEFINE CPU64}
{$DEFINE THANDLE_64}
{$ELSE}
{$DEFINE THANDLE_32}
{$ENDIF}
{$ENDIF}
{$ELSE}
{$DEFINE THANDLE_32}
{$ENDIF}
{$ENDIF}
{$IFDEF EMBEDDED}
{$DEFINE THANDLE_CPUBITS}
{$ENDIF}
{$IFDEF EMX}
{$DEFINE THANDLE_32}
{$ENDIF}
{$IFDEF GBA}
{$DEFINE THANDLE_32}
{$ENDIF}
{$IFDEF GO32}
{$DEFINE THANDLE_32}
{$ENDIF}
{$IFDEF HAIKU}
{$DEFINE THANDLE_32}
{$ENDIF}
{$IFDEF LINUX}
{$DEFINE THANDLE_32}
{$ENDIF}
{$IFDEF MACOS_CLASSIC}
{$DEFINE THANDLE_CPUBITS}
{$ENDIF}
{$IFDEF MORPHOS}
{$DEFINE THANDLE_CPUBITS}
{$ENDIF}
{$IFDEF NATIVENT} //Native NT for kernel level drivers
{$DEFINE THANDLE_CPUBITS}
{$ENDIF}
{$IFDEF NDS}
{$DEFINE THANDLE_32}
{$ENDIF}
{$IFDEF NETWARE}
{$DEFINE THANDLE_32}
{$ENDIF}
{$IFDEF NETWARELIBC}
{$DEFINE THANDLE_32}
{$ENDIF}
{$IFDEF OS2}
{$DEFINE THANDLE_32}
{$ENDIF}
{$IFDEF PALMOS}
{$DEFINE THANDLE_32}
{$ENDIF}
{$IFDEF SOLARIS}
{$DEFINE THANDLE_32}
{$ENDIF}
{$IFDEF SYMBIAN}
{$DEFINE THANDLE_32}
{$ENDIF}
{$IFDEF WII}
{$DEFINE THANDLE_32}
{$ENDIF}
{$IFDEF WATCOM}
{$DEFINE THANDLE_32}
{$ENDIF}
{$IFDEF WINDOWS}
{$DEFINE THANDLE_CPUBITS}
{$ENDIF}
// end platform specific stuff for THandle size
{$IFDEF THANDLE_CPUBITS}
{$IFDEF CPU64}
{$DEFINE THANDLE_64}
{$ELSE}
{$DEFINE THANDLE_32}
{$ENDIF}
{$ENDIF}
{$IFDEF DOTNET}
{$DEFINE DOTNET_OR_ICONV}
{$ENDIF}
{$IFDEF USE_ICONV}
{$DEFINE DOTNET_OR_ICONV}
{$ENDIF}
{$UNDEF STREAM_SIZE_64}
{$IFDEF FPC}
{$DEFINE STREAM_SIZE_64}
{$ELSE}
{$IFDEF VCL_6_OR_ABOVE}
{$DEFINE STREAM_SIZE_64}
{$ENDIF}
{$ENDIF}
{$IFNDEF FREE_ON_FINAL}
{$IFNDEF REGISTER_EXPECTED_MEMORY_LEAK}
{$IFDEF USE_FASTMM4}
{$DEFINE REGISTER_EXPECTED_MEMORY_LEAK}
{$ENDIF}
{$IFDEF USE_MADEXCEPT}
{$DEFINE REGISTER_EXPECTED_MEMORY_LEAK}
{$ENDIF}
{$ENDIF}
{$ENDIF}
{$IFDEF REGISTER_EXPECTED_MEMORY_LEAK}
{$IFDEF DOTNET}
{$UNDEF REGISTER_EXPECTED_MEMORY_LEAK}
{$ENDIF}
{$IFDEF VCL_CROSS_COMPILE}
// RLebeau: should this be enabled for Windows, at least?
{$UNDEF REGISTER_EXPECTED_MEMORY_LEAK}
{$ENDIF}
{$ENDIF}
{
We must determine what the SocketType parameter is for the Socket function.
In DotNET, it's SocketType. In Kylix and the libc.pas Kylix-compatibility
library, it's a __socket_type. In BaseUnix, it's a C-type Integer. In Windows,
it's a LongInt.
}
{$UNDEF SOCKETTYPE_IS_SOCKETTYPE}
{$UNDEF SOCKETTYPE_IS_CINT}
{$UNDEF SOCKETTYPE_IS___SOCKETTYPE}
{$UNDEF SOCKETTYPE_IS_LONGINT}
{$UNDEF SOCKETTYPE_IS_NUMERIC}
{$UNDEF SOCKET_LEN_IS_socklen_t}
{$IFDEF DOTNET}
{$DEFINE SOCKETTYPE_IS_SOCKETTYPE}
{$ENDIF}
{$IFDEF USE_BASEUNIX}
{$DEFINE SOCKETTYPE_IS_CINT}
{$DEFINE SOCKETTYPE_IS_NUMERIC}
{$ENDIF}
{$IFDEF KYLIXCOMPAT}
{$DEFINE SOCKETTYPE_IS___SOCKETTYPE}
{$ENDIF}
{$IFDEF USE_VCL_POSIX}
{$DEFINE SOCKETTYPE_IS_NUMERIC}
{$DEFINE SOCKETTYPE_IS_LONGINT}
{$DEFINE SOCKET_LEN_IS_socklen_t}
{$ENDIF}
{$IFDEF WINDOWS}
{$DEFINE SOCKETTYPE_IS_LONGINT}
{$DEFINE SOCKETTYPE_IS_NUMERIC}
{$ENDIF}
{$IFDEF OS2}
{$DEFINE SOCKETTYPE_IS_LONGINT}
{$DEFINE SOCKETTYPE_IS_NUMERIC}
{$ENDIF}
{$IFDEF NETWARE}
{$DEFINE SOCKETTYPE_IS_LONGINT}
{$DEFINE SOCKETTYPE_IS_NUMERIC}
{$ENDIF}
{Take advantage of some TCP features specific to some stacks.
They work somewhat similarly but there's a key difference.
In Linux, TCP_CORK is turned on to send fixed packet sizes and
when turned-off (uncorked), any remaining data is sent. With
TCP_NOPUSH, this might not happen and remaining data is only sent
before disconnect. TCP_KEEPIDLE and TCP_KEEPINTVL so the IFDEF LINUX and IFDEF
SOLARIS instead of IFDEF UNIX is not an error, it's deliberate.}
{$UNDEF HAS_TCP_NOPUSH}
{$UNDEF HAS_TCP_CORK}
{$UNDEF HAS_TCP_KEEPIDLE}
{$UNDEF HAS_TCP_KEEPINTVL}
{$UNDEF HAS_SOCKET_NOSIGPIPE}
{$IFDEF BSD}
{$DEFINE HAS_TCP_NOPUSH}
{$ENDIF}
{$IFDEF HAIKU}
{$DEFINE HAS_TCP_NOPUSH}
{$ENDIF}
{$IFDEF LINUX}
{$DEFINE HAS_TCP_CORK}
{$DEFINE HAS_TCP_KEEPIDLE}
{$DEFINE HAS_TCP_KEEPINTVL}
{$ENDIF}
{$IFDEF SOLARIS}
{$DEFINE HAS_TCP_CORK}
{$ENDIF}
{$IFDEF NETBSD}
{$DEFINE HAS_TCP_CORK}
{$DEFINE HAS_TCP_KEEPIDLE}
{$DEFINE HAS_TCP_KEEPINTVL}
{$ENDIF}
{$IFDEF USE_VCL_POSIX}
{$IFNDEF ANDROID}
{$DEFINE HAS_SOCKET_NOSIGPIPE}
{$ENDIF}
{$ENDIF}
{end Unix OS specific stuff}
{$IFDEF DEBUG}
{$UNDEF USE_INLINE}
{$ENDIF}
// RLebeau 5/24/2015: In C++Builder 2006 and 2007, UInt64 is emitted as
// signed __int64 in HPP files instead of as unsigned __int64. This causes
// conflicts in overloaded routines that have (U)Int64 parameters. This
// was fixed in C++Builder 2009. For compilers that do not have a native
// UInt64 type, or for C++Builder 2006/2007, let's define a record type
// that can hold UInt64 values...
{$IFDEF HAS_UInt64}
{$IFDEF BROKEN_UINT64_HPPEMIT}
{$DEFINE TIdUInt64_IS_NOT_NATIVE}
{$ENDIF}
{$ELSE}
{$IFNDEF HAS_QWord}
{$DEFINE TIdUInt64_IS_NOT_NATIVE}
{$ENDIF}
{$ENDIF}
// RLebeau 9/5/2013: it would take a lot of work to re-write Indy to support
// both 0-based and 1-based string indexing, so we'll just turn off 0-based
// indexing for now...
{$IFDEF HAS_DIRECTIVE_ZEROBASEDSTRINGS}
{$ZEROBASEDSTRINGS OFF}
{$ENDIF}