diff --git a/Package/pascalast.lpk b/Package/pascalast.lpk new file mode 100644 index 00000000..38f65c90 --- /dev/null +++ b/Package/pascalast.lpk @@ -0,0 +1,95 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Package/pascalast.pas b/Package/pascalast.pas new file mode 100644 index 00000000..02a03429 --- /dev/null +++ b/Package/pascalast.pas @@ -0,0 +1,25 @@ +{ This file was automatically created by Lazarus. Do not edit! + This source is only used to compile and install the package. + } + +unit PascalAST; + +{$warn 5023 off : no warning about unused units} +interface + +uses + DelphiAST.Writer, StringPool, DelphiAST.Consts, DelphiAST, + DelphiAST.ProjectIndexer, DelphiAST.Serialize.Binary, + DelphiAST.SimpleParserEx, Diagnostics, IOUtils, SimpleParser.Types, + SimpleParser.Lexer, SimpleParser.Lexer.Types, SimpleParser, + SimplerParser.Lexer.Config, LazarusPackageIntf; + +implementation + +procedure Register; +begin +end; + +initialization + RegisterPackage('PascalAST', @Register); +end. diff --git a/Source/DelphiAST.ProjectIndexer.pas b/Source/DelphiAST.ProjectIndexer.pas index 4370f546..e3a76e93 100644 --- a/Source/DelphiAST.ProjectIndexer.pas +++ b/Source/DelphiAST.ProjectIndexer.pas @@ -42,6 +42,11 @@ TUnitInfo = record end; end; + TUnitComparer = class (TComparer) + public + function Compare(constref ALeft, ARight: TUnitInfo): Integer; override; + end; + TParsedUnits = class(TList) protected procedure Initialize(parsedUnits: TParsedUnitsCache; unitPaths: TUnitPathsCache); @@ -52,6 +57,11 @@ TIncludeFileInfo = record Path: string; end; + TIncludeFileComparer = class (TComparer) + public + function Compare(constref ALeft, ARight: TIncludeFileInfo): Integer; override; + end; + TIncludeFiles = class(TList) protected procedure Initialize(includeCache: TIncludeCache); @@ -72,9 +82,9 @@ TProblems = class(TList) strict private type TIncludeHandler = class(TInterfacedObject, IIncludeHandler) strict private - [weak] FIncludeCache: TIncludeCache; - [weak] FIndexer : TProjectIndexer; - [weak] FProblems : TProblems; + FIncludeCache: TIncludeCache; + FIndexer : TProjectIndexer; + FProblems : TProblems; FUnitFile : string; FUnitFileFolder : string; public @@ -141,6 +151,30 @@ implementation SysUtils, SimpleParser; +function IsRelativePath(s : String) : boolean; +begin + {$IFDEF WINDOWS} + result := not (s.contains(':')); + {$ELSE} + result := not s.startsWith('\'); + {$ENDIF} +end; + +{ TProjectIndexer.TUnitComparer } + +function TProjectIndexer.TUnitComparer.Compare(constref ALeft, ARight: TUnitInfo): Integer; +begin + Result := TOrdinalIStringComparer(TIStringComparer.Ordinal).Compare(ALeft.Name, ARight.Name); +end; + +{ TProjectIndexer.TIncludeFileComparer } + +function TProjectIndexer.TIncludeFileComparer.Compare(constref ALeft, ARight: TIncludeFileInfo): Integer; +begin + Result := TOrdinalIStringComparer(TIStringComparer.Ordinal).Compare(ALeft.Name, ARight.Name); +end; + + { TProjectIndexer.TParsedUnits } procedure TProjectIndexer.TParsedUnits.Initialize(parsedUnits: TParsedUnitsCache; @@ -168,12 +202,7 @@ procedure TProjectIndexer.TParsedUnits.Initialize(parsedUnits: TParsedUnitsCache end; TrimExcess; - Sort( - TComparer.Construct( - function(const Left, Right: TUnitInfo): integer - begin - Result := TOrdinalIStringComparer(TIStringComparer.Ordinal).Compare(Left.Name, Right.Name); - end)); + Sort(TUnitComparer.create); end; { TProjectIndexer.TIncludeFiles } @@ -198,12 +227,7 @@ procedure TProjectIndexer.TIncludeFiles.Initialize(includeCache: TIncludeCache); end; TrimExcess; - Sort( - TComparer.Construct( - function(const Left, Right: TIncludeFileInfo): integer - begin - Result := TOrdinalIStringComparer(TIStringComparer.Ordinal).Compare(Left.Name, Right.Name); - end)); + Sort(TIncludeFileComparer.create); end; { TProjectIndexer.TProblems } diff --git a/Source/DelphiAST.Serialize.Binary.pas b/Source/DelphiAST.Serialize.Binary.pas index 04ac2834..6ecb477e 100644 --- a/Source/DelphiAST.Serialize.Binary.pas +++ b/Source/DelphiAST.Serialize.Binary.pas @@ -38,6 +38,13 @@ implementation uses SysUtils; +{$IFDEF FPC} +function UTF8ToUnicodeString(s : String) : String; +begin + result := s; +end; +{$ENDIF} + var CSignature: AnsiString = 'DAST binary file'#26; diff --git a/Source/FreePascalSupport/Diagnostics.pas b/Source/FreePascalSupport/Diagnostics.pas index a5356b67..27784a0b 100644 --- a/Source/FreePascalSupport/Diagnostics.pas +++ b/Source/FreePascalSupport/Diagnostics.pas @@ -17,6 +17,9 @@ interface {$IFDEF LINUX} ,unixtype, linux {$ENDIF LINUX} + {$IFDEF DARWIN} + , unixtype + {$ENDIF} ; type @@ -43,7 +46,10 @@ TStopWatch = record Int64; {$ENDIF WINDOWS} {$IFDEF LINUX} - TTimeSpec; + TTimeSpec; + {$ENDIF LINUX} + {$IFDEF DARWIN} + TTimeSpec; {$ENDIF LINUX} strict private class var FFrequency : Int64; diff --git a/Source/SimpleParser/SimpleParser.Lexer.Types.pas b/Source/SimpleParser/SimpleParser.Lexer.Types.pas index 97843bd2..d5278ee2 100644 --- a/Source/SimpleParser/SimpleParser.Lexer.Types.pas +++ b/Source/SimpleParser/SimpleParser.Lexer.Types.pas @@ -118,6 +118,7 @@ interface ptExit, ptExport, ptExports, + ptExtdecl, ptExtended, ptExternal, ptFar, diff --git a/Source/SimpleParser/SimpleParser.Lexer.pas b/Source/SimpleParser/SimpleParser.Lexer.pas index 444246b8..f7f3ea12 100644 --- a/Source/SimpleParser/SimpleParser.Lexer.pas +++ b/Source/SimpleParser/SimpleParser.Lexer.pas @@ -58,6 +58,7 @@ interface {$IFDEF FPC} Generics.Collections, {$ENDIF} + SimplerParser.Lexer.Config, SimpleParser.Lexer.Types; {$IFDEF FPC} @@ -931,7 +932,8 @@ function TmwBasePasLex.Func72: TptTokenKind; function TmwBasePasLex.Func73: TptTokenKind; begin Result := ptIdentifier; - if KeyComp('Except') then Result := ptExcept; + if KeyComp('Except') then Result := ptExcept else + if KeyComp('Extdecl') then FExID := ptExtdecl; end; function TmwBasePasLex.Func75: TptTokenKind; @@ -2609,175 +2611,11 @@ procedure TmwBasePasLex.InitFrom(ALexer: TmwBasePasLex); end; procedure TmwBasePasLex.InitDefinesDefinedByCompiler; +var + s : String; begin - //Set up the defines that are defined by the compiler - {$IFDEF VER90} - AddDefine('VER90'); // 2 - {$ENDIF} - {$IFDEF VER100} - AddDefine('VER100'); // 3 - {$ENDIF} - {$IFDEF VER120} - AddDefine('VER120'); // 4 - {$ENDIF} - {$IFDEF VER130} - AddDefine('VER130'); // 5 - {$ENDIF} - {$IFDEF VER140} // 6 - AddDefine('VER140'); - {$ENDIF} - {$IFDEF VER150} // 7/7.1 - AddDefine('VER150'); - {$ENDIF} - {$IFDEF VER160} // 8 - AddDefine('VER160'); - {$ENDIF} - {$IFDEF VER170} // 2005 - AddDefine('VER170'); - {$ENDIF} - {$IFDEF VER180} // 2007 - AddDefine('VER180'); - {$ENDIF} - {$IFDEF VER185} // 2007 - AddDefine('VER185'); - {$ENDIF} - {$IFDEF VER190} // 2007.NET - AddDefine('VER190'); - {$ENDIF} - {$IFDEF CONDITIONALEXPRESSIONS} - {$IF COMPILERVERSION > 19.0} - AddDefine('VER' + IntToStr(Round(10*CompilerVersion))); - {$IFEND} - {$ENDIF} - {$IFDEF WIN32} - AddDefine('WIN32'); - {$ENDIF} - {$IFDEF WIN64} - AddDefine('WIN64'); - {$ENDIF} - {$IFDEF LINUX} - AddDefine('LINUX'); - {$ENDIF} - {$IFDEF LINUX32} - AddDefine('LINUX32'); - {$ENDIF} - {$IFDEF LINUX64} - AddDefine('LINUX64'); - {$ENDIF} - {$IFDEF POSIX} - AddDefine('POSIX'); - {$ENDIF} - {$IFDEF POSIX32} - AddDefine('POSIX32'); - {$ENDIF} - {$IFDEF POSIX64} - AddDefine('POSIX64'); - {$ENDIF} - {$IFDEF CPUARM} - AddDefine('CPUARM'); - {$ENDIF} - {$IFDEF CPUARM32} - AddDefine('CPUARM32'); - {$ENDIF} - {$IFDEF CPUARM64} - AddDefine('CPUARM64'); - {$ENDIF} - {$IFDEF CPU386} - AddDefine('CPU386'); - {$ENDIF} - {$IFDEF CPUX86} - AddDefine('CPUX86'); - {$ENDIF} - {$IFDEF CPUX64} - AddDefine('CPUX64'); - {$ENDIF} - {$IFDEF CPU32BITS} - AddDefine('CPU32BITS'); - {$ENDIF} - {$IFDEF CPU64BITS} - AddDefine('CPU64BITS'); - {$ENDIF} - {$IFDEF MSWINDOWS} - AddDefine('MSWINDOWS'); - {$ENDIF} - {$IFDEF MACOS} - AddDefine('MACOS'); - {$ENDIF} - {$IFDEF MACOS32} - AddDefine('MACOS32'); - {$ENDIF} - {$IFDEF MACOS64} - AddDefine('MACOS64'); - {$ENDIF} - {$IFDEF IOS} - AddDefine('IOS'); - {$ENDIF} - {$IFDEF IOS32} - AddDefine('IOS32'); - {$ENDIF} - {$IFDEF IOS64} - AddDefine('IOS64'); - {$ENDIF} - {$IFDEF ANDROID} - AddDefine('ANDROID'); - {$ENDIF} - {$IFDEF ANDROID32} - AddDefine('ANDROID32'); - {$ENDIF} - {$IFDEF ANDROID64} - AddDefine('ANDROID64'); - {$ENDIF} - {$IFDEF CONSOLE} - AddDefine('CONSOLE'); - {$ENDIF} - {$IFDEF NATIVECODE} - AddDefine('NATIVECODE'); - {$ENDIF} - {$IFDEF CONDITIONALEXPRESSIONS} - AddDefine('CONDITIONALEXPRESSIONS'); - {$ENDIF} - {$IFDEF UNICODE} - AddDefine('UNICODE'); - {$ENDIF} - {$IFDEF ALIGN_STACK} - AddDefine('ALIGN_STACK'); - {$ENDIF} - {$IFDEF ARM_NO_VFP_USE} - AddDefine('ARM_NO_VFP_USE'); - {$ENDIF} - {$IFDEF ASSEMBLER} - AddDefine('ASSEMBLER'); - {$ENDIF} - {$IFDEF AUTOREFCOUNT} - AddDefine('AUTOREFCOUNT'); - {$ENDIF} - {$IFDEF EXTERNALLINKER} - AddDefine('EXTERNALLINKER'); - {$ENDIF} - {$IFDEF ELF} - AddDefine('ELF'); - {$ENDIF} - {$IFDEF NEXTGEN} - AddDefine('NEXTGEN'); - {$ENDIF} - {$IFDEF PC_MAPPED_EXCEPTIONS} - AddDefine('PC_MAPPED_EXCEPTIONS'); - {$ENDIF} - {$IFDEF PIC} - AddDefine('PIC'); - {$ENDIF} - {$IFDEF UNDERSCOREIMPORTNAME} - AddDefine('UNDERSCOREIMPORTNAME'); - {$ENDIF} - {$IFDEF WEAKREF} - AddDefine('WEAKREF'); - {$ENDIF} - {$IFDEF WEAKINSTREF} - AddDefine('WEAKINSTREF'); - {$ENDIF} - {$IFDEF WEAKINTFREF} - AddDefine('WEAKINTFREF'); - {$ENDIF} + for s in DelphiParserConfig.GetDefines do + AddDefine(s); end; function TmwBasePasLex.GetStringContent: string; diff --git a/Source/SimpleParser/SimpleParser.pas b/Source/SimpleParser/SimpleParser.pas index a54e175d..9662b08d 100644 --- a/Source/SimpleParser/SimpleParser.pas +++ b/Source/SimpleParser/SimpleParser.pas @@ -162,6 +162,7 @@ interface ClassMethodDirectiveEnum = [ ptAbstract, ptCdecl, + ptExtdecl, ptDynamic, ptMessage, ptOverride, @@ -660,6 +661,15 @@ procedure TmwSimplePasPar.ObjectPropertySpecifiers; Semicolon; end; +{$IFDEF FPC} +function RemoveBOM( s : String) : String; +begin +// writeln(copy(s, 1, 3)+' / '+inttostr()+'.'+inttostr(ord(s[2]))+'.'+inttostr(ord(s[3]))+' / '+inttostr(b[0])+'.'+inttostr(b[1])+'.'+inttostr(b[2])); + if (ord(s[1]) = 239) and (ord(s[2]) = 187) and (ord(s[3]) = 191) then + delete(s, 1, 3); + result := s; +end; +{$ELSE} type TStringStreamHelper = class helper for TStringStream function GetDataString: string; @@ -695,6 +705,7 @@ function TStringStreamHelper.GetDataString: string; Result := Encoding.GetString(Bytes, Length(Encoding.GetPreamble), Size); {$ENDIF} end; +{$ENDIF} procedure TmwSimplePasPar.Run(const UnitName: string; SourceStream: TStream); var @@ -723,7 +734,11 @@ procedure TmwSimplePasPar.Run(const UnitName: string; SourceStream: TStream); end else StringStream := TStringStream(SourceStream); + {$IFDEF FPC} + FLexer.Origin := removeBom(StringStream.DataString); + {$ELSE} FLexer.Origin := StringStream.GetDataString; + {$ENDIF} ParseFile; if OwnStream then StringStream.Free; @@ -1835,7 +1850,7 @@ procedure TmwSimplePasPar.ObjectDestructorHeading; procedure TmwSimplePasPar.ObjectMethodDirective; begin - while ExID in [ptAbstract, ptCdecl, ptDynamic, ptExport, ptExternal, ptFar, + while ExID in [ptAbstract, ptCdecl, ptDynamic, ptExport, ptExtdecl, ptExternal, ptFar, ptMessage, ptNear, ptOverload, ptPascal, ptRegister, ptSafeCall, ptStdCall, ptVirtual, ptDeprecated, ptLibrary, ptPlatform, ptStatic, ptInline] do begin @@ -2125,7 +2140,7 @@ procedure TmwSimplePasPar.FunctionProcedureBlock; HasBlock := True; if TokenID = ptSemiColon then Semicolon; - while ExID in [ptAbstract, ptCdecl, ptDynamic, ptExport, ptExternal, ptDelayed, ptFar, + while ExID in [ptAbstract, ptCdecl, ptDynamic, ptExport, ptExtdecl, ptExternal, ptDelayed, ptFar, ptMessage, ptNear, ptOverload, ptOverride, ptPascal, ptRegister, ptReintroduce, ptSafeCall, ptStdCall, ptVirtual, ptLibrary, ptPlatform, ptLocal, ptVarargs, ptAssembler, ptStatic, ptInline, ptForward, @@ -3170,6 +3185,10 @@ procedure TmwSimplePasPar.DirectiveCalling; begin NextToken; end; + ptExtdecl: + begin + NextToken; + end; ptPascal: begin NextToken; @@ -4162,7 +4181,7 @@ procedure TmwSimplePasPar.ProceduralType; else TheTokenID := ExID; end; - while TheTokenID in [ptAbstract, ptCdecl, ptDynamic, ptExport, ptExternal, ptFar, + while TheTokenID in [ptAbstract, ptCdecl, ptDynamic, ptExport, ptExtdecl, ptExternal, ptFar, ptMessage, ptNear, ptOverload, ptOverride, ptPascal, ptRegister, ptReintroduce, ptSafeCall, ptStdCall, ptVirtual, ptStatic, ptInline, ptVarargs] do // DR 2001-11-14 no checking for deprecated etc. since it's captured by the typedecl @@ -4802,7 +4821,7 @@ procedure TmwSimplePasPar.ProceduralDirective; begin DirectiveBinding; end; - ptCdecl, ptPascal, ptRegister, ptSafeCall, ptStdCall: + ptCdecl, ptExtdecl, ptPascal, ptRegister, ptSafeCall, ptStdCall: begin DirectiveCalling; end; @@ -4868,7 +4887,7 @@ procedure TmwSimplePasPar.ExportedHeading; if TokenID = ptSemiColon then Semicolon; //TODO: Add FINAL - while ExID in [ptAbstract, ptCdecl, ptDynamic, ptExport, ptExternal, ptFar, + while ExID in [ptAbstract, ptCdecl, ptDynamic, ptExport, ptExtdecl, ptExternal, ptFar, ptMessage, ptNear, ptOverload, ptOverride, ptPascal, ptRegister, ptReintroduce, ptSafeCall, ptStdCall, ptVirtual, ptDeprecated, ptLibrary, ptPlatform, ptLocal, ptVarargs, diff --git a/Source/SimpleParser/SimplerParser.Lexer.Config.pas b/Source/SimpleParser/SimplerParser.Lexer.Config.pas new file mode 100644 index 00000000..05e0ab1a --- /dev/null +++ b/Source/SimpleParser/SimplerParser.Lexer.Config.pas @@ -0,0 +1,544 @@ +unit SimplerParser.Lexer.Config; + +{$mode delphi} + +interface + +uses + Classes, SysUtils, Types; + +type + TDelphiParserOS = (osWindows, osLinux, osMac, osIOS, osAndroid); + TDelphiParserCPUType = (ct32, ct64, ctARM32, ctARM64); + + { TDelphiParserConfig } + + TDelphiParserConfig = class (TObject) + private + FCompilerVersion: string; + FCPU32: boolean; + FCPU64: boolean; + FFreePascal: boolean; + + FWIN32 : boolean; + FWIN64 : boolean; + FLINUX : boolean; + FLINUX32 : boolean; + FLINUX64 : boolean; + FPOSIX : boolean; + FPOSIX32 : boolean; + FPOSIX64 : boolean; + FCPUARM : boolean; + FCPUARM32 : boolean; + FCPUARM64 : boolean; + FCPU386 : boolean; + FCPUX86 : boolean; + FCPUX64 : boolean; + FMSWINDOWS : boolean; + FMACOS : boolean; + FMACOS32 : boolean; + FMACOS64 : boolean; + FIOS : boolean; + FIOS32 : boolean; + FIOS64 : boolean; + FANDROID : boolean; + FANDROID32 : boolean; + FANDROID64 : boolean; + FCONSOLE : boolean; + FNATIVECODE : boolean; + FCONDITIONALEXPRESSIONS : boolean; + FUNICODE : boolean; + FALIGN_STACK : boolean; + FARM_NO_VFP_USE : boolean; + FASSEMBLER : boolean; + FAUTOREFCOUNT : boolean; + FEXTERNALLINKER : boolean; + FELF : boolean; + FNEXTGEN : boolean; + FPC_MAPPED_EXCEPTIONS : boolean; + FPIC : boolean; + FUNDERSCOREIMPORTNAME : boolean; + FWEAKREF : boolean; + FWEAKINSTREF : boolean; + FWEAKINTFREF : boolean; + + FCustomDefines : TStringList; + public + constructor Create; + destructor Destroy; override; + + procedure LoadDefaults; // Set up the defines that are defined by the compiler based as compiling this code + function GetDefines : TStringDynArray; + + procedure Configure(os : TDelphiParserOS; cpu : TDelphiParserCPUType); + procedure ConfigureWin32; + procedure ConfigureWin64; + procedure ConfigureLinux64; + procedure ConfigureMac64; + procedure ConfigureMacM1; + procedure ConfigureIOS; + procedure ConfigureAndroid; + + + property FreePascal : boolean read FFreePascal write FFreePascal; + property CompilerVersion : string read FCompilerVersion write FCompilerVersion; + + property WIN32 : boolean read FWIN32 write FWIN32; + property WIN64 : boolean read FWIN64 write FWIN64; + property LINUX : boolean read FLINUX write FLINUX; + property LINUX32 : boolean read FLINUX32 write FLINUX32; + property LINUX64 : boolean read FLINUX64 write FLINUX64; + property POSIX : boolean read FPOSIX write FPOSIX; + property POSIX32 : boolean read FPOSIX32 write FPOSIX32; + property POSIX64 : boolean read FPOSIX64 write FPOSIX64; + property CPUARM : boolean read FCPUARM write FCPUARM; + property CPUARM32 : boolean read FCPUARM32 write FCPUARM32; + property CPUARM64 : boolean read FCPUARM64 write FCPUARM64; + property CPU386 : boolean read FCPU386 write FCPU386; + property CPUX86 : boolean read FCPUX86 write FCPUX86; + property CPUX64 : boolean read FCPUX64 write FCPUX64; + property CPU32 : boolean read FCPU32 write FCPU32; + property CPU64 : boolean read FCPU64 write FCPU64; + property MSWINDOWS : boolean read FMSWINDOWS write FMSWINDOWS; + property MACOS : boolean read FMACOS write FMACOS; + property MACOS32 : boolean read FMACOS32 write FMACOS32; + property MACOS64 : boolean read FMACOS64 write FMACOS64; + property IOS : boolean read FIOS write FIOS; + property IOS32 : boolean read FIOS32 write FIOS32; + property IOS64 : boolean read FIOS64 write FIOS64; + property ANDROID : boolean read FANDROID write FANDROID; + property ANDROID32 : boolean read FANDROID32 write FANDROID32; + property ANDROID64 : boolean read FANDROID64 write FANDROID64; + property CONSOLE : boolean read FCONSOLE write FCONSOLE; + property NATIVECODE : boolean read FNATIVECODE write FNATIVECODE; + property CONDITIONALEXPRESSIONS : boolean read FCONDITIONALEXPRESSIONS write FCONDITIONALEXPRESSIONS; + property UNICODE : boolean read FUNICODE write FUNICODE; + property ALIGN_STACK : boolean read FALIGN_STACK write FALIGN_STACK; + property ARM_NO_VFP_USE : boolean read FARM_NO_VFP_USE write FARM_NO_VFP_USE; + property ASSEMBLER : boolean read FASSEMBLER write FASSEMBLER; + property AUTOREFCOUNT : boolean read FAUTOREFCOUNT write FAUTOREFCOUNT; + property EXTERNALLINKER : boolean read FEXTERNALLINKER write FEXTERNALLINKER; + property ELF : boolean read FELF write FELF; + property NEXTGEN : boolean read FNEXTGEN write FNEXTGEN; + property PC_MAPPED_EXCEPTIONS : boolean read FPC_MAPPED_EXCEPTIONS write FPC_MAPPED_EXCEPTIONS; + property PIC : boolean read FPIC write FPIC; + property UNDERSCOREIMPORTNAME : boolean read FUNDERSCOREIMPORTNAME write FUNDERSCOREIMPORTNAME; + property WEAKREF : boolean read FWEAKREF write FWEAKREF; + property WEAKINSTREF : boolean read FWEAKINSTREF write FWEAKINSTREF; + property WEAKINTFREF : boolean read FWEAKINTFREF write FWEAKINTFREF; + + property CustomDefines : TStringList read FCustomDefines; + end; + +var + DelphiParserConfig : TDelphiParserConfig; + +implementation + +function TDelphiParserConfig.GetDefines : TStringDynArray; +var + ts : TStringList; +begin + ts := TStringList.create; + try + ts.add('CODE_PARSER'); + if FFreePascal then + ts.add('FPC'); + ts.add(CompilerVersion); + + if FWIN32 then ts.add('WIN32'); + if FWIN64 then ts.add('WIN64'); + if FLINUX then ts.add('LINUX'); + if FLINUX32 then ts.add('LINUX32'); + if FLINUX64 then ts.add('LINUX64'); + if FPOSIX then ts.add('POSIX'); + if FPOSIX32 then ts.add('POSIX32'); + if FPOSIX64 then ts.add('POSIX64'); + if FCPUARM then ts.add('CPUARM'); + if FCPUARM32 then ts.add('CPUARM32'); + if FCPUARM64 then ts.add('CPUARM64'); + if FCPU386 then ts.add('CPU386'); + if FCPUX86 then ts.add('CPUX86'); + if FCPUX64 then ts.add('CPUX64'); + if FCPU32 then ts.add('CPU32'); + if FCPU64 then ts.add('CPU64'); + if FCPU32 then ts.add('CPU32BITS'); + if FCPU64 then ts.add('CPU64BITS'); + if FMSWINDOWS then ts.add('MSWINDOWS'); + if FFreePascal then + begin + if FMACOS then ts.add('DARWIN'); + if FMACOS32 then ts.add('DARWIN32'); + if FMACOS64 then ts.add('DARWIN64'); + end + else + begin + if FMACOS then ts.add('MACOS'); + if FMACOS32 then ts.add('MACOS32'); + if FMACOS64 then ts.add('MACOS64'); + end; + if FIOS then ts.add('IOS'); + if FIOS32 then ts.add('IOS32'); + if FIOS64 then ts.add('IOS64'); + if FANDROID then ts.add('ANDROID'); + if FANDROID32 then ts.add('ANDROID32'); + if FANDROID64 then ts.add('ANDROID64'); + if FCONSOLE then ts.add('CONSOLE'); + if FNATIVECODE then ts.add('NATIVECODE'); + if FCONDITIONALEXPRESSIONS then ts.add('CONDITIONALEXPRESSIONS'); + if FUNICODE then ts.add('UNICODE'); + if FALIGN_STACK then ts.add('ALIGN_STACK'); + if FARM_NO_VFP_USE then ts.add('ARM_NO_VFP_USE'); + if FASSEMBLER then ts.add('ASSEMBLER'); + if FAUTOREFCOUNT then ts.add('AUTOREFCOUNT'); + if FEXTERNALLINKER then ts.add('EXTERNALLINKER'); + if FELF then ts.add('ELF'); + if FNEXTGEN then ts.add('NEXTGEN'); + if FPC_MAPPED_EXCEPTIONS then ts.add('PC_MAPPED_EXCEPTIONS'); + if FPIC then ts.add('PIC'); + if FUNDERSCOREIMPORTNAME then ts.add('UNDERSCOREIMPORTNAME'); + if FWEAKREF then ts.add('WEAKREF'); + if FWEAKINSTREF then ts.add('WEAKINSTREF'); + if FWEAKINTFREF then ts.add('WEAKINTFREF'); + + ts.AddStrings(FCustomDefines); + + result := ts.ToStringArray; + finally + ts.free; + end; +end; + +constructor TDelphiParserConfig.Create; +begin + inherited Create; + FCustomDefines := TStringList.create; + +end; + +destructor TDelphiParserConfig.Destroy; +begin + FCustomDefines.free; + inherited Destroy; +end; + +procedure TDelphiParserConfig.LoadDefaults; +begin + FCustomDefines.clear; + {$IFDEF FPC} + FFreePascal := true; + {$ELSE} + FFreePascal := false; + {$ENDIF} + {$IFDEF VER90} + CompilerVersion := 'VER90'; // 2 + {$ENDIF} + {$IFDEF VER100} + CompilerVersion := 'VER100'; // 3 + {$ENDIF} + {$IFDEF VER120} + CompilerVersion := 'VER120'; // 4 + {$ENDIF} + {$IFDEF VER130} + CompilerVersion := 'VER130'; // 5 + {$ENDIF} + {$IFDEF VER140} // 6 + CompilerVersion := 'VER140'; + {$ENDIF} + {$IFDEF VER150} // 7/7.1 + CompilerVersion := 'VER150'; + {$ENDIF} + {$IFDEF VER160} // 8 + CompilerVersion := 'VER160'; + {$ENDIF} + {$IFDEF VER170} // 2005 + CompilerVersion := 'VER170'; + {$ENDIF} + {$IFDEF VER180} // 2007 + CompilerVersion := 'VER180'; + {$ENDIF} + {$IFDEF VER185} // 2007 + CompilerVersion := 'VER185'; + {$ENDIF} + {$IFDEF VER190} // 2007.NET + CompilerVersion := 'VER190'; + {$ENDIF} + {$IFDEF CONDITIONALEXPRESSIONS} + {$IF COMPILERVERSION > 19.0} + CompilerVersion := 'VER' + IntToStr(Round(10*CompilerVersion)); + {$IFEND} + {$ENDIF} + +{$IFDEF WIN32} + FWIN32 := true; +{$ENDIF} +{$IFDEF WIN64} + FWIN64 := true; +{$ENDIF} +{$IFDEF LINUX} + FLINUX := true; +{$ENDIF} +{$IFDEF LINUX32} + FLINUX32 := true; +{$ENDIF} +{$IFDEF LINUX64} + FLINUX64 := true; +{$ENDIF} +{$IFDEF POSIX} + FPOSIX := true; +{$ENDIF} +{$IFDEF POSIX32} + FPOSIX32 := true; +{$ENDIF} +{$IFDEF POSIX64} + FPOSIX64 := true; +{$ENDIF} +{$IFDEF CPUARM} + FCPUARM := true; +{$ENDIF} +{$IFDEF CPUARM32} + FCPUARM32 := true; +{$ENDIF} +{$IFDEF CPUARM64} + FCPUARM64 := true; +{$ENDIF} +{$IFDEF CPU386} + FCPU386 := true; +{$ENDIF} +{$IFDEF CPUX86} + FCPUX86 := true; +{$ENDIF} +{$IFDEF CPUX64} + FCPUX64 := true; +{$ENDIF} +{$IFDEF CPU32} + FCPU32 := true; +{$ENDIF} +{$IFDEF CPU64} + FCPU64 := true; +{$ENDIF} +{$IFDEF CPU32BITS} + FCPU32BITS := true; +{$ENDIF} +{$IFDEF CPU64BITS} + FCPU64BITS := true; +{$ENDIF} +{$IFDEF MSWINDOWS} + FMSWINDOWS := true; +{$ENDIF} +{$IFDEF MACOS} + FMACOS := true; +{$ENDIF} +{$IFDEF MACOS32} + FMACOS32 := true; +{$ENDIF} +{$IFDEF MACOS64} + FMACOS64 := true; +{$ENDIF} +{$IFDEF IOS} + FIOS := true; +{$ENDIF} +{$IFDEF IOS32} + FIOS32 := true; +{$ENDIF} +{$IFDEF IOS64} + FIOS64 := true; +{$ENDIF} +{$IFDEF ANDROID} + FANDROID := true; +{$ENDIF} +{$IFDEF ANDROID32} + FANDROID32 := true; +{$ENDIF} +{$IFDEF ANDROID64} + FANDROID64 := true; +{$ENDIF} +{$IFDEF CONSOLE} + FCONSOLE := true; +{$ENDIF} +{$IFDEF NATIVECODE} + FNATIVECODE := true; +{$ENDIF} +{$IFDEF CONDITIONALEXPRESSIONS} + FCONDITIONALEXPRESSIONS := true; +{$ENDIF} +{$IFDEF UNICODE} + FUNICODE := true; +{$ENDIF} +{$IFDEF ALIGN_STACK} + FALIGN_STACK := true; +{$ENDIF} +{$IFDEF ARM_NO_VFP_USE} + FARM_NO_VFP_USE := true; +{$ENDIF} +{$IFDEF ASSEMBLER} + FASSEMBLER := true; +{$ENDIF} +{$IFDEF AUTOREFCOUNT} + FAUTOREFCOUNT := true; +{$ENDIF} +{$IFDEF EXTERNALLINKER} + FEXTERNALLINKER := true; +{$ENDIF} +{$IFDEF ELF} + FELF := true; +{$ENDIF} +{$IFDEF NEXTGEN} + FNEXTGEN := true; +{$ENDIF} +{$IFDEF PC_MAPPED_EXCEPTIONS} + FPC_MAPPED_EXCEPTIONS := true; +{$ENDIF} +{$IFDEF PIC} + FPIC := true; +{$ENDIF} +{$IFDEF UNDERSCOREIMPORTNAME} + FUNDERSCOREIMPORTNAME := true; +{$ENDIF} +{$IFDEF WEAKREF} + FWEAKREF := true; +{$ENDIF} +{$IFDEF WEAKINSTREF} + FWEAKINSTREF := true; +{$ENDIF} +{$IFDEF WEAKINTFREF} + FWEAKINTFREF := true; +{$ENDIF} +end; + +procedure TDelphiParserConfig.Configure(os : TDelphiParserOS; cpu : TDelphiParserCPUType); +begin + FCPU386 := false; + FCPUX86 := false; + FCPUX64 := false; + FCPU32 := false; + FCPU64 := false; + FCPUARM := false; + FCPUARM32 := false; + FCPUARM64 := false; + + case cpu of + ct32: + begin + FCPU386 := true; + FCPUX86 := true; + FCPU32 := true; + end; + ct64: + begin + FCPU386 := true; + FCPUX64 := true; + FCPU64 := true; + end; + ctARM32: + begin + FCPUARM := true; + FCPUARM32 := true; + FCPU32 := true; + end; + ctARM64: + begin + FCPUARM := true; + FCPUARM64 := true; + FCPU64 := true; + end; + end; + + + FWIN32 := false; + FWIN64 := false; + FLINUX := false; + FLINUX32 := false; + FLINUX64 := false; + FPOSIX := false; + FPOSIX32 := false; + FPOSIX64 := false; + FCPUARM := false; + FCPUARM32 := false; + FCPUARM64 := false; + FMSWINDOWS := false; + FMACOS := false; + FMACOS32 := false; + FMACOS64 := false; + FIOS := false; + FIOS32 := false; + FIOS64 := false; + FANDROID := false; + FANDROID32 := false; + FANDROID64 := false; + case os of + osWindows : + begin + FMSWINDOWS := true; + if cpu in [ct32, ctARM32] then FWIN32 := true else FWIN64 := true; + end; + osLinux : + begin + FLINUX := true; + if cpu in [ct32, ctARM32] then FLINUX32 := true else FLINUX64 := true; + FPOSIX := true; + if cpu in [ct32, ctARM32] then FPOSIX32 := true else FPOSIX64 := true; + end; + osMac : + begin + FMACOS := true; + if cpu in [ct32, ctARM32] then FMACOS32 := true else FMACOS64 := true; + FPOSIX := true; + if cpu in [ct32, ctARM32] then FPOSIX32 := true else FPOSIX64 := true; + end; + osIOS : + begin + FIOS := true; + if cpu in [ct32, ctARM32] then FIOS32 := true else FIOS64 := true; + FPOSIX := true; + if cpu in [ct32, ctARM32] then FPOSIX32 := true else FPOSIX64 := true; + end; + osAndroid : + begin + FANDROID := true; + if cpu in [ct32, ctARM32] then FANDROID32 := true else FANDROID64 := true; + end; + end; +end; + +procedure TDelphiParserConfig.ConfigureWin32; +begin + Configure(osWindows, ct32); +end; + +procedure TDelphiParserConfig.ConfigureWin64; +begin + Configure(osWindows, ct64); +end; + +procedure TDelphiParserConfig.ConfigureLinux64; +begin + Configure(osLinux, ct64); +end; + +procedure TDelphiParserConfig.ConfigureMac64; +begin + Configure(osMac, ct64); +end; + +procedure TDelphiParserConfig.ConfigureMacM1; +begin + Configure(osMac, ctARM64); +end; + +procedure TDelphiParserConfig.ConfigureIOS; +begin + Configure(osIOS, ct64); +end; + +procedure TDelphiParserConfig.ConfigureAndroid; +begin + Configure(osAndroid, ct64); +end; + +initialization + DelphiParserConfig := TDelphiParserConfig.create; +finalization + DelphiParserConfig.Free; +end. +