diff --git a/.gitattributes b/.gitattributes index 22fe2f9b74..4f77cae9c0 100644 --- a/.gitattributes +++ b/.gitattributes @@ -2958,9 +2958,6 @@ packages/fcl-base/examples/parser.dat -text packages/fcl-base/examples/poolmm1.pp svneol=native#text/plain packages/fcl-base/examples/poolmm2.pp svneol=native#text/plain packages/fcl-base/examples/restest.pp svneol=native#text/plain -packages/fcl-base/examples/showver.pp svneol=native#text/plain -packages/fcl-base/examples/showver.rc -text -packages/fcl-base/examples/showver.res -text packages/fcl-base/examples/simple.xml -text packages/fcl-base/examples/sitest.pp svneol=native#text/plain packages/fcl-base/examples/sockcli.pp svneol=native#text/plain @@ -3022,7 +3019,6 @@ packages/fcl-base/src/csvreadwrite.pp svneol=native#text/plain packages/fcl-base/src/custapp.pp svneol=native#text/plain packages/fcl-base/src/dummy/eventlog.inc svneol=native#text/plain packages/fcl-base/src/eventlog.pp svneol=native#text/plain -packages/fcl-base/src/fileinfo.pp svneol=native#text/plain packages/fcl-base/src/fpexprpars.pp svneol=native#text/plain packages/fcl-base/src/fpobserver.pp svneol=native#text/plain packages/fcl-base/src/fptemplate.pp svneol=native#text/plain @@ -3373,8 +3369,12 @@ packages/fcl-extra/examples/double/daemonunit2.lfm svneol=native#text/plain packages/fcl-extra/examples/double/daemonunit2.pas svneol=native#text/plain packages/fcl-extra/examples/double/double.pp svneol=native#text/plain packages/fcl-extra/examples/double/resdaemonapp.pp svneol=native#text/plain +packages/fcl-extra/examples/showver.pp svneol=native#text/pascal +packages/fcl-extra/examples/showver.rc svneol=native#text/plain +packages/fcl-extra/examples/showver.res -text packages/fcl-extra/fpmake.pp svneol=native#text/pascal packages/fcl-extra/src/daemonapp.pp svneol=native#text/plain +packages/fcl-extra/src/fileinfo.pp svneol=native#text/pascal packages/fcl-extra/src/unix/daemonapp.inc svneol=native#text/plain packages/fcl-extra/src/win/ServiceManager.pas svneol=native#text/plain packages/fcl-extra/src/win/daemonapp.inc svneol=native#text/plain @@ -3897,6 +3897,12 @@ packages/fcl-res/src/machosubreader.inc svneol=native#text/plain packages/fcl-res/src/machosubwriter.inc svneol=native#text/plain packages/fcl-res/src/machotypes.pp svneol=native#text/plain packages/fcl-res/src/machowriter.pp svneol=native#text/plain +packages/fcl-res/src/rclex.inc svneol=native#text/plain +packages/fcl-res/src/rclex.l svneol=native#text/plain +packages/fcl-res/src/rcparser.pas svneol=native#text/pascal +packages/fcl-res/src/rcparser.y svneol=native#text/plain +packages/fcl-res/src/rcparserfn.inc svneol=native#text/plain +packages/fcl-res/src/rcreader.pp svneol=native#text/pascal packages/fcl-res/src/resdatastream.pp svneol=native#text/plain packages/fcl-res/src/resfactory.pp svneol=native#text/plain packages/fcl-res/src/resmerger.pp svneol=native#text/plain @@ -3912,6 +3918,8 @@ packages/fcl-res/src/versionresource.pp svneol=native#text/plain packages/fcl-res/src/versiontypes.pp svneol=native#text/plain packages/fcl-res/src/winpeimagereader.pp svneol=native#text/plain packages/fcl-res/src/xcoffwriter.pp svneol=native#text/plain +packages/fcl-res/src/yyinclude.pp svneol=native#text/pascal +packages/fcl-res/src/yypreproc.pp svneol=native#text/pascal packages/fcl-res/xml/acceleratorsresource.xml svneol=native#text/plain packages/fcl-res/xml/bitmapresource.xml svneol=native#text/plain packages/fcl-res/xml/clean.sh svneol=native#text/plain @@ -8826,6 +8834,11 @@ packages/tosunits/src/aes.pas svneol=native#text/plain packages/tosunits/src/gemdos.pas svneol=native#text/plain packages/tosunits/src/vdi.pas svneol=native#text/plain packages/tosunits/src/xbios.pas svneol=native#text/plain +packages/tplylib/Makefile svneol=native#text/plain +packages/tplylib/Makefile.fpc svneol=native#text/plain +packages/tplylib/fpmake.pp svneol=native#text/pascal +packages/tplylib/src/lexlib.pas svneol=native#text/pascal +packages/tplylib/src/yacclib.pas svneol=native#text/pascal packages/univint/Makefile svneol=native#text/plain packages/univint/Makefile.fpc svneol=native#text/plain packages/univint/Makefile.fpc.fpcmake svneol=native#text/plain @@ -18721,7 +18734,6 @@ utils/tply/README.txt svneol=native#text/plain utils/tply/fpmake.pp svneol=native#text/plain utils/tply/lexbase.pas svneol=native#text/plain utils/tply/lexdfa.pas svneol=native#text/plain -utils/tply/lexlib.pas svneol=native#text/plain utils/tply/lexlist.pas svneol=native#text/plain utils/tply/lexmsgs.pas svneol=native#text/plain utils/tply/lexopt.pas svneol=native#text/plain @@ -18735,7 +18747,6 @@ utils/tply/tply.doc -text utils/tply/tply.tex -text utils/tply/yaccbase.pas svneol=native#text/plain utils/tply/yaccclos.pas svneol=native#text/plain -utils/tply/yacclib.pas svneol=native#text/plain utils/tply/yacclook.pas svneol=native#text/plain utils/tply/yacclr0.pas svneol=native#text/plain utils/tply/yaccmsgs.pas svneol=native#text/plain diff --git a/packages/fcl-base/fpmake.pp b/packages/fcl-base/fpmake.pp index 1251be9a77..e19880ee46 100644 --- a/packages/fcl-base/fpmake.pp +++ b/packages/fcl-base/fpmake.pp @@ -19,7 +19,6 @@ begin {$endif ALLPACKAGES} P.Version:='3.2.1'; P.Dependencies.Add('univint',[Darwin,iPhoneSim]); - P.Dependencies.Add('fcl-res'); p.Dependencies.Add('rtl-objpas'); P.Author := ''; @@ -120,8 +119,6 @@ begin T:=P.Targets.AddUnit('fpexprpars.pp'); T.ResourceStrings:=true; - T:=P.Targets.AddUnit('fileinfo.pp'); - T.ResourceStrings:=true; T:=P.Targets.AddUnit('csvreadwrite.pp'); T:=P.Targets.addUnit('csvdocument.pp'); With T.Dependencies do @@ -166,7 +163,6 @@ begin T:=P.Targets.AddExampleProgram('poolmm1.pp'); T:=P.Targets.AddExampleProgram('poolmm2.pp'); T:=P.Targets.AddExampleProgram('restest.pp'); - T:=P.Targets.AddExampleProgram('showver.pp'); T:=P.Targets.AddExampleProgram('sockcli.pp'); T:=P.Targets.AddExampleProgram('socksvr.pp'); T:=P.Targets.AddExampleProgram('sstream.pp'); @@ -208,8 +204,6 @@ begin // README // kword.xml // overview.rtf - // showver.rc - // showver.res // simple.xml // parser.dat // testcgi.html diff --git a/packages/fcl-base/examples/showver.pp b/packages/fcl-extra/examples/showver.pp similarity index 100% rename from packages/fcl-base/examples/showver.pp rename to packages/fcl-extra/examples/showver.pp diff --git a/packages/fcl-base/examples/showver.rc b/packages/fcl-extra/examples/showver.rc similarity index 100% rename from packages/fcl-base/examples/showver.rc rename to packages/fcl-extra/examples/showver.rc diff --git a/packages/fcl-base/examples/showver.res b/packages/fcl-extra/examples/showver.res similarity index 100% rename from packages/fcl-base/examples/showver.res rename to packages/fcl-extra/examples/showver.res diff --git a/packages/fcl-extra/fpmake.pp b/packages/fcl-extra/fpmake.pp index 1779d1a9a5..f6836c363a 100644 --- a/packages/fcl-extra/fpmake.pp +++ b/packages/fcl-extra/fpmake.pp @@ -18,6 +18,7 @@ begin {$endif ALLPACKAGES} P.Version:='3.2.1'; P.Dependencies.Add('fcl-base'); + P.Dependencies.Add('fcl-res'); P.OSes:=[Win32,Win64]+AllUnixOSes; if Defaults.CPU=jvm then P.OSes := P.OSes - [java,android]; @@ -46,10 +47,21 @@ begin end; T.ResourceStrings:=true; + T:=P.Targets.AddUnit('fileinfo.pp'); + T.ResourceStrings:=true; + // Windows units T:=P.Targets.AddUnit('ServiceManager.pas',[Win32,Win64]); T.ResourceStrings:=true; + // Examples + P.ExamplePath.Add('examples'); + T:=P.Targets.AddExampleProgram('showver.pp'); + + // example data files. + // showver.rc + // showver.res + {$ifndef ALLPACKAGES} Run; end; diff --git a/packages/fcl-base/src/fileinfo.pp b/packages/fcl-extra/src/fileinfo.pp similarity index 100% rename from packages/fcl-base/src/fileinfo.pp rename to packages/fcl-extra/src/fileinfo.pp diff --git a/packages/fcl-res/fpmake.pp b/packages/fcl-res/fpmake.pp index faa9ebce83..1c1255fa55 100644 --- a/packages/fcl-res/fpmake.pp +++ b/packages/fcl-res/fpmake.pp @@ -18,6 +18,9 @@ begin P.Directory:=ADirectory; {$endif ALLPACKAGES} P.Version:='3.2.1'; + P.Dependencies.Add('rtl-objpas'); + P.Dependencies.Add('fcl-base'); + P.Dependencies.Add('tplylib'); P.Author := 'Giulio Bernardi'; P.License := 'LGPL with modification, '; P.HomepageURL := 'www.freepascal.org'; @@ -189,6 +192,30 @@ begin AddInclude('machosubwriter.inc'); AddInclude('machodefaulttarget.inc'); end; + T:=P.Targets.AddUnit('rcparser.pas'); + with T.Dependencies do + begin + AddUnit('resource'); + AddUnit('acceleratorsresource'); + AddUnit('groupiconresource'); + AddUnit('stringtableresource'); + AddUnit('bitmapresource'); + AddUnit('versionresource'); + AddUnit('versiontypes'); + AddUnit('groupcursorresource'); + AddInclude('rcparserfn.inc'); + AddInclude('rclex.inc'); + AddInclude('yyinclude.pp'); + AddInclude('yypreproc.pp'); + end; + T:=P.Targets.AddUnit('rcreader.pp'); + with T.Dependencies do + begin + AddUnit('resource'); + AddUnit('resdatastream'); + AddUnit('resfactory'); + AddUnit('rcparser'); + end; T:=P.Targets.AddUnit('resdatastream.pp'); with T.Dependencies do begin diff --git a/packages/fcl-res/src/rclex.inc b/packages/fcl-res/src/rclex.inc new file mode 100644 index 0000000000..69fe8194a4 --- /dev/null +++ b/packages/fcl-res/src/rclex.inc @@ -0,0 +1,1363 @@ + +(* lexical analyzer template (TP Lex V3.0), V1.0 3-2-91 AG *) + +(* global definitions: *) +var + kwtmp: integer; + +const + KeywordDefs: array [0..33] of TIdentMapEntry = ( + // attribs + (Value: _LANGUAGE; Name: 'LANGUAGE'), + (Value: _CHARACTERISTICS; Name: 'CHARACTERISTICS'), + (Value: _VERSION; Name: 'VERSION'), + (Value: _MOVEABLE; Name: 'MOVEABLE'), + (Value: _FIXED; Name: 'FIXED'), + (Value: _PURE; Name: 'PURE'), + (Value: _IMPURE; Name: 'IMPURE'), + (Value: _PRELOAD; Name: 'PRELOAD'), + (Value: _LOADONCALL; Name: 'LOADONCALL'), + (Value: _DISCARDABLE; Name: 'DISCARDABLE'), + // resource names + (Value: _ANICURSOR; Name: 'ANICURSOR'), + (Value: _ANIICON; Name: 'ANIICON'), + (Value: _BITMAP; Name: 'BITMAP'), + (Value: _CURSOR; Name: 'CURSOR'), + (Value: _DLGINCLUDE; Name: 'DLGINCLUDE'), + (Value: _DLGINIT; Name: 'DLGINIT'), + (Value: _HTML; Name: 'HTML'), + (Value: _ICON; Name: 'ICON'), + (Value: _MANIFEST; Name: 'MANIFEST'), + (Value: _MESSAGETABLE; Name: 'MESSAGETABLE'), + (Value: _PLUGPLAY; Name: 'PLUGPLAY'), + (Value: _STRINGTABLE; Name: 'STRINGTABLE'), + (Value: _RCDATA; Name: 'RCDATA'), + (Value: _VERSIONINFO; Name: 'VERSIONINFO'), + (Value: _VXD; Name: 'VXD'), + // file version fields names + (Value: _FILEVERSION; Name: 'FILEVERSION'), + (Value: _PRODUCTVERSION; Name: 'PRODUCTVERSION'), + (Value: _FILEFLAGSMASK; Name: 'FILEFLAGSMASK'), + (Value: _FILEFLAGS; Name: 'FILEFLAGS'), + (Value: _FILEOS; Name: 'FILEOS'), + (Value: _FILETYPE; Name: 'FILETYPE'), + (Value: _FILESUBTYPE; Name: 'FILESUBTYPE'), + (Value: _BLOCK; Name: 'BLOCK'), + (Value: _VALUE; Name: 'VALUE') + ); + +function KeywordToInt(k: string; out kw: integer): boolean; +var + i: integer; +begin + Result:= False; + for i:= low(KeywordDefs) to high(KeywordDefs) do begin + if k = KeywordDefs[i].Name then begin + kw:= KeywordDefs[i].Value; + Exit(True); + end; + end; +end; + +const INCOMLINE = 2; +const INCOMMENT = 4; +const INSTRING = 6; +const INSTRINGL = 8; + + + +function yylex : Integer; + +procedure yyaction ( yyruleno : Integer ); + (* local definitions: *) + +begin + (* actions: *) + case yyruleno of + 1: + start(INCOMLINE); + 2: + begin start(0); unget_char(nl); end; + 3: + yymore; + + 4: + start(INCOMMENT); + 5: + ; + 6: + start(0); + 7: + return(_ILLEGAL); + + 8: + return(_NUMBER); + 9: + return(_NUMBER); + 10: + return(_NUMBER); + 11: + begin start(INSTRINGL); strbuf_begin(); end; + 12: + begin start(INSTRING); strbuf_begin(); end; + 13: + strbuf_append('"'); + 14: + begin + start(0); + return(_QUOTEDSTR); + end; + 15: + begin + start(0); + return(_QUOTEDSTRL); + end; + 16: + ; + 17: + return(_ILLEGAL); + 18: + strbuf_append(yytext); + 19: + begin yytext:= 'StringFileInfo'; return(_STR_StringFileInfo); end; + 20: + begin yytext:= 'VarFileInfo'; return(_STR_VarFileInfo); end; + 21: + begin yytext:= 'Translation'; return(_STR_Translation); end; + + 22: + return(_BEGIN); + 23: + return(_END); + 24: + begin + if ypreproc.isdefine(yytext) then begin + unget_char(' '); + unget_string(ypreproc.getdefine(yytext)); + end else + if KeywordToInt(yytext, kwtmp) then + return(kwtmp) + else + return(_ID); + end; + 25: + ; + 26: + returnc(yytext[1]); + 27: + return(_ILLEGAL); + end; +end(*yyaction*); + +(* DFA table: *) + +type YYTRec = record + cc : set of Char; + s : Integer; + end; + +const + +yynmarks = 62; +yynmatches = 62; +yyntrans = 131; +yynstates = 94; + +yyk : array [1..yynmarks] of Integer = ( + { 0: } + { 1: } + { 2: } + { 3: } + { 4: } + { 5: } + { 6: } + { 7: } + { 8: } + { 9: } + { 10: } + 26, + 27, + { 11: } + 8, + 27, + { 12: } + 8, + 27, + { 13: } + 24, + 27, + { 14: } + 12, + 27, + { 15: } + 24, + 27, + { 16: } + 22, + 27, + { 17: } + 24, + 27, + { 18: } + 23, + 27, + { 19: } + 24, + 27, + { 20: } + 25, + { 21: } + 26, + 27, + { 22: } + 25, + 27, + { 23: } + 27, + { 24: } + 2, + { 25: } + 3, + { 26: } + 5, + { 27: } + 5, + { 28: } + 7, + { 29: } + 14, + 18, + { 30: } + 18, + { 31: } + 17, + { 32: } + 18, + { 33: } + 15, + 18, + { 34: } + 1, + { 35: } + 4, + { 36: } + 8, + { 37: } + 8, + { 38: } + { 39: } + { 40: } + 11, + { 41: } + 24, + { 42: } + { 43: } + { 44: } + { 45: } + 24, + { 46: } + 24, + { 47: } + 6, + { 48: } + 13, + { 49: } + 16, + { 50: } + 9, + { 51: } + 10, + { 52: } + { 53: } + 24, + { 54: } + 23, + 24, + { 55: } + 9, + { 56: } + 10, + { 57: } + { 58: } + { 59: } + { 60: } + 24, + { 61: } + { 62: } + 22, + 24, + { 63: } + { 64: } + { 65: } + { 66: } + { 67: } + { 68: } + { 69: } + { 70: } + { 71: } + { 72: } + 20, + { 73: } + 21, + { 74: } + 19 + { 75: } + { 76: } + { 77: } + { 78: } + { 79: } + { 80: } + { 81: } + { 82: } + { 83: } + { 84: } + { 85: } + { 86: } + { 87: } + { 88: } + { 89: } + { 90: } + { 91: } + { 92: } + { 93: } +); + +yym : array [1..yynmatches] of Integer = ( +{ 0: } +{ 1: } +{ 2: } +{ 3: } +{ 4: } +{ 5: } +{ 6: } +{ 7: } +{ 8: } +{ 9: } +{ 10: } + 26, + 27, +{ 11: } + 8, + 27, +{ 12: } + 8, + 27, +{ 13: } + 24, + 27, +{ 14: } + 12, + 27, +{ 15: } + 24, + 27, +{ 16: } + 22, + 27, +{ 17: } + 24, + 27, +{ 18: } + 23, + 27, +{ 19: } + 24, + 27, +{ 20: } + 25, +{ 21: } + 26, + 27, +{ 22: } + 25, + 27, +{ 23: } + 27, +{ 24: } + 2, +{ 25: } + 3, +{ 26: } + 5, +{ 27: } + 5, +{ 28: } + 7, +{ 29: } + 14, + 18, +{ 30: } + 18, +{ 31: } + 17, +{ 32: } + 18, +{ 33: } + 15, + 18, +{ 34: } + 1, +{ 35: } + 4, +{ 36: } + 8, +{ 37: } + 8, +{ 38: } +{ 39: } +{ 40: } + 11, +{ 41: } + 24, +{ 42: } +{ 43: } +{ 44: } +{ 45: } + 24, +{ 46: } + 24, +{ 47: } + 6, +{ 48: } + 13, +{ 49: } + 16, +{ 50: } + 9, +{ 51: } + 10, +{ 52: } +{ 53: } + 24, +{ 54: } + 23, + 24, +{ 55: } + 9, +{ 56: } + 10, +{ 57: } +{ 58: } +{ 59: } +{ 60: } + 24, +{ 61: } +{ 62: } + 22, + 24, +{ 63: } +{ 64: } +{ 65: } +{ 66: } +{ 67: } +{ 68: } +{ 69: } +{ 70: } +{ 71: } +{ 72: } + 20, +{ 73: } + 21, +{ 74: } + 19 +{ 75: } +{ 76: } +{ 77: } +{ 78: } +{ 79: } +{ 80: } +{ 81: } +{ 82: } +{ 83: } +{ 84: } +{ 85: } +{ 86: } +{ 87: } +{ 88: } +{ 89: } +{ 90: } +{ 91: } +{ 92: } +{ 93: } +); + +yyt : array [1..yyntrans] of YYTrec = ( +{ 0: } + ( cc: [ #1..#8,#11,#13..#31,'!','#','$','''','*','+', + '-','.',':'..'@','['..']','`',#127..#255 ]; s: 23), + ( cc: [ #9,#12,' ' ]; s: 22), + ( cc: [ #10 ]; s: 20), + ( cc: [ '"' ]; s: 14), + ( cc: [ '%','&','(',')',',','^','|','~' ]; s: 21), + ( cc: [ '/' ]; s: 10), + ( cc: [ '0' ]; s: 12), + ( cc: [ '1'..'9' ]; s: 11), + ( cc: [ 'A','C','D','F'..'K','M'..'Z','_','a'..'z' ]; s: 19), + ( cc: [ 'B' ]; s: 15), + ( cc: [ 'E' ]; s: 17), + ( cc: [ 'L' ]; s: 13), + ( cc: [ '{' ]; s: 16), + ( cc: [ '}' ]; s: 18), +{ 1: } + ( cc: [ #1..#8,#11,#13..#31,'!','#','$','''','*','+', + '-','.',':'..'@','['..']','`',#127..#255 ]; s: 23), + ( cc: [ #9,#12,' ' ]; s: 22), + ( cc: [ #10 ]; s: 20), + ( cc: [ '"' ]; s: 14), + ( cc: [ '%','&','(',')',',','^','|','~' ]; s: 21), + ( cc: [ '/' ]; s: 10), + ( cc: [ '0' ]; s: 12), + ( cc: [ '1'..'9' ]; s: 11), + ( cc: [ 'A','C','D','F'..'K','M'..'Z','_','a'..'z' ]; s: 19), + ( cc: [ 'B' ]; s: 15), + ( cc: [ 'E' ]; s: 17), + ( cc: [ 'L' ]; s: 13), + ( cc: [ '{' ]; s: 16), + ( cc: [ '}' ]; s: 18), +{ 2: } + ( cc: [ #1..#9,#11..#255 ]; s: 25), + ( cc: [ #10 ]; s: 24), +{ 3: } + ( cc: [ #1..#9,#11..#255 ]; s: 25), + ( cc: [ #10 ]; s: 24), +{ 4: } + ( cc: [ #0 ]; s: 28), + ( cc: [ #1..#9,#11..')','+'..#255 ]; s: 26), + ( cc: [ '*' ]; s: 27), +{ 5: } + ( cc: [ #0 ]; s: 28), + ( cc: [ #1..#9,#11..')','+'..#255 ]; s: 26), + ( cc: [ '*' ]; s: 27), +{ 6: } + ( cc: [ #1..#9,#11..'!','#'..'[',']'..#255 ]; s: 32), + ( cc: [ #10 ]; s: 31), + ( cc: [ '"' ]; s: 29), + ( cc: [ '\' ]; s: 30), +{ 7: } + ( cc: [ #1..#9,#11..'!','#'..'[',']'..#255 ]; s: 32), + ( cc: [ #10 ]; s: 31), + ( cc: [ '"' ]; s: 29), + ( cc: [ '\' ]; s: 30), +{ 8: } + ( cc: [ #1..#9,#11..'!','#'..'[',']'..#255 ]; s: 32), + ( cc: [ #10 ]; s: 31), + ( cc: [ '"' ]; s: 33), + ( cc: [ '\' ]; s: 30), +{ 9: } + ( cc: [ #1..#9,#11..'!','#'..'[',']'..#255 ]; s: 32), + ( cc: [ #10 ]; s: 31), + ( cc: [ '"' ]; s: 33), + ( cc: [ '\' ]; s: 30), +{ 10: } + ( cc: [ '*' ]; s: 35), + ( cc: [ '/' ]; s: 34), +{ 11: } + ( cc: [ '0'..'9' ]; s: 36), + ( cc: [ 'L' ]; s: 37), +{ 12: } + ( cc: [ '0'..'9' ]; s: 36), + ( cc: [ 'L' ]; s: 37), + ( cc: [ 'o' ]; s: 39), + ( cc: [ 'x' ]; s: 38), +{ 13: } + ( cc: [ '"' ]; s: 40), + ( cc: [ '0'..'9','A'..'Z','_','a'..'z' ]; s: 41), +{ 14: } + ( cc: [ 'S' ]; s: 42), + ( cc: [ 'T' ]; s: 44), + ( cc: [ 'V' ]; s: 43), +{ 15: } + ( cc: [ '0'..'9','A'..'D','F'..'Z','_','a'..'z' ]; s: 41), + ( cc: [ 'E' ]; s: 45), +{ 16: } +{ 17: } + ( cc: [ '0'..'9','A'..'M','O'..'Z','_','a'..'z' ]; s: 41), + ( cc: [ 'N' ]; s: 46), +{ 18: } +{ 19: } + ( cc: [ '0'..'9','A'..'Z','_','a'..'z' ]; s: 41), +{ 20: } +{ 21: } +{ 22: } +{ 23: } +{ 24: } +{ 25: } +{ 26: } +{ 27: } + ( cc: [ '/' ]; s: 47), +{ 28: } +{ 29: } + ( cc: [ '"' ]; s: 48), +{ 30: } + ( cc: [ #10 ]; s: 49), +{ 31: } +{ 32: } +{ 33: } + ( cc: [ '"' ]; s: 48), +{ 34: } +{ 35: } +{ 36: } + ( cc: [ '0'..'9' ]; s: 36), + ( cc: [ 'L' ]; s: 37), +{ 37: } +{ 38: } + ( cc: [ '0'..'9','A'..'F','a'..'f' ]; s: 50), +{ 39: } + ( cc: [ '0'..'7' ]; s: 51), +{ 40: } +{ 41: } + ( cc: [ '0'..'9','A'..'Z','_','a'..'z' ]; s: 41), +{ 42: } + ( cc: [ 't' ]; s: 52), +{ 43: } + ( cc: [ 'a' ]; s: 77), +{ 44: } + ( cc: [ 'r' ]; s: 76), +{ 45: } + ( cc: [ '0'..'9','A'..'F','H'..'Z','_','a'..'z' ]; s: 41), + ( cc: [ 'G' ]; s: 53), +{ 46: } + ( cc: [ '0'..'9','A'..'C','E'..'Z','_','a'..'z' ]; s: 41), + ( cc: [ 'D' ]; s: 54), +{ 47: } +{ 48: } +{ 49: } +{ 50: } + ( cc: [ '0'..'9','A'..'F','a'..'f' ]; s: 50), + ( cc: [ 'L' ]; s: 55), +{ 51: } + ( cc: [ '0'..'7' ]; s: 51), + ( cc: [ 'L' ]; s: 56), +{ 52: } + ( cc: [ 'r' ]; s: 57), +{ 53: } + ( cc: [ '0'..'9','A'..'H','J'..'Z','_','a'..'z' ]; s: 41), + ( cc: [ 'I' ]; s: 60), +{ 54: } + ( cc: [ '0'..'9','A'..'Z','_','a'..'z' ]; s: 41), +{ 55: } +{ 56: } +{ 57: } + ( cc: [ 'i' ]; s: 79), +{ 58: } + ( cc: [ 'F' ]; s: 78), +{ 59: } + ( cc: [ 'n' ]; s: 61), +{ 60: } + ( cc: [ '0'..'9','A'..'M','O'..'Z','_','a'..'z' ]; s: 41), + ( cc: [ 'N' ]; s: 62), +{ 61: } + ( cc: [ 's' ]; s: 80), +{ 62: } + ( cc: [ '0'..'9','A'..'Z','_','a'..'z' ]; s: 41), +{ 63: } + ( cc: [ 'g' ]; s: 93), +{ 64: } + ( cc: [ 'l' ]; s: 65), +{ 65: } + ( cc: [ 'e' ]; s: 67), +{ 66: } + ( cc: [ 'a' ]; s: 75), +{ 67: } + ( cc: [ 'I' ]; s: 83), +{ 68: } + ( cc: [ 'f' ]; s: 70), +{ 69: } + ( cc: [ 'o' ]; s: 85), +{ 70: } + ( cc: [ 'o' ]; s: 71), +{ 71: } + ( cc: [ '"' ]; s: 72), +{ 72: } +{ 73: } +{ 74: } +{ 75: } + ( cc: [ 't' ]; s: 82), +{ 76: } + ( cc: [ 'a' ]; s: 59), +{ 77: } + ( cc: [ 'r' ]; s: 58), +{ 78: } + ( cc: [ 'i' ]; s: 64), +{ 79: } + ( cc: [ 'n' ]; s: 63), +{ 80: } + ( cc: [ 'l' ]; s: 66), +{ 81: } + ( cc: [ '"' ]; s: 73), +{ 82: } + ( cc: [ 'i' ]; s: 69), +{ 83: } + ( cc: [ 'n' ]; s: 68), +{ 84: } + ( cc: [ '"' ]; s: 74), +{ 85: } + ( cc: [ 'n' ]; s: 81), +{ 86: } + ( cc: [ 'o' ]; s: 84), +{ 87: } + ( cc: [ 'f' ]; s: 86), +{ 88: } + ( cc: [ 'n' ]; s: 87), +{ 89: } + ( cc: [ 'I' ]; s: 88), +{ 90: } + ( cc: [ 'e' ]; s: 89), +{ 91: } + ( cc: [ 'l' ]; s: 90), +{ 92: } + ( cc: [ 'i' ]; s: 91), +{ 93: } + ( cc: [ 'F' ]; s: 92) +); + +yykl : array [0..yynstates-1] of Integer = ( +{ 0: } 1, +{ 1: } 1, +{ 2: } 1, +{ 3: } 1, +{ 4: } 1, +{ 5: } 1, +{ 6: } 1, +{ 7: } 1, +{ 8: } 1, +{ 9: } 1, +{ 10: } 1, +{ 11: } 3, +{ 12: } 5, +{ 13: } 7, +{ 14: } 9, +{ 15: } 11, +{ 16: } 13, +{ 17: } 15, +{ 18: } 17, +{ 19: } 19, +{ 20: } 21, +{ 21: } 22, +{ 22: } 24, +{ 23: } 26, +{ 24: } 27, +{ 25: } 28, +{ 26: } 29, +{ 27: } 30, +{ 28: } 31, +{ 29: } 32, +{ 30: } 34, +{ 31: } 35, +{ 32: } 36, +{ 33: } 37, +{ 34: } 39, +{ 35: } 40, +{ 36: } 41, +{ 37: } 42, +{ 38: } 43, +{ 39: } 43, +{ 40: } 43, +{ 41: } 44, +{ 42: } 45, +{ 43: } 45, +{ 44: } 45, +{ 45: } 45, +{ 46: } 46, +{ 47: } 47, +{ 48: } 48, +{ 49: } 49, +{ 50: } 50, +{ 51: } 51, +{ 52: } 52, +{ 53: } 52, +{ 54: } 53, +{ 55: } 55, +{ 56: } 56, +{ 57: } 57, +{ 58: } 57, +{ 59: } 57, +{ 60: } 57, +{ 61: } 58, +{ 62: } 58, +{ 63: } 60, +{ 64: } 60, +{ 65: } 60, +{ 66: } 60, +{ 67: } 60, +{ 68: } 60, +{ 69: } 60, +{ 70: } 60, +{ 71: } 60, +{ 72: } 60, +{ 73: } 61, +{ 74: } 62, +{ 75: } 63, +{ 76: } 63, +{ 77: } 63, +{ 78: } 63, +{ 79: } 63, +{ 80: } 63, +{ 81: } 63, +{ 82: } 63, +{ 83: } 63, +{ 84: } 63, +{ 85: } 63, +{ 86: } 63, +{ 87: } 63, +{ 88: } 63, +{ 89: } 63, +{ 90: } 63, +{ 91: } 63, +{ 92: } 63, +{ 93: } 63 +); + +yykh : array [0..yynstates-1] of Integer = ( +{ 0: } 0, +{ 1: } 0, +{ 2: } 0, +{ 3: } 0, +{ 4: } 0, +{ 5: } 0, +{ 6: } 0, +{ 7: } 0, +{ 8: } 0, +{ 9: } 0, +{ 10: } 2, +{ 11: } 4, +{ 12: } 6, +{ 13: } 8, +{ 14: } 10, +{ 15: } 12, +{ 16: } 14, +{ 17: } 16, +{ 18: } 18, +{ 19: } 20, +{ 20: } 21, +{ 21: } 23, +{ 22: } 25, +{ 23: } 26, +{ 24: } 27, +{ 25: } 28, +{ 26: } 29, +{ 27: } 30, +{ 28: } 31, +{ 29: } 33, +{ 30: } 34, +{ 31: } 35, +{ 32: } 36, +{ 33: } 38, +{ 34: } 39, +{ 35: } 40, +{ 36: } 41, +{ 37: } 42, +{ 38: } 42, +{ 39: } 42, +{ 40: } 43, +{ 41: } 44, +{ 42: } 44, +{ 43: } 44, +{ 44: } 44, +{ 45: } 45, +{ 46: } 46, +{ 47: } 47, +{ 48: } 48, +{ 49: } 49, +{ 50: } 50, +{ 51: } 51, +{ 52: } 51, +{ 53: } 52, +{ 54: } 54, +{ 55: } 55, +{ 56: } 56, +{ 57: } 56, +{ 58: } 56, +{ 59: } 56, +{ 60: } 57, +{ 61: } 57, +{ 62: } 59, +{ 63: } 59, +{ 64: } 59, +{ 65: } 59, +{ 66: } 59, +{ 67: } 59, +{ 68: } 59, +{ 69: } 59, +{ 70: } 59, +{ 71: } 59, +{ 72: } 60, +{ 73: } 61, +{ 74: } 62, +{ 75: } 62, +{ 76: } 62, +{ 77: } 62, +{ 78: } 62, +{ 79: } 62, +{ 80: } 62, +{ 81: } 62, +{ 82: } 62, +{ 83: } 62, +{ 84: } 62, +{ 85: } 62, +{ 86: } 62, +{ 87: } 62, +{ 88: } 62, +{ 89: } 62, +{ 90: } 62, +{ 91: } 62, +{ 92: } 62, +{ 93: } 62 +); + +yyml : array [0..yynstates-1] of Integer = ( +{ 0: } 1, +{ 1: } 1, +{ 2: } 1, +{ 3: } 1, +{ 4: } 1, +{ 5: } 1, +{ 6: } 1, +{ 7: } 1, +{ 8: } 1, +{ 9: } 1, +{ 10: } 1, +{ 11: } 3, +{ 12: } 5, +{ 13: } 7, +{ 14: } 9, +{ 15: } 11, +{ 16: } 13, +{ 17: } 15, +{ 18: } 17, +{ 19: } 19, +{ 20: } 21, +{ 21: } 22, +{ 22: } 24, +{ 23: } 26, +{ 24: } 27, +{ 25: } 28, +{ 26: } 29, +{ 27: } 30, +{ 28: } 31, +{ 29: } 32, +{ 30: } 34, +{ 31: } 35, +{ 32: } 36, +{ 33: } 37, +{ 34: } 39, +{ 35: } 40, +{ 36: } 41, +{ 37: } 42, +{ 38: } 43, +{ 39: } 43, +{ 40: } 43, +{ 41: } 44, +{ 42: } 45, +{ 43: } 45, +{ 44: } 45, +{ 45: } 45, +{ 46: } 46, +{ 47: } 47, +{ 48: } 48, +{ 49: } 49, +{ 50: } 50, +{ 51: } 51, +{ 52: } 52, +{ 53: } 52, +{ 54: } 53, +{ 55: } 55, +{ 56: } 56, +{ 57: } 57, +{ 58: } 57, +{ 59: } 57, +{ 60: } 57, +{ 61: } 58, +{ 62: } 58, +{ 63: } 60, +{ 64: } 60, +{ 65: } 60, +{ 66: } 60, +{ 67: } 60, +{ 68: } 60, +{ 69: } 60, +{ 70: } 60, +{ 71: } 60, +{ 72: } 60, +{ 73: } 61, +{ 74: } 62, +{ 75: } 63, +{ 76: } 63, +{ 77: } 63, +{ 78: } 63, +{ 79: } 63, +{ 80: } 63, +{ 81: } 63, +{ 82: } 63, +{ 83: } 63, +{ 84: } 63, +{ 85: } 63, +{ 86: } 63, +{ 87: } 63, +{ 88: } 63, +{ 89: } 63, +{ 90: } 63, +{ 91: } 63, +{ 92: } 63, +{ 93: } 63 +); + +yymh : array [0..yynstates-1] of Integer = ( +{ 0: } 0, +{ 1: } 0, +{ 2: } 0, +{ 3: } 0, +{ 4: } 0, +{ 5: } 0, +{ 6: } 0, +{ 7: } 0, +{ 8: } 0, +{ 9: } 0, +{ 10: } 2, +{ 11: } 4, +{ 12: } 6, +{ 13: } 8, +{ 14: } 10, +{ 15: } 12, +{ 16: } 14, +{ 17: } 16, +{ 18: } 18, +{ 19: } 20, +{ 20: } 21, +{ 21: } 23, +{ 22: } 25, +{ 23: } 26, +{ 24: } 27, +{ 25: } 28, +{ 26: } 29, +{ 27: } 30, +{ 28: } 31, +{ 29: } 33, +{ 30: } 34, +{ 31: } 35, +{ 32: } 36, +{ 33: } 38, +{ 34: } 39, +{ 35: } 40, +{ 36: } 41, +{ 37: } 42, +{ 38: } 42, +{ 39: } 42, +{ 40: } 43, +{ 41: } 44, +{ 42: } 44, +{ 43: } 44, +{ 44: } 44, +{ 45: } 45, +{ 46: } 46, +{ 47: } 47, +{ 48: } 48, +{ 49: } 49, +{ 50: } 50, +{ 51: } 51, +{ 52: } 51, +{ 53: } 52, +{ 54: } 54, +{ 55: } 55, +{ 56: } 56, +{ 57: } 56, +{ 58: } 56, +{ 59: } 56, +{ 60: } 57, +{ 61: } 57, +{ 62: } 59, +{ 63: } 59, +{ 64: } 59, +{ 65: } 59, +{ 66: } 59, +{ 67: } 59, +{ 68: } 59, +{ 69: } 59, +{ 70: } 59, +{ 71: } 59, +{ 72: } 60, +{ 73: } 61, +{ 74: } 62, +{ 75: } 62, +{ 76: } 62, +{ 77: } 62, +{ 78: } 62, +{ 79: } 62, +{ 80: } 62, +{ 81: } 62, +{ 82: } 62, +{ 83: } 62, +{ 84: } 62, +{ 85: } 62, +{ 86: } 62, +{ 87: } 62, +{ 88: } 62, +{ 89: } 62, +{ 90: } 62, +{ 91: } 62, +{ 92: } 62, +{ 93: } 62 +); + +yytl : array [0..yynstates-1] of Integer = ( +{ 0: } 1, +{ 1: } 15, +{ 2: } 29, +{ 3: } 31, +{ 4: } 33, +{ 5: } 36, +{ 6: } 39, +{ 7: } 43, +{ 8: } 47, +{ 9: } 51, +{ 10: } 55, +{ 11: } 57, +{ 12: } 59, +{ 13: } 63, +{ 14: } 65, +{ 15: } 68, +{ 16: } 70, +{ 17: } 70, +{ 18: } 72, +{ 19: } 72, +{ 20: } 73, +{ 21: } 73, +{ 22: } 73, +{ 23: } 73, +{ 24: } 73, +{ 25: } 73, +{ 26: } 73, +{ 27: } 73, +{ 28: } 74, +{ 29: } 74, +{ 30: } 75, +{ 31: } 76, +{ 32: } 76, +{ 33: } 76, +{ 34: } 77, +{ 35: } 77, +{ 36: } 77, +{ 37: } 79, +{ 38: } 79, +{ 39: } 80, +{ 40: } 81, +{ 41: } 81, +{ 42: } 82, +{ 43: } 83, +{ 44: } 84, +{ 45: } 85, +{ 46: } 87, +{ 47: } 89, +{ 48: } 89, +{ 49: } 89, +{ 50: } 89, +{ 51: } 91, +{ 52: } 93, +{ 53: } 94, +{ 54: } 96, +{ 55: } 97, +{ 56: } 97, +{ 57: } 97, +{ 58: } 98, +{ 59: } 99, +{ 60: } 100, +{ 61: } 102, +{ 62: } 103, +{ 63: } 104, +{ 64: } 105, +{ 65: } 106, +{ 66: } 107, +{ 67: } 108, +{ 68: } 109, +{ 69: } 110, +{ 70: } 111, +{ 71: } 112, +{ 72: } 113, +{ 73: } 113, +{ 74: } 113, +{ 75: } 113, +{ 76: } 114, +{ 77: } 115, +{ 78: } 116, +{ 79: } 117, +{ 80: } 118, +{ 81: } 119, +{ 82: } 120, +{ 83: } 121, +{ 84: } 122, +{ 85: } 123, +{ 86: } 124, +{ 87: } 125, +{ 88: } 126, +{ 89: } 127, +{ 90: } 128, +{ 91: } 129, +{ 92: } 130, +{ 93: } 131 +); + +yyth : array [0..yynstates-1] of Integer = ( +{ 0: } 14, +{ 1: } 28, +{ 2: } 30, +{ 3: } 32, +{ 4: } 35, +{ 5: } 38, +{ 6: } 42, +{ 7: } 46, +{ 8: } 50, +{ 9: } 54, +{ 10: } 56, +{ 11: } 58, +{ 12: } 62, +{ 13: } 64, +{ 14: } 67, +{ 15: } 69, +{ 16: } 69, +{ 17: } 71, +{ 18: } 71, +{ 19: } 72, +{ 20: } 72, +{ 21: } 72, +{ 22: } 72, +{ 23: } 72, +{ 24: } 72, +{ 25: } 72, +{ 26: } 72, +{ 27: } 73, +{ 28: } 73, +{ 29: } 74, +{ 30: } 75, +{ 31: } 75, +{ 32: } 75, +{ 33: } 76, +{ 34: } 76, +{ 35: } 76, +{ 36: } 78, +{ 37: } 78, +{ 38: } 79, +{ 39: } 80, +{ 40: } 80, +{ 41: } 81, +{ 42: } 82, +{ 43: } 83, +{ 44: } 84, +{ 45: } 86, +{ 46: } 88, +{ 47: } 88, +{ 48: } 88, +{ 49: } 88, +{ 50: } 90, +{ 51: } 92, +{ 52: } 93, +{ 53: } 95, +{ 54: } 96, +{ 55: } 96, +{ 56: } 96, +{ 57: } 97, +{ 58: } 98, +{ 59: } 99, +{ 60: } 101, +{ 61: } 102, +{ 62: } 103, +{ 63: } 104, +{ 64: } 105, +{ 65: } 106, +{ 66: } 107, +{ 67: } 108, +{ 68: } 109, +{ 69: } 110, +{ 70: } 111, +{ 71: } 112, +{ 72: } 112, +{ 73: } 112, +{ 74: } 112, +{ 75: } 113, +{ 76: } 114, +{ 77: } 115, +{ 78: } 116, +{ 79: } 117, +{ 80: } 118, +{ 81: } 119, +{ 82: } 120, +{ 83: } 121, +{ 84: } 122, +{ 85: } 123, +{ 86: } 124, +{ 87: } 125, +{ 88: } 126, +{ 89: } 127, +{ 90: } 128, +{ 91: } 129, +{ 92: } 130, +{ 93: } 131 +); + + +var yyn : Integer; + +label start, scan, action; + +begin + +start: + + (* initialize: *) + + yynew; + +scan: + + (* mark positions and matches: *) + + for yyn := yykl[yystate] to yykh[yystate] do yymark(yyk[yyn]); + for yyn := yymh[yystate] downto yyml[yystate] do yymatch(yym[yyn]); + + if yytl[yystate]>yyth[yystate] then goto action; (* dead state *) + + (* get next character: *) + + yyscan; + + (* determine action: *) + + yyn := yytl[yystate]; + while (yyn<=yyth[yystate]) and not (yyactchar in yyt[yyn].cc) do inc(yyn); + if yyn>yyth[yystate] then goto action; + (* no transition on yyactchar in this state *) + + (* switch to new state: *) + + yystate := yyt[yyn].s; + + goto scan; + +action: + + (* execute action: *) + + if yyfind(yyrule) then + begin + yyaction(yyrule); + if yyreject then goto action; + end + else if not yydefault and yywrap() then + begin + yyclear; + return(0); + end; + + if not yydone then goto start; + + yylex := yyretval; + +end(*yylex*); + + + +// end. + + + + + diff --git a/packages/fcl-res/src/rclex.l b/packages/fcl-res/src/rclex.l new file mode 100644 index 0000000000..be7bc7af29 --- /dev/null +++ b/packages/fcl-res/src/rclex.l @@ -0,0 +1,121 @@ +%{ +var + kwtmp: integer; + +const + KeywordDefs: array [0..33] of TIdentMapEntry = ( + // attribs + (Value: _LANGUAGE; Name: 'LANGUAGE'), + (Value: _CHARACTERISTICS; Name: 'CHARACTERISTICS'), + (Value: _VERSION; Name: 'VERSION'), + (Value: _MOVEABLE; Name: 'MOVEABLE'), + (Value: _FIXED; Name: 'FIXED'), + (Value: _PURE; Name: 'PURE'), + (Value: _IMPURE; Name: 'IMPURE'), + (Value: _PRELOAD; Name: 'PRELOAD'), + (Value: _LOADONCALL; Name: 'LOADONCALL'), + (Value: _DISCARDABLE; Name: 'DISCARDABLE'), + // resource names + (Value: _ANICURSOR; Name: 'ANICURSOR'), + (Value: _ANIICON; Name: 'ANIICON'), + (Value: _BITMAP; Name: 'BITMAP'), + (Value: _CURSOR; Name: 'CURSOR'), + (Value: _DLGINCLUDE; Name: 'DLGINCLUDE'), + (Value: _DLGINIT; Name: 'DLGINIT'), + (Value: _HTML; Name: 'HTML'), + (Value: _ICON; Name: 'ICON'), + (Value: _MANIFEST; Name: 'MANIFEST'), + (Value: _MESSAGETABLE; Name: 'MESSAGETABLE'), + (Value: _PLUGPLAY; Name: 'PLUGPLAY'), + (Value: _STRINGTABLE; Name: 'STRINGTABLE'), + (Value: _RCDATA; Name: 'RCDATA'), + (Value: _VERSIONINFO; Name: 'VERSIONINFO'), + (Value: _VXD; Name: 'VXD'), + // file version fields names + (Value: _FILEVERSION; Name: 'FILEVERSION'), + (Value: _PRODUCTVERSION; Name: 'PRODUCTVERSION'), + (Value: _FILEFLAGSMASK; Name: 'FILEFLAGSMASK'), + (Value: _FILEFLAGS; Name: 'FILEFLAGS'), + (Value: _FILEOS; Name: 'FILEOS'), + (Value: _FILETYPE; Name: 'FILETYPE'), + (Value: _FILESUBTYPE; Name: 'FILESUBTYPE'), + (Value: _BLOCK; Name: 'BLOCK'), + (Value: _VALUE; Name: 'VALUE') + ); + +function KeywordToInt(k: string; out kw: integer): boolean; +var + i: integer; +begin + Result:= False; + for i:= low(KeywordDefs) to high(KeywordDefs) do begin + if k = KeywordDefs[i].Name then begin + kw:= KeywordDefs[i].Value; + Exit(True); + end; + end; +end; + +%} +%x INCOMLINE INCOMMENT INSTRING INSTRINGL + +O [0-7] +D [0-9] +H [0-9a-fA-F] +IDENT [a-zA-Z_]([a-zA-Z0-9_])* + +%% + +"//" start(INCOMLINE); +\n begin start(0); unget_char(nl); end; +. yymore; + +"/*" start(INCOMMENT); +. ; +"*/" start(0); +\0 return(_ILLEGAL); + +{D}+L? return(_NUMBER); +0x{H}+L? return(_NUMBER); +0o{O}+L? return(_NUMBER); +L\" begin start(INSTRINGL); strbuf_begin(); end; +\" begin start(INSTRING); strbuf_begin(); end; +\"\" strbuf_append('"'); +\" begin + start(0); + return(_QUOTEDSTR); + end; +\" begin + start(0); + return(_QUOTEDSTRL); + end; +\\\n ; +\n return(_ILLEGAL); +. strbuf_append(yytext); +\"StringFileInfo\" begin yytext:= 'StringFileInfo'; return(_STR_StringFileInfo); end; +\"VarFileInfo\" begin yytext:= 'VarFileInfo'; return(_STR_VarFileInfo); end; +\"Translation\" begin yytext:= 'Translation'; return(_STR_Translation); end; + +BEGIN|{ return(_BEGIN); +END|} return(_END); +{IDENT} begin + if ypreproc.isdefine(yytext) then begin + unget_char(' '); + unget_string(ypreproc.getdefine(yytext)); + end else + if KeywordToInt(yytext, kwtmp) then + return(kwtmp) + else + return(_ID); + end; +[ \t\n\f] ; +[,()|^&+-*/%~] returnc(yytext[1]); +. return(_ILLEGAL); +%% + +// end. + + + + + diff --git a/packages/fcl-res/src/rcparser.pas b/packages/fcl-res/src/rcparser.pas new file mode 100644 index 0000000000..36d30c8a27 --- /dev/null +++ b/packages/fcl-res/src/rcparser.pas @@ -0,0 +1,2747 @@ + +(* Yacc parser template (TP Yacc V3.0), V1.2 6-17-91 AG *) + +(* global definitions: *) + +(* +Vorspann + ****************************************************************************) + +unit rcparser; + +{$I rcparserfn.inc} + +const _ILLEGAL = 257; +const _NUMBER = 258; +const _QUOTEDSTR = 259; +const _QUOTEDSTRL = 260; +const _STR_StringFileInfo = 261; +const _STR_VarFileInfo = 262; +const _STR_Translation = 263; +const _BEGIN = 264; +const _END = 265; +const _ID = 266; +const _LANGUAGE = 267; +const _CHARACTERISTICS = 268; +const _VERSION = 269; +const _MOVEABLE = 270; +const _FIXED = 271; +const _PURE = 272; +const _IMPURE = 273; +const _PRELOAD = 274; +const _LOADONCALL = 275; +const _DISCARDABLE = 276; +const _BITMAP = 277; +const _CURSOR = 278; +const _ICON = 279; +const _STRINGTABLE = 280; +const _VERSIONINFO = 281; +const _ANICURSOR = 282; +const _ANIICON = 283; +const _DLGINCLUDE = 284; +const _DLGINIT = 285; +const _HTML = 286; +const _MANIFEST = 287; +const _MESSAGETABLE = 288; +const _PLUGPLAY = 289; +const _RCDATA = 290; +const _VXD = 291; +const _FILEVERSION = 292; +const _PRODUCTVERSION = 293; +const _FILEFLAGSMASK = 294; +const _FILEFLAGS = 295; +const _FILEOS = 296; +const _FILETYPE = 297; +const _FILESUBTYPE = 298; +const _BLOCK = 299; +const _VALUE = 300; +const _ACCELERATORS = 301; +const _DIALOG = 302; +const _DIALOGEX = 303; +const _MENU = 304; +const _MENUEX = 305; +const _NUMNEG = 306; + +type YYSType = record case Integer of + 1 : ( yyTFileStream : TFileStream ); + 2 : ( yyTMemoryStream : TMemoryStream ); + 3 : ( yyTResourceDesc : TResourceDesc ); + 4 : ( yyrcnumtype : rcnumtype ); + 5 : ( yyrcstrtype : rcstrtype ); + end(*YYSType*); + +var yylval : YYSType; + +function yylex : Integer; forward; + +function yyparse : Integer; + +var yystate, yysp, yyn : Integer; + yys : array [1..yymaxdepth] of Integer; + yyv : array [1..yymaxdepth] of YYSType; + yyval : YYSType; + +procedure yyaction ( yyruleno : Integer ); + (* local definitions: *) +begin + (* actions: *) + case yyruleno of + 1 : begin + end; + 2 : begin + yyval := yyv[yysp-1]; + end; + 3 : begin + yyval := yyv[yysp-0]; + end; + 4 : begin + yyval := yyv[yysp-0]; + end; + 5 : begin + yyval := yyv[yysp-0]; + end; + 6 : begin + yyval := yyv[yysp-0]; + end; + 7 : begin + yyval := yyv[yysp-0]; + end; + 8 : begin + yyval := yyv[yysp-0]; + end; + 9 : begin + yyval := yyv[yysp-0]; + end; + 10 : begin + yyval := yyv[yysp-0]; + end; + 11 : begin + create_resource(yyv[yysp-1].yyTResourceDesc, RT_BITMAP); + end; + 12 : begin + TBitmapResource(aktresource).SetCustomBitmapDataStream(yyv[yysp-0].yyTFileStream); + end; + 13 : begin + create_resource(yyv[yysp-1].yyTResourceDesc, RT_CURSOR); + end; + 14 : begin + TGroupCursorResource(aktresource).SetCustomItemDataStream(yyv[yysp-0].yyTFileStream); + end; + 15 : begin + create_resource(yyv[yysp-1].yyTResourceDesc, RT_ICON); + end; + 16 : begin + TGroupIconResource(aktresource).SetCustomItemDataStream(yyv[yysp-0].yyTFileStream); + end; + 17 : begin + create_resource(yyv[yysp-1].yyTResourceDesc, RT_VERSION); + end; + 18 : begin + yyval := yyv[yysp-6]; + end; + 19 : begin + end; + 20 : begin + TVersionResource(aktresource).FixedInfo.FileVersion:= make_version(yyv[yysp-6].yyrcnumtype.v, yyv[yysp-4].yyrcnumtype.v, yyv[yysp-2].yyrcnumtype.v, yyv[yysp-0].yyrcnumtype.v); + end; + 21 : begin + TVersionResource(aktresource).FixedInfo.ProductVersion:= make_version(yyv[yysp-6].yyrcnumtype.v, yyv[yysp-4].yyrcnumtype.v, yyv[yysp-2].yyrcnumtype.v, yyv[yysp-0].yyrcnumtype.v); + end; + 22 : begin + TVersionResource(aktresource).FixedInfo.FileFlagsMask:= yyv[yysp-0].yyrcnumtype.v; + end; + 23 : begin + TVersionResource(aktresource).FixedInfo.FileFlags:= yyv[yysp-0].yyrcnumtype.v; + end; + 24 : begin + TVersionResource(aktresource).FixedInfo.FileOS:= yyv[yysp-0].yyrcnumtype.v; + end; + 25 : begin + TVersionResource(aktresource).FixedInfo.FileType:= yyv[yysp-0].yyrcnumtype.v; + end; + 26 : begin + TVersionResource(aktresource).FixedInfo.FileSubType:= yyv[yysp-0].yyrcnumtype.v; + end; + 27 : begin + end; + 28 : begin + yyval := yyv[yysp-5]; + end; + 29 : begin + yyval := yyv[yysp-5]; + end; + 30 : begin + end; + 31 : begin + version_string_tab_begin(yyv[yysp-1].yyrcstrtype.v^); + end; + 32 : begin + yyval := yyv[yysp-6]; + end; + 33 : begin + end; + 34 : begin + version_string_tab_add(yyv[yysp-2].yyrcstrtype.v^, yyv[yysp-0].yyrcstrtype.v^); + end; + 35 : begin + yyval := yyv[yysp-3]; + end; + 36 : begin + version_var_translation_add(yyv[yysp-2].yyrcnumtype.v, yyv[yysp-0].yyrcnumtype.v); + end; + 37 : begin + version_var_translation_add(yyv[yysp-2].yyrcnumtype.v, yyv[yysp-0].yyrcnumtype.v); + end; + 38 : begin + create_resource(yyv[yysp-1].yyTResourceDesc, yyv[yysp-0].yyTResourceDesc); + end; + 39 : begin + aktresource.SetCustomRawDataStream(yyv[yysp-0].yyTFileStream); + end; + 40 : begin + create_resource(yyv[yysp-1].yyTResourceDesc, yyv[yysp-0].yyTResourceDesc); + end; + 41 : begin + aktresource.SetCustomRawDataStream(yyv[yysp-1].yyTMemoryStream); + end; + 42 : begin + stringtable_begin(); + end; + 43 : begin + stringtable_end(); + end; + 44 : begin + end; + 45 : begin + yyval := yyv[yysp-1]; + end; + 46 : begin + stringtable_add(yyv[yysp-2].yyrcnumtype.v, yyv[yysp-0].yyrcstrtype.v^); + end; + 47 : begin + stringtable_add(yyv[yysp-1].yyrcnumtype.v, yyv[yysp-0].yyrcstrtype.v^); + end; + 48 : begin + yyval.yyTResourceDesc:= TResourceDesc.Create(RT_ANICURSOR); + end; + 49 : begin + yyval.yyTResourceDesc:= TResourceDesc.Create(RT_ANIICON); + end; + 50 : begin + yyval.yyTResourceDesc:= TResourceDesc.Create(RT_DLGINCLUDE); + end; + 51 : begin + yyval.yyTResourceDesc:= TResourceDesc.Create(RT_DLGINIT); + end; + 52 : begin + yyval.yyTResourceDesc:= TResourceDesc.Create(23); + end; + 53 : begin + yyval.yyTResourceDesc:= TResourceDesc.Create(RT_MANIFEST); + end; + 54 : begin + yyval.yyTResourceDesc:= TResourceDesc.Create(RT_MESSAGETABLE); + end; + 55 : begin + yyval.yyTResourceDesc:= TResourceDesc.Create(RT_PLUGPLAY); + end; + 56 : begin + yyval.yyTResourceDesc:= TResourceDesc.Create(RT_RCDATA); + end; + 57 : begin + yyval.yyTResourceDesc:= TResourceDesc.Create(RT_VXD); + end; + 58 : begin + yyval := yyv[yysp-0]; + end; + 59 : begin + yyval.yyTResourceDesc:= TResourceDesc.Create(yyv[yysp-0].yyrcnumtype.v); + end; + 60 : begin + yyval.yyTResourceDesc:= TResourceDesc.Create(yyv[yysp-0].yyrcstrtype.v^); + end; + 61 : begin + end; + 62 : begin + yyval := yyv[yysp-1]; + end; + 63 : begin + change_lang_id(MakeLangID(yyv[yysp-2].yyrcnumtype.v, yyv[yysp-0].yyrcnumtype.v)); + end; + 64 : begin + aktresource.Characteristics:= yyv[yysp-0].yyrcnumtype.v; + end; + 65 : begin + aktresource.Version:= yyv[yysp-0].yyrcnumtype.v; + end; + 66 : begin + aktresource.MemoryFlags:= aktresource.MemoryFlags or MF_MOVEABLE; + end; + 67 : begin + aktresource.MemoryFlags:= aktresource.MemoryFlags and not MF_MOVEABLE; + end; + 68 : begin + aktresource.MemoryFlags:= aktresource.MemoryFlags or MF_PURE; + end; + 69 : begin + aktresource.MemoryFlags:= aktresource.MemoryFlags and not MF_PURE; + end; + 70 : begin + aktresource.MemoryFlags:= aktresource.MemoryFlags or MF_PRELOAD; + end; + 71 : begin + aktresource.MemoryFlags:= aktresource.MemoryFlags and not MF_PRELOAD; + end; + 72 : begin + aktresource.MemoryFlags:= aktresource.MemoryFlags or MF_DISCARDABLE; + end; + 73 : begin + language:= MakeLangID(yyv[yysp-2].yyrcnumtype.v, yyv[yysp-0].yyrcnumtype.v); + end; + 74 : begin + yyval := yyv[yysp-0]; + end; + 75 : begin + yyval.yyrcnumtype:= str_to_num(yytext); + end; + 76 : begin + yyval := yyv[yysp-0]; + end; + 77 : begin + yyval.yyrcnumtype:= yyv[yysp-1].yyrcnumtype; + end; + 78 : begin + yyval.yyrcnumtype.v:= not yyv[yysp-0].yyrcnumtype.v; yyval.yyrcnumtype.long:= yyv[yysp-0].yyrcnumtype.long; + end; + 79 : begin + yyval.yyrcnumtype.v:= -yyv[yysp-0].yyrcnumtype.v; yyval.yyrcnumtype.long:= yyv[yysp-0].yyrcnumtype.long; + end; + 80 : begin + yyval.yyrcnumtype.v:= yyv[yysp-2].yyrcnumtype.v * yyv[yysp-0].yyrcnumtype.v; yyval.yyrcnumtype.long:= yyv[yysp-2].yyrcnumtype.long or yyv[yysp-0].yyrcnumtype.long; + end; + 81 : begin + yyval.yyrcnumtype.v:= yyv[yysp-2].yyrcnumtype.v div Max(1, yyv[yysp-0].yyrcnumtype.v); yyval.yyrcnumtype.long:= yyv[yysp-2].yyrcnumtype.long or yyv[yysp-0].yyrcnumtype.long; + end; + 82 : begin + yyval.yyrcnumtype.v:= yyv[yysp-2].yyrcnumtype.v mod Max(1, yyv[yysp-0].yyrcnumtype.v); yyval.yyrcnumtype.long:= yyv[yysp-2].yyrcnumtype.long or yyv[yysp-0].yyrcnumtype.long; + end; + 83 : begin + yyval.yyrcnumtype.v:= yyv[yysp-2].yyrcnumtype.v + yyv[yysp-0].yyrcnumtype.v; yyval.yyrcnumtype.long:= yyv[yysp-2].yyrcnumtype.long or yyv[yysp-0].yyrcnumtype.long; + end; + 84 : begin + yyval.yyrcnumtype.v:= yyv[yysp-2].yyrcnumtype.v - yyv[yysp-0].yyrcnumtype.v; yyval.yyrcnumtype.long:= yyv[yysp-2].yyrcnumtype.long or yyv[yysp-0].yyrcnumtype.long; + end; + 85 : begin + yyval.yyrcnumtype.v:= yyv[yysp-2].yyrcnumtype.v and yyv[yysp-0].yyrcnumtype.v; yyval.yyrcnumtype.long:= yyv[yysp-2].yyrcnumtype.long or yyv[yysp-0].yyrcnumtype.long; + end; + 86 : begin + yyval.yyrcnumtype.v:= yyv[yysp-2].yyrcnumtype.v xor yyv[yysp-0].yyrcnumtype.v; yyval.yyrcnumtype.long:= yyv[yysp-2].yyrcnumtype.long or yyv[yysp-0].yyrcnumtype.long; + end; + 87 : begin + yyval.yyrcnumtype.v:= yyv[yysp-2].yyrcnumtype.v or yyv[yysp-0].yyrcnumtype.v; yyval.yyrcnumtype.long:= yyv[yysp-2].yyrcnumtype.long or yyv[yysp-0].yyrcnumtype.long; + end; + 88 : begin + string_new(yyval.yyrcstrtype, yytext, opt_code_page); + end; + 89 : begin + yyval := yyv[yysp-0]; + end; + 90 : begin + yyval.yyTFileStream:= TFileStream.Create(ExpandFileName(yyv[yysp-0].yyrcstrtype.v^), fmOpenRead or fmShareDenyWrite); + end; + 91 : begin + string_new_uni(yyval.yyrcstrtype, @strbuf[0], strbuflen, opt_code_page, true); + end; + 92 : begin + string_new_uni(yyval.yyrcstrtype, @strbuf[0], strbuflen, CP_UTF16, true); + end; + 93 : begin + string_new(yyval.yyrcstrtype, yytext, opt_code_page); + end; + 94 : begin + string_new(yyval.yyrcstrtype, yytext, opt_code_page); + end; + 95 : begin + string_new(yyval.yyrcstrtype, yytext, opt_code_page); + end; + 96 : begin + yyval.yyTMemoryStream:= TMemoryStream.Create; + end; + 97 : begin + yyval := yyv[yysp-1]; + end; + 98 : begin + yyval.yyTMemoryStream:= yyv[yysp-1].yyTMemoryStream; + end; + 99 : begin + yyval := yyv[yysp-3]; + end; + 100 : begin + + yyval.yyTMemoryStream:= yyv[yysp-0].yyTMemoryStream; + + end; + 101 : begin + + yyval.yyTMemoryStream:= yyv[yysp-1].yyTMemoryStream; + raw_write_string(yyval.yyTMemoryStream, yyv[yysp-0].yyrcstrtype); + + end; + 102 : begin + + yyval.yyTMemoryStream:= yyv[yysp-1].yyTMemoryStream; + raw_write_int(yyval.yyTMemoryStream, yyv[yysp-0].yyrcnumtype); + + end; + end; +end(*yyaction*); + +(* parse table: *) + +type YYARec = record + sym, act : Integer; + end; + YYRRec = record + len, sym : Integer; + end; + +const + +yynacts = 643; +yyngotos = 141; +yynstates = 180; +yynrules = 102; + +yya : array [1..yynacts] of YYARec = ( +{ 0: } +{ 1: } + ( sym: 0; act: 0 ), + ( sym: 40; act: 17 ), + ( sym: 45; act: 18 ), + ( sym: 126; act: 19 ), + ( sym: 258; act: 20 ), + ( sym: 259; act: 21 ), + ( sym: 260; act: 22 ), + ( sym: 261; act: 23 ), + ( sym: 262; act: 24 ), + ( sym: 263; act: 25 ), + ( sym: 266; act: 26 ), + ( sym: 267; act: 27 ), + ( sym: 280; act: 28 ), +{ 2: } +{ 3: } +{ 4: } +{ 5: } +{ 6: } +{ 7: } +{ 8: } +{ 9: } +{ 10: } +{ 11: } + ( sym: 40; act: 17 ), + ( sym: 45; act: 18 ), + ( sym: 126; act: 19 ), + ( sym: 258; act: 20 ), + ( sym: 259; act: 21 ), + ( sym: 260; act: 22 ), + ( sym: 261; act: 23 ), + ( sym: 262; act: 24 ), + ( sym: 263; act: 25 ), + ( sym: 266; act: 26 ), + ( sym: 277; act: 31 ), + ( sym: 278; act: 32 ), + ( sym: 279; act: 33 ), + ( sym: 281; act: 34 ), + ( sym: 282; act: 35 ), + ( sym: 283; act: 36 ), + ( sym: 284; act: 37 ), + ( sym: 285; act: 38 ), + ( sym: 286; act: 39 ), + ( sym: 287; act: 40 ), + ( sym: 288; act: 41 ), + ( sym: 289; act: 42 ), + ( sym: 290; act: 43 ), + ( sym: 291; act: 44 ), +{ 12: } +{ 13: } +{ 14: } +{ 15: } + ( sym: 37; act: 45 ), + ( sym: 38; act: 46 ), + ( sym: 42; act: 47 ), + ( sym: 43; act: 48 ), + ( sym: 45; act: 49 ), + ( sym: 47; act: 50 ), + ( sym: 94; act: 51 ), + ( sym: 124; act: 52 ), + ( sym: 0; act: -74 ), + ( sym: 40; act: -74 ), + ( sym: 44; act: -74 ), + ( sym: 126; act: -74 ), + ( sym: 258; act: -74 ), + ( sym: 259; act: -74 ), + ( sym: 260; act: -74 ), + ( sym: 261; act: -74 ), + ( sym: 262; act: -74 ), + ( sym: 263; act: -74 ), + ( sym: 264; act: -74 ), + ( sym: 266; act: -74 ), + ( sym: 267; act: -74 ), + ( sym: 268; act: -74 ), + ( sym: 269; act: -74 ), + ( sym: 270; act: -74 ), + ( sym: 271; act: -74 ), + ( sym: 272; act: -74 ), + ( sym: 273; act: -74 ), + ( sym: 274; act: -74 ), + ( sym: 275; act: -74 ), + ( sym: 276; act: -74 ), + ( sym: 277; act: -74 ), + ( sym: 278; act: -74 ), + ( sym: 279; act: -74 ), + ( sym: 280; act: -74 ), + ( sym: 281; act: -74 ), + ( sym: 282; act: -74 ), + ( sym: 283; act: -74 ), + ( sym: 284; act: -74 ), + ( sym: 285; act: -74 ), + ( sym: 286; act: -74 ), + ( sym: 287; act: -74 ), + ( sym: 288; act: -74 ), + ( sym: 289; act: -74 ), + ( sym: 290; act: -74 ), + ( sym: 291; act: -74 ), + ( sym: 292; act: -74 ), + ( sym: 293; act: -74 ), + ( sym: 294; act: -74 ), + ( sym: 295; act: -74 ), + ( sym: 296; act: -74 ), + ( sym: 297; act: -74 ), + ( sym: 298; act: -74 ), +{ 16: } +{ 17: } + ( sym: 40; act: 17 ), + ( sym: 45; act: 18 ), + ( sym: 126; act: 19 ), + ( sym: 258; act: 20 ), +{ 18: } + ( sym: 40; act: 17 ), + ( sym: 45; act: 18 ), + ( sym: 126; act: 19 ), + ( sym: 258; act: 20 ), +{ 19: } + ( sym: 40; act: 17 ), + ( sym: 45; act: 18 ), + ( sym: 126; act: 19 ), + ( sym: 258; act: 20 ), +{ 20: } +{ 21: } +{ 22: } +{ 23: } +{ 24: } +{ 25: } +{ 26: } +{ 27: } + ( sym: 40; act: 17 ), + ( sym: 45; act: 18 ), + ( sym: 126; act: 19 ), + ( sym: 258; act: 20 ), +{ 28: } +{ 29: } + ( sym: 259; act: -38 ), + ( sym: 260; act: -38 ), + ( sym: 261; act: -38 ), + ( sym: 262; act: -38 ), + ( sym: 263; act: -38 ), + ( sym: 267; act: -38 ), + ( sym: 268; act: -38 ), + ( sym: 269; act: -38 ), + ( sym: 270; act: -38 ), + ( sym: 271; act: -38 ), + ( sym: 272; act: -38 ), + ( sym: 273; act: -38 ), + ( sym: 274; act: -38 ), + ( sym: 275; act: -38 ), + ( sym: 276; act: -38 ), + ( sym: 264; act: -40 ), +{ 30: } +{ 31: } +{ 32: } +{ 33: } +{ 34: } +{ 35: } +{ 36: } +{ 37: } +{ 38: } +{ 39: } +{ 40: } +{ 41: } +{ 42: } +{ 43: } +{ 44: } +{ 45: } + ( sym: 40; act: 17 ), + ( sym: 45; act: 18 ), + ( sym: 126; act: 19 ), + ( sym: 258; act: 20 ), +{ 46: } + ( sym: 40; act: 17 ), + ( sym: 45; act: 18 ), + ( sym: 126; act: 19 ), + ( sym: 258; act: 20 ), +{ 47: } + ( sym: 40; act: 17 ), + ( sym: 45; act: 18 ), + ( sym: 126; act: 19 ), + ( sym: 258; act: 20 ), +{ 48: } + ( sym: 40; act: 17 ), + ( sym: 45; act: 18 ), + ( sym: 126; act: 19 ), + ( sym: 258; act: 20 ), +{ 49: } + ( sym: 40; act: 17 ), + ( sym: 45; act: 18 ), + ( sym: 126; act: 19 ), + ( sym: 258; act: 20 ), +{ 50: } + ( sym: 40; act: 17 ), + ( sym: 45; act: 18 ), + ( sym: 126; act: 19 ), + ( sym: 258; act: 20 ), +{ 51: } + ( sym: 40; act: 17 ), + ( sym: 45; act: 18 ), + ( sym: 126; act: 19 ), + ( sym: 258; act: 20 ), +{ 52: } + ( sym: 40; act: 17 ), + ( sym: 45; act: 18 ), + ( sym: 126; act: 19 ), + ( sym: 258; act: 20 ), +{ 53: } + ( sym: 37; act: 45 ), + ( sym: 38; act: 46 ), + ( sym: 41; act: 72 ), + ( sym: 42; act: 47 ), + ( sym: 43; act: 48 ), + ( sym: 45; act: 49 ), + ( sym: 47; act: 50 ), + ( sym: 94; act: 51 ), + ( sym: 124; act: 52 ), +{ 54: } +{ 55: } +{ 56: } + ( sym: 44; act: 73 ), +{ 57: } +{ 58: } +{ 59: } +{ 60: } +{ 61: } +{ 62: } +{ 63: } +{ 64: } +{ 65: } + ( sym: 37; act: 45 ), + ( sym: 42; act: 47 ), + ( sym: 43; act: 48 ), + ( sym: 45; act: 49 ), + ( sym: 47; act: 50 ), + ( sym: 0; act: -85 ), + ( sym: 38; act: -85 ), + ( sym: 40; act: -85 ), + ( sym: 41; act: -85 ), + ( sym: 44; act: -85 ), + ( sym: 94; act: -85 ), + ( sym: 124; act: -85 ), + ( sym: 126; act: -85 ), + ( sym: 258; act: -85 ), + ( sym: 259; act: -85 ), + ( sym: 260; act: -85 ), + ( sym: 261; act: -85 ), + ( sym: 262; act: -85 ), + ( sym: 263; act: -85 ), + ( sym: 264; act: -85 ), + ( sym: 266; act: -85 ), + ( sym: 267; act: -85 ), + ( sym: 268; act: -85 ), + ( sym: 269; act: -85 ), + ( sym: 270; act: -85 ), + ( sym: 271; act: -85 ), + ( sym: 272; act: -85 ), + ( sym: 273; act: -85 ), + ( sym: 274; act: -85 ), + ( sym: 275; act: -85 ), + ( sym: 276; act: -85 ), + ( sym: 277; act: -85 ), + ( sym: 278; act: -85 ), + ( sym: 279; act: -85 ), + ( sym: 280; act: -85 ), + ( sym: 281; act: -85 ), + ( sym: 282; act: -85 ), + ( sym: 283; act: -85 ), + ( sym: 284; act: -85 ), + ( sym: 285; act: -85 ), + ( sym: 286; act: -85 ), + ( sym: 287; act: -85 ), + ( sym: 288; act: -85 ), + ( sym: 289; act: -85 ), + ( sym: 290; act: -85 ), + ( sym: 291; act: -85 ), + ( sym: 292; act: -85 ), + ( sym: 293; act: -85 ), + ( sym: 294; act: -85 ), + ( sym: 295; act: -85 ), + ( sym: 296; act: -85 ), + ( sym: 297; act: -85 ), + ( sym: 298; act: -85 ), +{ 66: } +{ 67: } + ( sym: 37; act: 45 ), + ( sym: 42; act: 47 ), + ( sym: 47; act: 50 ), + ( sym: 0; act: -83 ), + ( sym: 38; act: -83 ), + ( sym: 40; act: -83 ), + ( sym: 41; act: -83 ), + ( sym: 43; act: -83 ), + ( sym: 44; act: -83 ), + ( sym: 45; act: -83 ), + ( sym: 94; act: -83 ), + ( sym: 124; act: -83 ), + ( sym: 126; act: -83 ), + ( sym: 258; act: -83 ), + ( sym: 259; act: -83 ), + ( sym: 260; act: -83 ), + ( sym: 261; act: -83 ), + ( sym: 262; act: -83 ), + ( sym: 263; act: -83 ), + ( sym: 264; act: -83 ), + ( sym: 266; act: -83 ), + ( sym: 267; act: -83 ), + ( sym: 268; act: -83 ), + ( sym: 269; act: -83 ), + ( sym: 270; act: -83 ), + ( sym: 271; act: -83 ), + ( sym: 272; act: -83 ), + ( sym: 273; act: -83 ), + ( sym: 274; act: -83 ), + ( sym: 275; act: -83 ), + ( sym: 276; act: -83 ), + ( sym: 277; act: -83 ), + ( sym: 278; act: -83 ), + ( sym: 279; act: -83 ), + ( sym: 280; act: -83 ), + ( sym: 281; act: -83 ), + ( sym: 282; act: -83 ), + ( sym: 283; act: -83 ), + ( sym: 284; act: -83 ), + ( sym: 285; act: -83 ), + ( sym: 286; act: -83 ), + ( sym: 287; act: -83 ), + ( sym: 288; act: -83 ), + ( sym: 289; act: -83 ), + ( sym: 290; act: -83 ), + ( sym: 291; act: -83 ), + ( sym: 292; act: -83 ), + ( sym: 293; act: -83 ), + ( sym: 294; act: -83 ), + ( sym: 295; act: -83 ), + ( sym: 296; act: -83 ), + ( sym: 297; act: -83 ), + ( sym: 298; act: -83 ), +{ 68: } + ( sym: 37; act: 45 ), + ( sym: 42; act: 47 ), + ( sym: 47; act: 50 ), + ( sym: 0; act: -84 ), + ( sym: 38; act: -84 ), + ( sym: 40; act: -84 ), + ( sym: 41; act: -84 ), + ( sym: 43; act: -84 ), + ( sym: 44; act: -84 ), + ( sym: 45; act: -84 ), + ( sym: 94; act: -84 ), + ( sym: 124; act: -84 ), + ( sym: 126; act: -84 ), + ( sym: 258; act: -84 ), + ( sym: 259; act: -84 ), + ( sym: 260; act: -84 ), + ( sym: 261; act: -84 ), + ( sym: 262; act: -84 ), + ( sym: 263; act: -84 ), + ( sym: 264; act: -84 ), + ( sym: 266; act: -84 ), + ( sym: 267; act: -84 ), + ( sym: 268; act: -84 ), + ( sym: 269; act: -84 ), + ( sym: 270; act: -84 ), + ( sym: 271; act: -84 ), + ( sym: 272; act: -84 ), + ( sym: 273; act: -84 ), + ( sym: 274; act: -84 ), + ( sym: 275; act: -84 ), + ( sym: 276; act: -84 ), + ( sym: 277; act: -84 ), + ( sym: 278; act: -84 ), + ( sym: 279; act: -84 ), + ( sym: 280; act: -84 ), + ( sym: 281; act: -84 ), + ( sym: 282; act: -84 ), + ( sym: 283; act: -84 ), + ( sym: 284; act: -84 ), + ( sym: 285; act: -84 ), + ( sym: 286; act: -84 ), + ( sym: 287; act: -84 ), + ( sym: 288; act: -84 ), + ( sym: 289; act: -84 ), + ( sym: 290; act: -84 ), + ( sym: 291; act: -84 ), + ( sym: 292; act: -84 ), + ( sym: 293; act: -84 ), + ( sym: 294; act: -84 ), + ( sym: 295; act: -84 ), + ( sym: 296; act: -84 ), + ( sym: 297; act: -84 ), + ( sym: 298; act: -84 ), +{ 69: } +{ 70: } + ( sym: 37; act: 45 ), + ( sym: 38; act: 46 ), + ( sym: 42; act: 47 ), + ( sym: 43; act: 48 ), + ( sym: 45; act: 49 ), + ( sym: 47; act: 50 ), + ( sym: 0; act: -86 ), + ( sym: 40; act: -86 ), + ( sym: 41; act: -86 ), + ( sym: 44; act: -86 ), + ( sym: 94; act: -86 ), + ( sym: 124; act: -86 ), + ( sym: 126; act: -86 ), + ( sym: 258; act: -86 ), + ( sym: 259; act: -86 ), + ( sym: 260; act: -86 ), + ( sym: 261; act: -86 ), + ( sym: 262; act: -86 ), + ( sym: 263; act: -86 ), + ( sym: 264; act: -86 ), + ( sym: 266; act: -86 ), + ( sym: 267; act: -86 ), + ( sym: 268; act: -86 ), + ( sym: 269; act: -86 ), + ( sym: 270; act: -86 ), + ( sym: 271; act: -86 ), + ( sym: 272; act: -86 ), + ( sym: 273; act: -86 ), + ( sym: 274; act: -86 ), + ( sym: 275; act: -86 ), + ( sym: 276; act: -86 ), + ( sym: 277; act: -86 ), + ( sym: 278; act: -86 ), + ( sym: 279; act: -86 ), + ( sym: 280; act: -86 ), + ( sym: 281; act: -86 ), + ( sym: 282; act: -86 ), + ( sym: 283; act: -86 ), + ( sym: 284; act: -86 ), + ( sym: 285; act: -86 ), + ( sym: 286; act: -86 ), + ( sym: 287; act: -86 ), + ( sym: 288; act: -86 ), + ( sym: 289; act: -86 ), + ( sym: 290; act: -86 ), + ( sym: 291; act: -86 ), + ( sym: 292; act: -86 ), + ( sym: 293; act: -86 ), + ( sym: 294; act: -86 ), + ( sym: 295; act: -86 ), + ( sym: 296; act: -86 ), + ( sym: 297; act: -86 ), + ( sym: 298; act: -86 ), +{ 71: } + ( sym: 37; act: 45 ), + ( sym: 38; act: 46 ), + ( sym: 42; act: 47 ), + ( sym: 43; act: 48 ), + ( sym: 45; act: 49 ), + ( sym: 47; act: 50 ), + ( sym: 94; act: 51 ), + ( sym: 0; act: -87 ), + ( sym: 40; act: -87 ), + ( sym: 41; act: -87 ), + ( sym: 44; act: -87 ), + ( sym: 124; act: -87 ), + ( sym: 126; act: -87 ), + ( sym: 258; act: -87 ), + ( sym: 259; act: -87 ), + ( sym: 260; act: -87 ), + ( sym: 261; act: -87 ), + ( sym: 262; act: -87 ), + ( sym: 263; act: -87 ), + ( sym: 264; act: -87 ), + ( sym: 266; act: -87 ), + ( sym: 267; act: -87 ), + ( sym: 268; act: -87 ), + ( sym: 269; act: -87 ), + ( sym: 270; act: -87 ), + ( sym: 271; act: -87 ), + ( sym: 272; act: -87 ), + ( sym: 273; act: -87 ), + ( sym: 274; act: -87 ), + ( sym: 275; act: -87 ), + ( sym: 276; act: -87 ), + ( sym: 277; act: -87 ), + ( sym: 278; act: -87 ), + ( sym: 279; act: -87 ), + ( sym: 280; act: -87 ), + ( sym: 281; act: -87 ), + ( sym: 282; act: -87 ), + ( sym: 283; act: -87 ), + ( sym: 284; act: -87 ), + ( sym: 285; act: -87 ), + ( sym: 286; act: -87 ), + ( sym: 287; act: -87 ), + ( sym: 288; act: -87 ), + ( sym: 289; act: -87 ), + ( sym: 290; act: -87 ), + ( sym: 291; act: -87 ), + ( sym: 292; act: -87 ), + ( sym: 293; act: -87 ), + ( sym: 294; act: -87 ), + ( sym: 295; act: -87 ), + ( sym: 296; act: -87 ), + ( sym: 297; act: -87 ), + ( sym: 298; act: -87 ), +{ 72: } +{ 73: } + ( sym: 40; act: 17 ), + ( sym: 45; act: 18 ), + ( sym: 126; act: 19 ), + ( sym: 258; act: 20 ), +{ 74: } + ( sym: 264; act: 83 ), + ( sym: 267; act: 84 ), + ( sym: 268; act: 85 ), + ( sym: 269; act: 86 ), + ( sym: 270; act: 87 ), + ( sym: 271; act: 88 ), + ( sym: 272; act: 89 ), + ( sym: 273; act: 90 ), + ( sym: 274; act: 91 ), + ( sym: 275; act: 92 ), + ( sym: 276; act: 93 ), +{ 75: } + ( sym: 264; act: 94 ), + ( sym: 267; act: 84 ), + ( sym: 268; act: 85 ), + ( sym: 269; act: 86 ), + ( sym: 270; act: 87 ), + ( sym: 271; act: 88 ), + ( sym: 272; act: 89 ), + ( sym: 273; act: 90 ), + ( sym: 274; act: 91 ), + ( sym: 275; act: 92 ), + ( sym: 276; act: 93 ), +{ 76: } + ( sym: 259; act: 21 ), + ( sym: 260; act: 22 ), + ( sym: 261; act: 23 ), + ( sym: 262; act: 24 ), + ( sym: 263; act: 25 ), + ( sym: 267; act: 84 ), + ( sym: 268; act: 85 ), + ( sym: 269; act: 86 ), + ( sym: 270; act: 87 ), + ( sym: 271; act: 88 ), + ( sym: 272; act: 89 ), + ( sym: 273; act: 90 ), + ( sym: 274; act: 91 ), + ( sym: 275; act: 92 ), + ( sym: 276; act: 93 ), +{ 77: } + ( sym: 259; act: 21 ), + ( sym: 260; act: 22 ), + ( sym: 261; act: 23 ), + ( sym: 262; act: 24 ), + ( sym: 263; act: 25 ), + ( sym: 267; act: 84 ), + ( sym: 268; act: 85 ), + ( sym: 269; act: 86 ), + ( sym: 270; act: 87 ), + ( sym: 271; act: 88 ), + ( sym: 272; act: 89 ), + ( sym: 273; act: 90 ), + ( sym: 274; act: 91 ), + ( sym: 275; act: 92 ), + ( sym: 276; act: 93 ), +{ 78: } + ( sym: 259; act: 21 ), + ( sym: 260; act: 22 ), + ( sym: 261; act: 23 ), + ( sym: 262; act: 24 ), + ( sym: 263; act: 25 ), + ( sym: 267; act: 84 ), + ( sym: 268; act: 85 ), + ( sym: 269; act: 86 ), + ( sym: 270; act: 87 ), + ( sym: 271; act: 88 ), + ( sym: 272; act: 89 ), + ( sym: 273; act: 90 ), + ( sym: 274; act: 91 ), + ( sym: 275; act: 92 ), + ( sym: 276; act: 93 ), +{ 79: } + ( sym: 259; act: 21 ), + ( sym: 260; act: 22 ), + ( sym: 261; act: 23 ), + ( sym: 262; act: 24 ), + ( sym: 263; act: 25 ), + ( sym: 267; act: 84 ), + ( sym: 268; act: 85 ), + ( sym: 269; act: 86 ), + ( sym: 270; act: 87 ), + ( sym: 271; act: 88 ), + ( sym: 272; act: 89 ), + ( sym: 273; act: 90 ), + ( sym: 274; act: 91 ), + ( sym: 275; act: 92 ), + ( sym: 276; act: 93 ), +{ 80: } + ( sym: 264; act: 100 ), + ( sym: 292; act: 101 ), + ( sym: 293; act: 102 ), + ( sym: 294; act: 103 ), + ( sym: 295; act: 104 ), + ( sym: 296; act: 105 ), + ( sym: 297; act: 106 ), + ( sym: 298; act: 107 ), +{ 81: } +{ 82: } +{ 83: } +{ 84: } + ( sym: 40; act: 17 ), + ( sym: 45; act: 18 ), + ( sym: 126; act: 19 ), + ( sym: 258; act: 20 ), +{ 85: } + ( sym: 40; act: 17 ), + ( sym: 45; act: 18 ), + ( sym: 126; act: 19 ), + ( sym: 258; act: 20 ), +{ 86: } + ( sym: 40; act: 17 ), + ( sym: 45; act: 18 ), + ( sym: 126; act: 19 ), + ( sym: 258; act: 20 ), +{ 87: } +{ 88: } +{ 89: } +{ 90: } +{ 91: } +{ 92: } +{ 93: } +{ 94: } +{ 95: } +{ 96: } +{ 97: } +{ 98: } +{ 99: } +{ 100: } +{ 101: } + ( sym: 258; act: 20 ), +{ 102: } + ( sym: 258; act: 20 ), +{ 103: } + ( sym: 40; act: 17 ), + ( sym: 45; act: 18 ), + ( sym: 126; act: 19 ), + ( sym: 258; act: 20 ), +{ 104: } + ( sym: 40; act: 17 ), + ( sym: 45; act: 18 ), + ( sym: 126; act: 19 ), + ( sym: 258; act: 20 ), +{ 105: } + ( sym: 40; act: 17 ), + ( sym: 45; act: 18 ), + ( sym: 126; act: 19 ), + ( sym: 258; act: 20 ), +{ 106: } + ( sym: 40; act: 17 ), + ( sym: 45; act: 18 ), + ( sym: 126; act: 19 ), + ( sym: 258; act: 20 ), +{ 107: } + ( sym: 40; act: 17 ), + ( sym: 45; act: 18 ), + ( sym: 126; act: 19 ), + ( sym: 258; act: 20 ), +{ 108: } + ( sym: 258; act: 20 ), + ( sym: 265; act: 124 ), +{ 109: } + ( sym: 44; act: 125 ), +{ 110: } +{ 111: } +{ 112: } + ( sym: 258; act: 20 ), + ( sym: 259; act: 21 ), + ( sym: 260; act: 22 ), + ( sym: 261; act: 23 ), + ( sym: 262; act: 24 ), + ( sym: 263; act: 25 ), + ( sym: 44; act: -100 ), + ( sym: 265; act: -100 ), +{ 113: } + ( sym: 44; act: 129 ), + ( sym: 265; act: 130 ), +{ 114: } + ( sym: 265; act: 131 ), + ( sym: 299; act: 132 ), +{ 115: } + ( sym: 44; act: 133 ), +{ 116: } + ( sym: 44; act: 134 ), +{ 117: } +{ 118: } +{ 119: } +{ 120: } +{ 121: } +{ 122: } +{ 123: } + ( sym: 44; act: 136 ), + ( sym: 259; act: 21 ), + ( sym: 260; act: 22 ), + ( sym: 261; act: 23 ), + ( sym: 262; act: 24 ), + ( sym: 263; act: 25 ), +{ 124: } +{ 125: } + ( sym: 40; act: 17 ), + ( sym: 45; act: 18 ), + ( sym: 126; act: 19 ), + ( sym: 258; act: 20 ), +{ 126: } +{ 127: } +{ 128: } +{ 129: } +{ 130: } +{ 131: } +{ 132: } + ( sym: 261; act: 139 ), + ( sym: 262; act: 140 ), +{ 133: } + ( sym: 258; act: 20 ), +{ 134: } + ( sym: 258; act: 20 ), +{ 135: } +{ 136: } + ( sym: 259; act: 21 ), + ( sym: 260; act: 22 ), + ( sym: 261; act: 23 ), + ( sym: 262; act: 24 ), + ( sym: 263; act: 25 ), +{ 137: } +{ 138: } + ( sym: 258; act: 20 ), + ( sym: 259; act: 21 ), + ( sym: 260; act: 22 ), + ( sym: 261; act: 23 ), + ( sym: 262; act: 24 ), + ( sym: 263; act: 25 ), + ( sym: 44; act: -100 ), + ( sym: 265; act: -100 ), +{ 139: } + ( sym: 264; act: 145 ), +{ 140: } + ( sym: 264; act: 146 ), +{ 141: } + ( sym: 44; act: 147 ), +{ 142: } + ( sym: 44; act: 148 ), +{ 143: } +{ 144: } +{ 145: } +{ 146: } + ( sym: 300; act: 151 ), +{ 147: } + ( sym: 258; act: 20 ), +{ 148: } + ( sym: 258; act: 20 ), +{ 149: } + ( sym: 265; act: 154 ), + ( sym: 299; act: 155 ), +{ 150: } + ( sym: 265; act: 156 ), +{ 151: } + ( sym: 263; act: 157 ), +{ 152: } + ( sym: 44; act: 158 ), +{ 153: } + ( sym: 44; act: 159 ), +{ 154: } +{ 155: } + ( sym: 259; act: 21 ), + ( sym: 260; act: 22 ), + ( sym: 261; act: 23 ), + ( sym: 262; act: 24 ), + ( sym: 263; act: 25 ), +{ 156: } +{ 157: } + ( sym: 44; act: 161 ), +{ 158: } + ( sym: 258; act: 20 ), +{ 159: } + ( sym: 258; act: 20 ), +{ 160: } + ( sym: 264; act: 164 ), +{ 161: } + ( sym: 258; act: 20 ), +{ 162: } +{ 163: } +{ 164: } +{ 165: } + ( sym: 44; act: 168 ), + ( sym: 265; act: -35 ), +{ 166: } + ( sym: 44; act: 169 ), +{ 167: } +{ 168: } + ( sym: 258; act: 20 ), +{ 169: } + ( sym: 258; act: 20 ), +{ 170: } + ( sym: 265; act: 173 ), + ( sym: 300; act: 174 ), +{ 171: } + ( sym: 44; act: 175 ), +{ 172: } +{ 173: } +{ 174: } + ( sym: 259; act: 21 ), + ( sym: 260; act: 22 ), + ( sym: 261; act: 23 ), + ( sym: 262; act: 24 ), + ( sym: 263; act: 25 ), +{ 175: } + ( sym: 258; act: 20 ), +{ 176: } + ( sym: 44; act: 178 ), +{ 177: } +{ 178: } + ( sym: 259; act: 21 ), + ( sym: 260; act: 22 ), + ( sym: 261; act: 23 ), + ( sym: 262; act: 24 ), + ( sym: 263; act: 25 ) +{ 179: } +); + +yyg : array [1..yyngotos] of YYARec = ( +{ 0: } + ( sym: -12; act: 1 ), +{ 1: } + ( sym: -21; act: 2 ), + ( sym: -20; act: 3 ), + ( sym: -19; act: 4 ), + ( sym: -18; act: 5 ), + ( sym: -17; act: 6 ), + ( sym: -16; act: 7 ), + ( sym: -15; act: 8 ), + ( sym: -14; act: 9 ), + ( sym: -13; act: 10 ), + ( sym: -7; act: 11 ), + ( sym: -6; act: 12 ), + ( sym: -5; act: 13 ), + ( sym: -4; act: 14 ), + ( sym: -3; act: 15 ), + ( sym: -2; act: 16 ), +{ 2: } +{ 3: } +{ 4: } +{ 5: } +{ 6: } +{ 7: } +{ 8: } +{ 9: } +{ 10: } +{ 11: } + ( sym: -8; act: 29 ), + ( sym: -7; act: 30 ), + ( sym: -6; act: 12 ), + ( sym: -5; act: 13 ), + ( sym: -4; act: 14 ), + ( sym: -3; act: 15 ), + ( sym: -2; act: 16 ), +{ 12: } +{ 13: } +{ 14: } +{ 15: } +{ 16: } +{ 17: } + ( sym: -4; act: 14 ), + ( sym: -3; act: 53 ), +{ 18: } + ( sym: -4; act: 14 ), + ( sym: -3; act: 54 ), +{ 19: } + ( sym: -4; act: 14 ), + ( sym: -3; act: 55 ), +{ 20: } +{ 21: } +{ 22: } +{ 23: } +{ 24: } +{ 25: } +{ 26: } +{ 27: } + ( sym: -4; act: 14 ), + ( sym: -3; act: 15 ), + ( sym: -2; act: 56 ), +{ 28: } + ( sym: -36; act: 57 ), +{ 29: } + ( sym: -35; act: 58 ), + ( sym: -34; act: 59 ), +{ 30: } +{ 31: } + ( sym: -23; act: 60 ), +{ 32: } + ( sym: -24; act: 61 ), +{ 33: } + ( sym: -25; act: 62 ), +{ 34: } + ( sym: -27; act: 63 ), +{ 35: } +{ 36: } +{ 37: } +{ 38: } +{ 39: } +{ 40: } +{ 41: } +{ 42: } +{ 43: } +{ 44: } +{ 45: } + ( sym: -4; act: 14 ), + ( sym: -3; act: 64 ), +{ 46: } + ( sym: -4; act: 14 ), + ( sym: -3; act: 65 ), +{ 47: } + ( sym: -4; act: 14 ), + ( sym: -3; act: 66 ), +{ 48: } + ( sym: -4; act: 14 ), + ( sym: -3; act: 67 ), +{ 49: } + ( sym: -4; act: 14 ), + ( sym: -3; act: 68 ), +{ 50: } + ( sym: -4; act: 14 ), + ( sym: -3; act: 69 ), +{ 51: } + ( sym: -4; act: 14 ), + ( sym: -3; act: 70 ), +{ 52: } + ( sym: -4; act: 14 ), + ( sym: -3; act: 71 ), +{ 53: } +{ 54: } +{ 55: } +{ 56: } +{ 57: } + ( sym: -22; act: 74 ), +{ 58: } + ( sym: -22; act: 75 ), +{ 59: } + ( sym: -22; act: 76 ), +{ 60: } + ( sym: -22; act: 77 ), +{ 61: } + ( sym: -22; act: 78 ), +{ 62: } + ( sym: -22; act: 79 ), +{ 63: } + ( sym: -26; act: 80 ), +{ 64: } +{ 65: } +{ 66: } +{ 67: } +{ 68: } +{ 69: } +{ 70: } +{ 71: } +{ 72: } +{ 73: } + ( sym: -4; act: 14 ), + ( sym: -3; act: 15 ), + ( sym: -2; act: 81 ), +{ 74: } + ( sym: -39; act: 82 ), +{ 75: } + ( sym: -39; act: 82 ), +{ 76: } + ( sym: -39; act: 82 ), + ( sym: -11; act: 95 ), + ( sym: -6; act: 96 ), +{ 77: } + ( sym: -39; act: 82 ), + ( sym: -11; act: 97 ), + ( sym: -6; act: 96 ), +{ 78: } + ( sym: -39; act: 82 ), + ( sym: -11; act: 98 ), + ( sym: -6; act: 96 ), +{ 79: } + ( sym: -39; act: 82 ), + ( sym: -11; act: 99 ), + ( sym: -6; act: 96 ), +{ 80: } +{ 81: } +{ 82: } +{ 83: } + ( sym: -37; act: 108 ), +{ 84: } + ( sym: -4; act: 14 ), + ( sym: -3; act: 15 ), + ( sym: -2; act: 109 ), +{ 85: } + ( sym: -4; act: 14 ), + ( sym: -3; act: 15 ), + ( sym: -2; act: 110 ), +{ 86: } + ( sym: -4; act: 14 ), + ( sym: -3; act: 15 ), + ( sym: -2; act: 111 ), +{ 87: } +{ 88: } +{ 89: } +{ 90: } +{ 91: } +{ 92: } +{ 93: } +{ 94: } + ( sym: -40; act: 112 ), + ( sym: -9; act: 113 ), +{ 95: } +{ 96: } +{ 97: } +{ 98: } +{ 99: } +{ 100: } + ( sym: -28; act: 114 ), +{ 101: } + ( sym: -4; act: 115 ), +{ 102: } + ( sym: -4; act: 116 ), +{ 103: } + ( sym: -4; act: 14 ), + ( sym: -3; act: 15 ), + ( sym: -2; act: 117 ), +{ 104: } + ( sym: -4; act: 14 ), + ( sym: -3; act: 15 ), + ( sym: -2; act: 118 ), +{ 105: } + ( sym: -4; act: 14 ), + ( sym: -3; act: 15 ), + ( sym: -2; act: 119 ), +{ 106: } + ( sym: -4; act: 14 ), + ( sym: -3; act: 15 ), + ( sym: -2; act: 120 ), +{ 107: } + ( sym: -4; act: 14 ), + ( sym: -3; act: 15 ), + ( sym: -2; act: 121 ), +{ 108: } + ( sym: -38; act: 122 ), + ( sym: -4; act: 123 ), +{ 109: } +{ 110: } +{ 111: } +{ 112: } + ( sym: -10; act: 126 ), + ( sym: -6; act: 127 ), + ( sym: -4; act: 128 ), +{ 113: } +{ 114: } +{ 115: } +{ 116: } +{ 117: } +{ 118: } +{ 119: } +{ 120: } +{ 121: } +{ 122: } +{ 123: } + ( sym: -6; act: 135 ), +{ 124: } +{ 125: } + ( sym: -4; act: 14 ), + ( sym: -3; act: 15 ), + ( sym: -2; act: 137 ), +{ 126: } +{ 127: } +{ 128: } +{ 129: } + ( sym: -41; act: 138 ), +{ 130: } +{ 131: } +{ 132: } +{ 133: } + ( sym: -4; act: 141 ), +{ 134: } + ( sym: -4; act: 142 ), +{ 135: } +{ 136: } + ( sym: -6; act: 143 ), +{ 137: } +{ 138: } + ( sym: -10; act: 144 ), + ( sym: -6; act: 127 ), + ( sym: -4; act: 128 ), +{ 139: } +{ 140: } +{ 141: } +{ 142: } +{ 143: } +{ 144: } +{ 145: } + ( sym: -29; act: 149 ), +{ 146: } + ( sym: -30; act: 150 ), +{ 147: } + ( sym: -4; act: 152 ), +{ 148: } + ( sym: -4; act: 153 ), +{ 149: } +{ 150: } +{ 151: } +{ 152: } +{ 153: } +{ 154: } +{ 155: } + ( sym: -6; act: 160 ), +{ 156: } +{ 157: } +{ 158: } + ( sym: -4; act: 162 ), +{ 159: } + ( sym: -4; act: 163 ), +{ 160: } +{ 161: } + ( sym: -33; act: 165 ), + ( sym: -4; act: 166 ), +{ 162: } +{ 163: } +{ 164: } + ( sym: -32; act: 167 ), +{ 165: } +{ 166: } +{ 167: } + ( sym: -31; act: 170 ), +{ 168: } + ( sym: -4; act: 171 ), +{ 169: } + ( sym: -4; act: 172 ), +{ 170: } +{ 171: } +{ 172: } +{ 173: } +{ 174: } + ( sym: -6; act: 176 ), +{ 175: } + ( sym: -4; act: 177 ), +{ 176: } +{ 177: } +{ 178: } + ( sym: -6; act: 179 ) +{ 179: } +); + +yyd : array [0..yynstates-1] of Integer = ( +{ 0: } -1, +{ 1: } 0, +{ 2: } -10, +{ 3: } -9, +{ 4: } -8, +{ 5: } -7, +{ 6: } -6, +{ 7: } -5, +{ 8: } -4, +{ 9: } -3, +{ 10: } -2, +{ 11: } 0, +{ 12: } -89, +{ 13: } -60, +{ 14: } -76, +{ 15: } 0, +{ 16: } -59, +{ 17: } 0, +{ 18: } 0, +{ 19: } 0, +{ 20: } -75, +{ 21: } -91, +{ 22: } -92, +{ 23: } -93, +{ 24: } -94, +{ 25: } -95, +{ 26: } -88, +{ 27: } 0, +{ 28: } -42, +{ 29: } 0, +{ 30: } -58, +{ 31: } -11, +{ 32: } -13, +{ 33: } -15, +{ 34: } -17, +{ 35: } -48, +{ 36: } -49, +{ 37: } -50, +{ 38: } -51, +{ 39: } -52, +{ 40: } -53, +{ 41: } -54, +{ 42: } -55, +{ 43: } -56, +{ 44: } -57, +{ 45: } 0, +{ 46: } 0, +{ 47: } 0, +{ 48: } 0, +{ 49: } 0, +{ 50: } 0, +{ 51: } 0, +{ 52: } 0, +{ 53: } 0, +{ 54: } -79, +{ 55: } -78, +{ 56: } 0, +{ 57: } -61, +{ 58: } -61, +{ 59: } -61, +{ 60: } -61, +{ 61: } -61, +{ 62: } -61, +{ 63: } -19, +{ 64: } -82, +{ 65: } 0, +{ 66: } -80, +{ 67: } 0, +{ 68: } 0, +{ 69: } -81, +{ 70: } 0, +{ 71: } 0, +{ 72: } -77, +{ 73: } 0, +{ 74: } 0, +{ 75: } 0, +{ 76: } 0, +{ 77: } 0, +{ 78: } 0, +{ 79: } 0, +{ 80: } 0, +{ 81: } -73, +{ 82: } -62, +{ 83: } -44, +{ 84: } 0, +{ 85: } 0, +{ 86: } 0, +{ 87: } -66, +{ 88: } -67, +{ 89: } -68, +{ 90: } -69, +{ 91: } -70, +{ 92: } -71, +{ 93: } -72, +{ 94: } -96, +{ 95: } -39, +{ 96: } -90, +{ 97: } -12, +{ 98: } -14, +{ 99: } -16, +{ 100: } -27, +{ 101: } 0, +{ 102: } 0, +{ 103: } 0, +{ 104: } 0, +{ 105: } 0, +{ 106: } 0, +{ 107: } 0, +{ 108: } 0, +{ 109: } 0, +{ 110: } -64, +{ 111: } -65, +{ 112: } 0, +{ 113: } 0, +{ 114: } 0, +{ 115: } 0, +{ 116: } 0, +{ 117: } -22, +{ 118: } -23, +{ 119: } -24, +{ 120: } -25, +{ 121: } -26, +{ 122: } -45, +{ 123: } 0, +{ 124: } -43, +{ 125: } 0, +{ 126: } -97, +{ 127: } -101, +{ 128: } -102, +{ 129: } -98, +{ 130: } -41, +{ 131: } -18, +{ 132: } 0, +{ 133: } 0, +{ 134: } 0, +{ 135: } -47, +{ 136: } 0, +{ 137: } -63, +{ 138: } 0, +{ 139: } 0, +{ 140: } 0, +{ 141: } 0, +{ 142: } 0, +{ 143: } -46, +{ 144: } -99, +{ 145: } -30, +{ 146: } 0, +{ 147: } 0, +{ 148: } 0, +{ 149: } 0, +{ 150: } 0, +{ 151: } 0, +{ 152: } 0, +{ 153: } 0, +{ 154: } -28, +{ 155: } 0, +{ 156: } -29, +{ 157: } 0, +{ 158: } 0, +{ 159: } 0, +{ 160: } 0, +{ 161: } 0, +{ 162: } -20, +{ 163: } -21, +{ 164: } -31, +{ 165: } 0, +{ 166: } 0, +{ 167: } -33, +{ 168: } 0, +{ 169: } 0, +{ 170: } 0, +{ 171: } 0, +{ 172: } -36, +{ 173: } -32, +{ 174: } 0, +{ 175: } 0, +{ 176: } 0, +{ 177: } -37, +{ 178: } 0, +{ 179: } -34 +); + +yyal : array [0..yynstates-1] of Integer = ( +{ 0: } 1, +{ 1: } 1, +{ 2: } 14, +{ 3: } 14, +{ 4: } 14, +{ 5: } 14, +{ 6: } 14, +{ 7: } 14, +{ 8: } 14, +{ 9: } 14, +{ 10: } 14, +{ 11: } 14, +{ 12: } 38, +{ 13: } 38, +{ 14: } 38, +{ 15: } 38, +{ 16: } 90, +{ 17: } 90, +{ 18: } 94, +{ 19: } 98, +{ 20: } 102, +{ 21: } 102, +{ 22: } 102, +{ 23: } 102, +{ 24: } 102, +{ 25: } 102, +{ 26: } 102, +{ 27: } 102, +{ 28: } 106, +{ 29: } 106, +{ 30: } 122, +{ 31: } 122, +{ 32: } 122, +{ 33: } 122, +{ 34: } 122, +{ 35: } 122, +{ 36: } 122, +{ 37: } 122, +{ 38: } 122, +{ 39: } 122, +{ 40: } 122, +{ 41: } 122, +{ 42: } 122, +{ 43: } 122, +{ 44: } 122, +{ 45: } 122, +{ 46: } 126, +{ 47: } 130, +{ 48: } 134, +{ 49: } 138, +{ 50: } 142, +{ 51: } 146, +{ 52: } 150, +{ 53: } 154, +{ 54: } 163, +{ 55: } 163, +{ 56: } 163, +{ 57: } 164, +{ 58: } 164, +{ 59: } 164, +{ 60: } 164, +{ 61: } 164, +{ 62: } 164, +{ 63: } 164, +{ 64: } 164, +{ 65: } 164, +{ 66: } 217, +{ 67: } 217, +{ 68: } 270, +{ 69: } 323, +{ 70: } 323, +{ 71: } 376, +{ 72: } 429, +{ 73: } 429, +{ 74: } 433, +{ 75: } 444, +{ 76: } 455, +{ 77: } 470, +{ 78: } 485, +{ 79: } 500, +{ 80: } 515, +{ 81: } 523, +{ 82: } 523, +{ 83: } 523, +{ 84: } 523, +{ 85: } 527, +{ 86: } 531, +{ 87: } 535, +{ 88: } 535, +{ 89: } 535, +{ 90: } 535, +{ 91: } 535, +{ 92: } 535, +{ 93: } 535, +{ 94: } 535, +{ 95: } 535, +{ 96: } 535, +{ 97: } 535, +{ 98: } 535, +{ 99: } 535, +{ 100: } 535, +{ 101: } 535, +{ 102: } 536, +{ 103: } 537, +{ 104: } 541, +{ 105: } 545, +{ 106: } 549, +{ 107: } 553, +{ 108: } 557, +{ 109: } 559, +{ 110: } 560, +{ 111: } 560, +{ 112: } 560, +{ 113: } 568, +{ 114: } 570, +{ 115: } 572, +{ 116: } 573, +{ 117: } 574, +{ 118: } 574, +{ 119: } 574, +{ 120: } 574, +{ 121: } 574, +{ 122: } 574, +{ 123: } 574, +{ 124: } 580, +{ 125: } 580, +{ 126: } 584, +{ 127: } 584, +{ 128: } 584, +{ 129: } 584, +{ 130: } 584, +{ 131: } 584, +{ 132: } 584, +{ 133: } 586, +{ 134: } 587, +{ 135: } 588, +{ 136: } 588, +{ 137: } 593, +{ 138: } 593, +{ 139: } 601, +{ 140: } 602, +{ 141: } 603, +{ 142: } 604, +{ 143: } 605, +{ 144: } 605, +{ 145: } 605, +{ 146: } 605, +{ 147: } 606, +{ 148: } 607, +{ 149: } 608, +{ 150: } 610, +{ 151: } 611, +{ 152: } 612, +{ 153: } 613, +{ 154: } 614, +{ 155: } 614, +{ 156: } 619, +{ 157: } 619, +{ 158: } 620, +{ 159: } 621, +{ 160: } 622, +{ 161: } 623, +{ 162: } 624, +{ 163: } 624, +{ 164: } 624, +{ 165: } 624, +{ 166: } 626, +{ 167: } 627, +{ 168: } 627, +{ 169: } 628, +{ 170: } 629, +{ 171: } 631, +{ 172: } 632, +{ 173: } 632, +{ 174: } 632, +{ 175: } 637, +{ 176: } 638, +{ 177: } 639, +{ 178: } 639, +{ 179: } 644 +); + +yyah : array [0..yynstates-1] of Integer = ( +{ 0: } 0, +{ 1: } 13, +{ 2: } 13, +{ 3: } 13, +{ 4: } 13, +{ 5: } 13, +{ 6: } 13, +{ 7: } 13, +{ 8: } 13, +{ 9: } 13, +{ 10: } 13, +{ 11: } 37, +{ 12: } 37, +{ 13: } 37, +{ 14: } 37, +{ 15: } 89, +{ 16: } 89, +{ 17: } 93, +{ 18: } 97, +{ 19: } 101, +{ 20: } 101, +{ 21: } 101, +{ 22: } 101, +{ 23: } 101, +{ 24: } 101, +{ 25: } 101, +{ 26: } 101, +{ 27: } 105, +{ 28: } 105, +{ 29: } 121, +{ 30: } 121, +{ 31: } 121, +{ 32: } 121, +{ 33: } 121, +{ 34: } 121, +{ 35: } 121, +{ 36: } 121, +{ 37: } 121, +{ 38: } 121, +{ 39: } 121, +{ 40: } 121, +{ 41: } 121, +{ 42: } 121, +{ 43: } 121, +{ 44: } 121, +{ 45: } 125, +{ 46: } 129, +{ 47: } 133, +{ 48: } 137, +{ 49: } 141, +{ 50: } 145, +{ 51: } 149, +{ 52: } 153, +{ 53: } 162, +{ 54: } 162, +{ 55: } 162, +{ 56: } 163, +{ 57: } 163, +{ 58: } 163, +{ 59: } 163, +{ 60: } 163, +{ 61: } 163, +{ 62: } 163, +{ 63: } 163, +{ 64: } 163, +{ 65: } 216, +{ 66: } 216, +{ 67: } 269, +{ 68: } 322, +{ 69: } 322, +{ 70: } 375, +{ 71: } 428, +{ 72: } 428, +{ 73: } 432, +{ 74: } 443, +{ 75: } 454, +{ 76: } 469, +{ 77: } 484, +{ 78: } 499, +{ 79: } 514, +{ 80: } 522, +{ 81: } 522, +{ 82: } 522, +{ 83: } 522, +{ 84: } 526, +{ 85: } 530, +{ 86: } 534, +{ 87: } 534, +{ 88: } 534, +{ 89: } 534, +{ 90: } 534, +{ 91: } 534, +{ 92: } 534, +{ 93: } 534, +{ 94: } 534, +{ 95: } 534, +{ 96: } 534, +{ 97: } 534, +{ 98: } 534, +{ 99: } 534, +{ 100: } 534, +{ 101: } 535, +{ 102: } 536, +{ 103: } 540, +{ 104: } 544, +{ 105: } 548, +{ 106: } 552, +{ 107: } 556, +{ 108: } 558, +{ 109: } 559, +{ 110: } 559, +{ 111: } 559, +{ 112: } 567, +{ 113: } 569, +{ 114: } 571, +{ 115: } 572, +{ 116: } 573, +{ 117: } 573, +{ 118: } 573, +{ 119: } 573, +{ 120: } 573, +{ 121: } 573, +{ 122: } 573, +{ 123: } 579, +{ 124: } 579, +{ 125: } 583, +{ 126: } 583, +{ 127: } 583, +{ 128: } 583, +{ 129: } 583, +{ 130: } 583, +{ 131: } 583, +{ 132: } 585, +{ 133: } 586, +{ 134: } 587, +{ 135: } 587, +{ 136: } 592, +{ 137: } 592, +{ 138: } 600, +{ 139: } 601, +{ 140: } 602, +{ 141: } 603, +{ 142: } 604, +{ 143: } 604, +{ 144: } 604, +{ 145: } 604, +{ 146: } 605, +{ 147: } 606, +{ 148: } 607, +{ 149: } 609, +{ 150: } 610, +{ 151: } 611, +{ 152: } 612, +{ 153: } 613, +{ 154: } 613, +{ 155: } 618, +{ 156: } 618, +{ 157: } 619, +{ 158: } 620, +{ 159: } 621, +{ 160: } 622, +{ 161: } 623, +{ 162: } 623, +{ 163: } 623, +{ 164: } 623, +{ 165: } 625, +{ 166: } 626, +{ 167: } 626, +{ 168: } 627, +{ 169: } 628, +{ 170: } 630, +{ 171: } 631, +{ 172: } 631, +{ 173: } 631, +{ 174: } 636, +{ 175: } 637, +{ 176: } 638, +{ 177: } 638, +{ 178: } 643, +{ 179: } 643 +); + +yygl : array [0..yynstates-1] of Integer = ( +{ 0: } 1, +{ 1: } 2, +{ 2: } 17, +{ 3: } 17, +{ 4: } 17, +{ 5: } 17, +{ 6: } 17, +{ 7: } 17, +{ 8: } 17, +{ 9: } 17, +{ 10: } 17, +{ 11: } 17, +{ 12: } 24, +{ 13: } 24, +{ 14: } 24, +{ 15: } 24, +{ 16: } 24, +{ 17: } 24, +{ 18: } 26, +{ 19: } 28, +{ 20: } 30, +{ 21: } 30, +{ 22: } 30, +{ 23: } 30, +{ 24: } 30, +{ 25: } 30, +{ 26: } 30, +{ 27: } 30, +{ 28: } 33, +{ 29: } 34, +{ 30: } 36, +{ 31: } 36, +{ 32: } 37, +{ 33: } 38, +{ 34: } 39, +{ 35: } 40, +{ 36: } 40, +{ 37: } 40, +{ 38: } 40, +{ 39: } 40, +{ 40: } 40, +{ 41: } 40, +{ 42: } 40, +{ 43: } 40, +{ 44: } 40, +{ 45: } 40, +{ 46: } 42, +{ 47: } 44, +{ 48: } 46, +{ 49: } 48, +{ 50: } 50, +{ 51: } 52, +{ 52: } 54, +{ 53: } 56, +{ 54: } 56, +{ 55: } 56, +{ 56: } 56, +{ 57: } 56, +{ 58: } 57, +{ 59: } 58, +{ 60: } 59, +{ 61: } 60, +{ 62: } 61, +{ 63: } 62, +{ 64: } 63, +{ 65: } 63, +{ 66: } 63, +{ 67: } 63, +{ 68: } 63, +{ 69: } 63, +{ 70: } 63, +{ 71: } 63, +{ 72: } 63, +{ 73: } 63, +{ 74: } 66, +{ 75: } 67, +{ 76: } 68, +{ 77: } 71, +{ 78: } 74, +{ 79: } 77, +{ 80: } 80, +{ 81: } 80, +{ 82: } 80, +{ 83: } 80, +{ 84: } 81, +{ 85: } 84, +{ 86: } 87, +{ 87: } 90, +{ 88: } 90, +{ 89: } 90, +{ 90: } 90, +{ 91: } 90, +{ 92: } 90, +{ 93: } 90, +{ 94: } 90, +{ 95: } 92, +{ 96: } 92, +{ 97: } 92, +{ 98: } 92, +{ 99: } 92, +{ 100: } 92, +{ 101: } 93, +{ 102: } 94, +{ 103: } 95, +{ 104: } 98, +{ 105: } 101, +{ 106: } 104, +{ 107: } 107, +{ 108: } 110, +{ 109: } 112, +{ 110: } 112, +{ 111: } 112, +{ 112: } 112, +{ 113: } 115, +{ 114: } 115, +{ 115: } 115, +{ 116: } 115, +{ 117: } 115, +{ 118: } 115, +{ 119: } 115, +{ 120: } 115, +{ 121: } 115, +{ 122: } 115, +{ 123: } 115, +{ 124: } 116, +{ 125: } 116, +{ 126: } 119, +{ 127: } 119, +{ 128: } 119, +{ 129: } 119, +{ 130: } 120, +{ 131: } 120, +{ 132: } 120, +{ 133: } 120, +{ 134: } 121, +{ 135: } 122, +{ 136: } 122, +{ 137: } 123, +{ 138: } 123, +{ 139: } 126, +{ 140: } 126, +{ 141: } 126, +{ 142: } 126, +{ 143: } 126, +{ 144: } 126, +{ 145: } 126, +{ 146: } 127, +{ 147: } 128, +{ 148: } 129, +{ 149: } 130, +{ 150: } 130, +{ 151: } 130, +{ 152: } 130, +{ 153: } 130, +{ 154: } 130, +{ 155: } 130, +{ 156: } 131, +{ 157: } 131, +{ 158: } 131, +{ 159: } 132, +{ 160: } 133, +{ 161: } 133, +{ 162: } 135, +{ 163: } 135, +{ 164: } 135, +{ 165: } 136, +{ 166: } 136, +{ 167: } 136, +{ 168: } 137, +{ 169: } 138, +{ 170: } 139, +{ 171: } 139, +{ 172: } 139, +{ 173: } 139, +{ 174: } 139, +{ 175: } 140, +{ 176: } 141, +{ 177: } 141, +{ 178: } 141, +{ 179: } 142 +); + +yygh : array [0..yynstates-1] of Integer = ( +{ 0: } 1, +{ 1: } 16, +{ 2: } 16, +{ 3: } 16, +{ 4: } 16, +{ 5: } 16, +{ 6: } 16, +{ 7: } 16, +{ 8: } 16, +{ 9: } 16, +{ 10: } 16, +{ 11: } 23, +{ 12: } 23, +{ 13: } 23, +{ 14: } 23, +{ 15: } 23, +{ 16: } 23, +{ 17: } 25, +{ 18: } 27, +{ 19: } 29, +{ 20: } 29, +{ 21: } 29, +{ 22: } 29, +{ 23: } 29, +{ 24: } 29, +{ 25: } 29, +{ 26: } 29, +{ 27: } 32, +{ 28: } 33, +{ 29: } 35, +{ 30: } 35, +{ 31: } 36, +{ 32: } 37, +{ 33: } 38, +{ 34: } 39, +{ 35: } 39, +{ 36: } 39, +{ 37: } 39, +{ 38: } 39, +{ 39: } 39, +{ 40: } 39, +{ 41: } 39, +{ 42: } 39, +{ 43: } 39, +{ 44: } 39, +{ 45: } 41, +{ 46: } 43, +{ 47: } 45, +{ 48: } 47, +{ 49: } 49, +{ 50: } 51, +{ 51: } 53, +{ 52: } 55, +{ 53: } 55, +{ 54: } 55, +{ 55: } 55, +{ 56: } 55, +{ 57: } 56, +{ 58: } 57, +{ 59: } 58, +{ 60: } 59, +{ 61: } 60, +{ 62: } 61, +{ 63: } 62, +{ 64: } 62, +{ 65: } 62, +{ 66: } 62, +{ 67: } 62, +{ 68: } 62, +{ 69: } 62, +{ 70: } 62, +{ 71: } 62, +{ 72: } 62, +{ 73: } 65, +{ 74: } 66, +{ 75: } 67, +{ 76: } 70, +{ 77: } 73, +{ 78: } 76, +{ 79: } 79, +{ 80: } 79, +{ 81: } 79, +{ 82: } 79, +{ 83: } 80, +{ 84: } 83, +{ 85: } 86, +{ 86: } 89, +{ 87: } 89, +{ 88: } 89, +{ 89: } 89, +{ 90: } 89, +{ 91: } 89, +{ 92: } 89, +{ 93: } 89, +{ 94: } 91, +{ 95: } 91, +{ 96: } 91, +{ 97: } 91, +{ 98: } 91, +{ 99: } 91, +{ 100: } 92, +{ 101: } 93, +{ 102: } 94, +{ 103: } 97, +{ 104: } 100, +{ 105: } 103, +{ 106: } 106, +{ 107: } 109, +{ 108: } 111, +{ 109: } 111, +{ 110: } 111, +{ 111: } 111, +{ 112: } 114, +{ 113: } 114, +{ 114: } 114, +{ 115: } 114, +{ 116: } 114, +{ 117: } 114, +{ 118: } 114, +{ 119: } 114, +{ 120: } 114, +{ 121: } 114, +{ 122: } 114, +{ 123: } 115, +{ 124: } 115, +{ 125: } 118, +{ 126: } 118, +{ 127: } 118, +{ 128: } 118, +{ 129: } 119, +{ 130: } 119, +{ 131: } 119, +{ 132: } 119, +{ 133: } 120, +{ 134: } 121, +{ 135: } 121, +{ 136: } 122, +{ 137: } 122, +{ 138: } 125, +{ 139: } 125, +{ 140: } 125, +{ 141: } 125, +{ 142: } 125, +{ 143: } 125, +{ 144: } 125, +{ 145: } 126, +{ 146: } 127, +{ 147: } 128, +{ 148: } 129, +{ 149: } 129, +{ 150: } 129, +{ 151: } 129, +{ 152: } 129, +{ 153: } 129, +{ 154: } 129, +{ 155: } 130, +{ 156: } 130, +{ 157: } 130, +{ 158: } 131, +{ 159: } 132, +{ 160: } 132, +{ 161: } 134, +{ 162: } 134, +{ 163: } 134, +{ 164: } 135, +{ 165: } 135, +{ 166: } 135, +{ 167: } 136, +{ 168: } 137, +{ 169: } 138, +{ 170: } 138, +{ 171: } 138, +{ 172: } 138, +{ 173: } 138, +{ 174: } 139, +{ 175: } 140, +{ 176: } 140, +{ 177: } 140, +{ 178: } 141, +{ 179: } 141 +); + +yyr : array [1..yynrules] of YYRRec = ( +{ 1: } ( len: 0; sym: -12 ), +{ 2: } ( len: 2; sym: -12 ), +{ 3: } ( len: 1; sym: -13 ), +{ 4: } ( len: 1; sym: -13 ), +{ 5: } ( len: 1; sym: -14 ), +{ 6: } ( len: 1; sym: -14 ), +{ 7: } ( len: 1; sym: -14 ), +{ 8: } ( len: 1; sym: -14 ), +{ 9: } ( len: 1; sym: -14 ), +{ 10: } ( len: 1; sym: -14 ), +{ 11: } ( len: 0; sym: -23 ), +{ 12: } ( len: 5; sym: -17 ), +{ 13: } ( len: 0; sym: -24 ), +{ 14: } ( len: 5; sym: -18 ), +{ 15: } ( len: 0; sym: -25 ), +{ 16: } ( len: 5; sym: -19 ), +{ 17: } ( len: 0; sym: -27 ), +{ 18: } ( len: 7; sym: -20 ), +{ 19: } ( len: 0; sym: -26 ), +{ 20: } ( len: 9; sym: -26 ), +{ 21: } ( len: 9; sym: -26 ), +{ 22: } ( len: 3; sym: -26 ), +{ 23: } ( len: 3; sym: -26 ), +{ 24: } ( len: 3; sym: -26 ), +{ 25: } ( len: 3; sym: -26 ), +{ 26: } ( len: 3; sym: -26 ), +{ 27: } ( len: 0; sym: -28 ), +{ 28: } ( len: 6; sym: -28 ), +{ 29: } ( len: 6; sym: -28 ), +{ 30: } ( len: 0; sym: -29 ), +{ 31: } ( len: 0; sym: -32 ), +{ 32: } ( len: 7; sym: -29 ), +{ 33: } ( len: 0; sym: -31 ), +{ 34: } ( len: 5; sym: -31 ), +{ 35: } ( len: 4; sym: -30 ), +{ 36: } ( len: 3; sym: -33 ), +{ 37: } ( len: 5; sym: -33 ), +{ 38: } ( len: 0; sym: -34 ), +{ 39: } ( len: 5; sym: -21 ), +{ 40: } ( len: 0; sym: -35 ), +{ 41: } ( len: 7; sym: -21 ), +{ 42: } ( len: 0; sym: -36 ), +{ 43: } ( len: 6; sym: -16 ), +{ 44: } ( len: 0; sym: -37 ), +{ 45: } ( len: 2; sym: -37 ), +{ 46: } ( len: 3; sym: -38 ), +{ 47: } ( len: 2; sym: -38 ), +{ 48: } ( len: 1; sym: -8 ), +{ 49: } ( len: 1; sym: -8 ), +{ 50: } ( len: 1; sym: -8 ), +{ 51: } ( len: 1; sym: -8 ), +{ 52: } ( len: 1; sym: -8 ), +{ 53: } ( len: 1; sym: -8 ), +{ 54: } ( len: 1; sym: -8 ), +{ 55: } ( len: 1; sym: -8 ), +{ 56: } ( len: 1; sym: -8 ), +{ 57: } ( len: 1; sym: -8 ), +{ 58: } ( len: 1; sym: -8 ), +{ 59: } ( len: 1; sym: -7 ), +{ 60: } ( len: 1; sym: -7 ), +{ 61: } ( len: 0; sym: -22 ), +{ 62: } ( len: 2; sym: -22 ), +{ 63: } ( len: 4; sym: -39 ), +{ 64: } ( len: 2; sym: -39 ), +{ 65: } ( len: 2; sym: -39 ), +{ 66: } ( len: 1; sym: -39 ), +{ 67: } ( len: 1; sym: -39 ), +{ 68: } ( len: 1; sym: -39 ), +{ 69: } ( len: 1; sym: -39 ), +{ 70: } ( len: 1; sym: -39 ), +{ 71: } ( len: 1; sym: -39 ), +{ 72: } ( len: 1; sym: -39 ), +{ 73: } ( len: 4; sym: -15 ), +{ 74: } ( len: 1; sym: -2 ), +{ 75: } ( len: 1; sym: -4 ), +{ 76: } ( len: 1; sym: -3 ), +{ 77: } ( len: 3; sym: -3 ), +{ 78: } ( len: 2; sym: -3 ), +{ 79: } ( len: 2; sym: -3 ), +{ 80: } ( len: 3; sym: -3 ), +{ 81: } ( len: 3; sym: -3 ), +{ 82: } ( len: 3; sym: -3 ), +{ 83: } ( len: 3; sym: -3 ), +{ 84: } ( len: 3; sym: -3 ), +{ 85: } ( len: 3; sym: -3 ), +{ 86: } ( len: 3; sym: -3 ), +{ 87: } ( len: 3; sym: -3 ), +{ 88: } ( len: 1; sym: -5 ), +{ 89: } ( len: 1; sym: -5 ), +{ 90: } ( len: 1; sym: -11 ), +{ 91: } ( len: 1; sym: -6 ), +{ 92: } ( len: 1; sym: -6 ), +{ 93: } ( len: 1; sym: -6 ), +{ 94: } ( len: 1; sym: -6 ), +{ 95: } ( len: 1; sym: -6 ), +{ 96: } ( len: 0; sym: -40 ), +{ 97: } ( len: 2; sym: -9 ), +{ 98: } ( len: 0; sym: -41 ), +{ 99: } ( len: 4; sym: -9 ), +{ 100: } ( len: 0; sym: -10 ), +{ 101: } ( len: 1; sym: -10 ), +{ 102: } ( len: 1; sym: -10 ) +); + + +const _error = 256; (* error token *) + +function yyact(state, sym : Integer; var act : Integer) : Boolean; + (* search action table *) + var k : Integer; + begin + k := yyal[state]; + while (k<=yyah[state]) and (yya[k].sym<>sym) do inc(k); + if k>yyah[state] then + yyact := false + else + begin + act := yya[k].act; + yyact := true; + end; + end(*yyact*); + +function yygoto(state, sym : Integer; var nstate : Integer) : Boolean; + (* search goto table *) + var k : Integer; + begin + k := yygl[state]; + while (k<=yygh[state]) and (yyg[k].sym<>sym) do inc(k); + if k>yygh[state] then + yygoto := false + else + begin + nstate := yyg[k].act; + yygoto := true; + end; + end(*yygoto*); + +label parse, next, error, errlab, shift, reduce, accept, abort; + +begin(*yyparse*) + + (* initialize: *) + + yystate := 0; yychar := -1; yynerrs := 0; yyerrflag := 0; yysp := 0; + +{$ifdef yydebug} + yydebug := true; +{$else} + yydebug := false; +{$endif} + +parse: + + (* push state and value: *) + + inc(yysp); + if yysp>yymaxdepth then + begin + yyerror('yyparse stack overflow'); + goto abort; + end; + yys[yysp] := yystate; yyv[yysp] := yyval; + +next: + + if (yyd[yystate]=0) and (yychar=-1) then + (* get next symbol *) + begin + yychar := yylex; if yychar<0 then yychar := 0; + end; + + if yydebug then writeln('state ', yystate, ', char ', yychar); + + (* determine parse action: *) + + yyn := yyd[yystate]; + if yyn<>0 then goto reduce; (* simple state *) + + (* no default action; search parse table *) + + if not yyact(yystate, yychar, yyn) then goto error + else if yyn>0 then goto shift + else if yyn<0 then goto reduce + else goto accept; + +error: + + (* error; start error recovery: *) + + if yyerrflag=0 then yyerror('syntax error'); + +errlab: + + if yyerrflag=0 then inc(yynerrs); (* new error *) + + if yyerrflag<=2 then (* incomplete recovery; try again *) + begin + yyerrflag := 3; + (* uncover a state with shift action on error token *) + while (yysp>0) and not ( yyact(yys[yysp], _error, yyn) and + (yyn>0) ) do + begin + if yydebug then + if yysp>1 then + writeln('error recovery pops state ', yys[yysp], ', uncovers ', + yys[yysp-1]) + else + writeln('error recovery fails ... abort'); + dec(yysp); + end; + if yysp=0 then goto abort; (* parser has fallen from stack; abort *) + yystate := yyn; (* simulate shift on error *) + goto parse; + end + else (* no shift yet; discard symbol *) + begin + if yydebug then writeln('error recovery discards char ', yychar); + if yychar=0 then goto abort; (* end of input; abort *) + yychar := -1; goto next; (* clear lookahead char and try again *) + end; + +shift: + + (* go to new state, clear lookahead character: *) + + yystate := yyn; yychar := -1; yyval := yylval; + if yyerrflag>0 then dec(yyerrflag); + + goto parse; + +reduce: + + (* execute action, pop rule from stack, and go to next state: *) + + if yydebug then writeln('reduce ', -yyn); + + yyflag := yyfnone; yyaction(-yyn); + dec(yysp, yyr[-yyn].len); + if yygoto(yys[yysp], yyr[-yyn].sym, yyn) then yystate := yyn; + + (* handle action calls to yyaccept, yyabort and yyerror: *) + + case yyflag of + yyfaccept : goto accept; + yyfabort : goto abort; + yyferror : goto errlab; + end; + + goto parse; + +accept: + + yyparse := 0; exit; + +abort: + + yyparse := 1; exit; + +end(*yyparse*); + + +{$I rclex.inc} +begin + bufptr:= 0; + lexlib.get_char:= @rc_get_char; + lexlib.unget_char:= @rc_unget_char; +end. diff --git a/packages/fcl-res/src/rcparser.y b/packages/fcl-res/src/rcparser.y new file mode 100644 index 0000000000..3fe3072524 --- /dev/null +++ b/packages/fcl-res/src/rcparser.y @@ -0,0 +1,234 @@ +%{ +(* +Vorspann + ****************************************************************************) + +unit rcparser; + +{$I rcparserfn.inc} + +%} + +%token _ILLEGAL +%token _NUMBER _QUOTEDSTR _QUOTEDSTRL +%token _STR_StringFileInfo _STR_VarFileInfo _STR_Translation +%token _BEGIN _END _ID +%token _LANGUAGE _CHARACTERISTICS _VERSION _MOVEABLE _FIXED _PURE _IMPURE _PRELOAD _LOADONCALL _DISCARDABLE +%token _BITMAP _CURSOR _ICON _STRINGTABLE _VERSIONINFO +%token _ANICURSOR _ANIICON _DLGINCLUDE _DLGINIT _HTML _MANIFEST _MESSAGETABLE _PLUGPLAY _RCDATA _VXD +%token _FILEVERSION _PRODUCTVERSION _FILEFLAGSMASK _FILEFLAGS _FILEOS _FILETYPE _FILESUBTYPE _BLOCK _VALUE +%token _ACCELERATORS _DIALOG _DIALOGEX _MENU _MENUEX + +%type numpos numexpr numeral +%type ident_string long_string +%type resid rcdataid +%type raw_data raw_item +%type filename_string + +%left '|' +%left '^' +%left '&' +%left '+' '-' +%left '*' '/' '%' +%right '~' _NUMNEG + +%% + +rcfile + : /* empty */ + | rcfile defnstatement + ; + +defnstatement + : resourcedef + | languagedef + ; + +resourcedef + : res_stringtable + | res_bitmap + | res_cursor + | res_icon + | res_version + | res_rcdata + ; + +res_bitmap + : resid _BITMAP { create_resource($1, RT_BITMAP); } suboptions filename_string { TBitmapResource(aktresource).SetCustomBitmapDataStream($5); } + +res_cursor + : resid _CURSOR { create_resource($1, RT_CURSOR); } suboptions filename_string { TGroupCursorResource(aktresource).SetCustomItemDataStream($5); } + +res_icon + : resid _ICON { create_resource($1, RT_ICON); } suboptions filename_string { TGroupIconResource(aktresource).SetCustomItemDataStream($5); } + +res_version + : resid _VERSIONINFO { create_resource($1, RT_VERSION); } version_fixed _BEGIN version_blocks _END + +version_fixed + : /* empty */ + | version_fixed _FILEVERSION numeral ',' numeral ',' numeral ',' numeral { TVersionResource(aktresource).FixedInfo.FileVersion:= make_version($3.v, $5.v, $7.v, $9.v); } + | version_fixed _PRODUCTVERSION numeral ',' numeral ',' numeral ',' numeral { TVersionResource(aktresource).FixedInfo.ProductVersion:= make_version($3.v, $5.v, $7.v, $9.v); } + | version_fixed _FILEFLAGSMASK numpos { TVersionResource(aktresource).FixedInfo.FileFlagsMask:= $3.v; } + | version_fixed _FILEFLAGS numpos { TVersionResource(aktresource).FixedInfo.FileFlags:= $3.v; } + | version_fixed _FILEOS numpos { TVersionResource(aktresource).FixedInfo.FileOS:= $3.v; } + | version_fixed _FILETYPE numpos { TVersionResource(aktresource).FixedInfo.FileType:= $3.v; } + | version_fixed _FILESUBTYPE numpos { TVersionResource(aktresource).FixedInfo.FileSubType:= $3.v; } + ; + +version_blocks + : /* empty */ + | version_blocks _BLOCK _STR_StringFileInfo _BEGIN ver_strings_lang _END + | version_blocks _BLOCK _STR_VarFileInfo _BEGIN ver_translation_data _END + ; + +ver_strings_lang + : /* empty */ + | ver_strings_lang _BLOCK long_string _BEGIN { version_string_tab_begin($3.v^); } + ver_strings_data _END + ; + +ver_strings_data + : /* empty */ + | ver_strings_data _VALUE long_string ',' long_string { version_string_tab_add($3.v^, $5.v^); } + ; + +ver_translation_data + : _VALUE _STR_Translation ',' ver_translation_pair + ; + +ver_translation_pair + : numeral ',' numeral { version_var_translation_add($1.v, $3.v); } + | ver_translation_pair ',' numeral ',' numeral { version_var_translation_add($3.v, $5.v); } + ; + +res_rcdata + : resid rcdataid { create_resource($1, $2); } suboptions filename_string { aktresource.SetCustomRawDataStream($5); } + | resid rcdataid { create_resource($1, $2); } suboptions _BEGIN raw_data _END { aktresource.SetCustomRawDataStream($6); } + ; + +res_stringtable + : _STRINGTABLE { stringtable_begin(); } suboptions _BEGIN stringtable_data _END { stringtable_end(); } + +stringtable_data + : /* empty */ + | stringtable_data stringtable_entry + ; + +stringtable_entry + : numeral ',' long_string { stringtable_add($1.v, $3.v^); } + | numeral long_string { stringtable_add($1.v, $2.v^); } + ; + +rcdataid + : _ANICURSOR { $$:= TResourceDesc.Create(RT_ANICURSOR); } + | _ANIICON { $$:= TResourceDesc.Create(RT_ANIICON); } + | _DLGINCLUDE { $$:= TResourceDesc.Create(RT_DLGINCLUDE); } + | _DLGINIT { $$:= TResourceDesc.Create(RT_DLGINIT); } + | _HTML { $$:= TResourceDesc.Create(23); } + | _MANIFEST { $$:= TResourceDesc.Create(RT_MANIFEST); } + | _MESSAGETABLE { $$:= TResourceDesc.Create(RT_MESSAGETABLE); } + | _PLUGPLAY { $$:= TResourceDesc.Create(RT_PLUGPLAY); } + | _RCDATA { $$:= TResourceDesc.Create(RT_RCDATA); } + | _VXD { $$:= TResourceDesc.Create(RT_VXD); } + | resid + ; + +resid + : numpos { $$:= TResourceDesc.Create($1.v); } + | ident_string { $$:= TResourceDesc.Create($1.v^); } + ; + +suboptions + : /* empty */ + | suboptions suboption + ; + +suboption + : _LANGUAGE numpos ',' numpos { change_lang_id(MakeLangID($2.v, $4.v)); } + | _CHARACTERISTICS numpos { aktresource.Characteristics:= $2.v; } + | _VERSION numpos { aktresource.Version:= $2.v; } + | _MOVEABLE { aktresource.MemoryFlags:= aktresource.MemoryFlags or MF_MOVEABLE; } + | _FIXED { aktresource.MemoryFlags:= aktresource.MemoryFlags and not MF_MOVEABLE; } + | _PURE { aktresource.MemoryFlags:= aktresource.MemoryFlags or MF_PURE; } + | _IMPURE { aktresource.MemoryFlags:= aktresource.MemoryFlags and not MF_PURE; } + | _PRELOAD { aktresource.MemoryFlags:= aktresource.MemoryFlags or MF_PRELOAD; } + | _LOADONCALL { aktresource.MemoryFlags:= aktresource.MemoryFlags and not MF_PRELOAD; } + | _DISCARDABLE { aktresource.MemoryFlags:= aktresource.MemoryFlags or MF_DISCARDABLE; } + ; + +languagedef + : _LANGUAGE numpos ',' numpos { language:= MakeLangID($2.v, $4.v); } + +numpos + : numexpr + ; + +numeral + : _NUMBER { $$:= str_to_num(yytext); } + ; + +numexpr + : numeral + | '(' numexpr ')' { $$:= $2; } + | '~' numexpr %prec '~' { $$.v:= not $2.v; $$.long:= $2.long; } + | '-' numexpr %prec _NUMNEG { $$.v:= -$2.v; $$.long:= $2.long; } + | numexpr '*' numexpr { $$.v:= $1.v * $3.v; $$.long:= $1.long or $3.long; } + | numexpr '/' numexpr { $$.v:= $1.v div Max(1, $3.v); $$.long:= $1.long or $3.long; } + | numexpr '%' numexpr { $$.v:= $1.v mod Max(1, $3.v); $$.long:= $1.long or $3.long; } + | numexpr '+' numexpr { $$.v:= $1.v + $3.v; $$.long:= $1.long or $3.long; } + | numexpr '-' numexpr { $$.v:= $1.v - $3.v; $$.long:= $1.long or $3.long; } + | numexpr '&' numexpr { $$.v:= $1.v and $3.v; $$.long:= $1.long or $3.long; } + | numexpr '^' numexpr { $$.v:= $1.v xor $3.v; $$.long:= $1.long or $3.long; } + | numexpr '|' numexpr { $$.v:= $1.v or $3.v; $$.long:= $1.long or $3.long; } + ; + +ident_string + : _ID { string_new($$, yytext, opt_code_page); } + | long_string + ; + +filename_string + : long_string { $$:= TFileStream.Create($1.v^, fmOpenRead or fmShareDenyWrite); } + ; + +long_string + : _QUOTEDSTR { string_new_uni($$, @strbuf[0], strbuflen, opt_code_page, true); } + | _QUOTEDSTRL { string_new_uni($$, @strbuf[0], strbuflen, CP_UTF16, true); } + | _STR_StringFileInfo { string_new($$, yytext, opt_code_page); } + | _STR_VarFileInfo { string_new($$, yytext, opt_code_page); } + | _STR_Translation { string_new($$, yytext, opt_code_page); } + ; + +raw_data + : { $$:= TMemoryStream.Create; } + raw_item + | raw_data ',' { $$:= $1; } raw_item + ; + +raw_item + : /* empty */ + { + $$:= $0; + } + | long_string + { + $$:= $0; + raw_write_string($$, $1); + } + | numeral + { + $$:= $0; + raw_write_int($$, $1); + } + ; + +%% + +{$I rclex.inc} +begin + bufptr:= 0; + lexlib.get_char:= @rc_get_char; + lexlib.unget_char:= @rc_unget_char; +end. + diff --git a/packages/fcl-res/src/rcparserfn.inc b/packages/fcl-res/src/rcparserfn.inc new file mode 100644 index 0000000000..a92f6f89f9 --- /dev/null +++ b/packages/fcl-res/src/rcparserfn.inc @@ -0,0 +1,435 @@ +{%MainUnit rcparser.pas} + +interface + +{$mode objfpc}{$H+} +{$COPERATORS ON} +{$GOTO ON} + +uses + SysUtils, Classes, StrUtils, fgl, lexlib, yacclib, resource, + acceleratorsresource, groupiconresource, stringtableresource, + bitmapresource, versionresource, versiontypes, groupcursorresource; + +type + TStringHashTable = specialize TFPGMap; + +function yyparse : Integer; + +var + aktresources: TResources; + opt_code_page: TSystemCodePage; + yyfilename: AnsiString; + yyparseresult: YYSType; + +procedure DisposePools; +procedure SetDefaults; +procedure PragmaCodePage(cp: string); + +{$DEFINE INC_HEADER} +{$I yyinclude.pp} +{$I yypreproc.pp} +{$UNDEF INC_HEADER} + +implementation + +procedure yyerror ( msg : String ); +begin + writeln(ErrOutput, yyfilename, '(',yylineno,':',yycolno,'): at "',yytext,'": ', msg); + WriteLn(ErrOutput, yyline); + WriteLn(ErrOutput, '^':yycolno); +end(*yyerrmsg*); + +{$I yyinclude.pp} +{$I yypreproc.pp} + +(* I/O routines: *) + +const nl = #10; (* newline character *) + +const max_chars = 2048; + +var + bufptr : Integer; + buf : array [1..max_chars] of Char; + +function rc_get_char : Char; + var i : Integer; + ok : boolean; + begin + if (bufptr=0) and not eof(yyinput) then + begin + repeat + readln(yyinput, yyline); + inc(yylineno); yycolno := 1; + ok:= ypreproc.useline(yyline); + until (ok or eof(yyinput)); + if ok then begin + buf[1] := nl; + for i := 1 to length(yyline) do + buf[i+1] := yyline[length(yyline)-i+1]; + inc(bufptr, length(yyline)+1); + end; + end; + if bufptr>0 then + begin + rc_get_char := buf[bufptr]; + dec(bufptr); + inc(yycolno); + end + else + rc_get_char := #0; + end(*get_char*); + +procedure rc_unget_char ( c : Char ); + begin + if bufptr=max_chars then yyerror('input buffer overflow'); + inc(bufptr); + dec(yycolno); + buf[bufptr] := c; + end(*unget_char*); + +procedure unget_string(s: string); +var + i: integer; +begin + for i:= Length(s) downto 1 do + rc_unget_char(s[i]); +end; + +procedure PragmaCodePage(cp: string); +var cpi: integer; +begin + if Uppercase(cp) = 'DEFAULT' then + opt_code_page:= DefaultFileSystemCodePage + else begin + if TryStrToInt(cp, cpi) and (cpi>=0) and (cpi<=high(TSystemCodePage)) then + opt_code_page:= cpi + else + yyerror('Invalid code_page pragma: "' + cp + '"'); + end; +end; + +type + rcnumtype = record + v: LongWord; + long: boolean; + end; + + rcstrtype = record + v: PUnicodeString; + cp: TSystemCodePage; + end; + +function str_to_cbase(s: string): LongWord; +begin + if s = '0' then + Exit(0); + if Copy(s, 1, 2) = '0x' then + Exit(StrToInt('$' + Copy(s, 3, Maxint))); + if Copy(s, 1, 2) = '0o' then + Exit(StrToInt('&' + Copy(s, 3, Maxint))); + if Copy(s, 1, 1) = '0' then + Exit(StrToInt('&' + Copy(s, 2, Maxint))); + Result:= StrToInt(s); +end; + +function str_to_num(s:string): rcnumtype; +begin + // this does not handle empty strings - should never get them from the lexer + Result.long:= s[Length(s)] = 'L'; + if Result.long then + setlength(s, Length(s) - 1); + Result.v:= str_to_cbase(s); +end; + +type + PStrPoolItem = ^TStrPoolItem; + TStrPoolItem = record + str: PUnicodeString; + next: PStrPoolItem; + end; + +const + MAX_RCSTR_LEN = 4096; +var + strbuf: array[0..MAX_RCSTR_LEN + 1] of char; + strbuflen: Integer; + stringpool: PStrPoolItem = nil; + +procedure strbuf_begin(); +begin + FillChar(strbuf[0], sizeof(strbuf), 0); + strbuflen:= 0; +end; + +procedure strbuf_append(s: string); +var + rem: integer; +begin + rem:= MAX_RCSTR_LEN - strbuflen; + if Length(s) < rem then + rem:= Length(s); + Move(s[1], strbuf[strbuflen], rem); + inc(strbuflen, rem); +end; + +procedure string_new(var str: rcstrtype; val: UnicodeString; cp: TSystemCodePage); +var + s: PStrPoolItem; +begin + New(str.v); + str.v^:= val; + str.cp:= cp; + + New(s); + s^.next:= stringpool; + s^.str:= str.v; + stringpool:= s; +end; + +procedure string_new_uni(var str: rcstrtype; val: PAnsiChar; len: integer; cp: TSystemCodePage; escapes: boolean); + function translateChar(c: AnsiChar): UnicodeChar; + var + u: UnicodeString = ''; + begin + if cp = CP_UTF16 then + Result:= c + else begin + // TODO: there has to be a better way to translate a single codepoint + widestringmanager.Ansi2UnicodeMoveProc(@c, cp, u, 1); + Result:= u[1]; + end; + end; + +var + uni: UnicodeString; + wc: PUnicodeChar; + rc, endin: PAnsiChar; + h: string; + hexlen, i: integer; +begin + uni:= ''; + if not escapes then + widestringmanager.Ansi2UnicodeMoveProc(val, cp, uni, len) + else begin + if cp = CP_UTF16 then + hexlen:= 4 + else + hexlen:= 2; + setlength(uni, len); + wc:= @uni[1]; + rc:= val; + endin:= @val[len]; + while rc < endin do begin + if (rc^ = '\') then begin + inc(rc); + case rc^ of + #0: exit {Error: End too soon}; + '\': wc^:= '\'; + 'f': wc^:= #&14; + 'n': wc^:= #&12; + 'r': wc^:= #&15; + 't': wc^:= #&11; + 'x', + 'X': begin + h:= '$'; + for i:= 1 to hexlen do begin + inc(rc); + if rc >= endin then + exit {Error: End too soon}; + h += rc^; + end; + if cp = CP_UTF16 then + wc^:= WideChar(StrToInt(h)) + else + wc^:= translateChar(Char(StrToInt(h))); + end; + '0'..'7': begin + h:= '&' + rc^; + for i:= 2 to 3 do begin + inc(rc); + if (rc >= endin) or not (rc^ in ['0'..'7']) then begin + dec(rc); + break; + end; + h += rc^; + end; + if cp = CP_UTF16 then + wc^:= WideChar(StrToInt(h)) + else + wc^:= translateChar(Char(StrToInt(h))); + end; + else + wc^:= translateChar(rc^); + end; + end else + wc^:= translateChar(rc^); + inc(wc); + inc(rc); + end; + i:= (PtrUInt(wc) - PtrUInt(@uni[1])) div SizeOf(WideChar); + SetLength(uni, i); + end; + string_new(str, uni, cp); +end; + +function Max(a, b: LongWord): LongWord; inline; +begin + if a > b then + Result:= a + else + Result:= b; +end; + +var + aktresource: TAbstractResource; + language: TLangID; + +procedure create_resource(aId, aType: TResourceDesc; aClass: TResourceClass); +var + r: TAbstractResource; +begin + r:= aClass.Create(aType, aId); + r.LangID:= language; + aktresources.Add(r); + aktresource:= r; + aId.Free; + aType.Free; +end; + +procedure create_resource(aId, aType: TResourceDesc); overload; +begin + create_resource(aId, aType, TGenericResource); +end; + +procedure create_resource(aId: TResourceDesc; aType: Word); overload; +var + cls: TResourceClass; +begin + case aType of + RT_BITMAP: cls:= TBitmapResource; + RT_ICON: cls:= TGroupIconResource; + RT_CURSOR: cls:= TGroupCursorResource; + RT_VERSION: cls:= TVersionResource; + else + raise EResourceDescTypeException.CreateFmt('Resource type not supported: %d', [aType]); + end; + create_resource(aId, nil, cls); +end; + +procedure change_lang_id(newlang: TLangID); +begin + // cannot change a language id while it is contained in a list, so remove and re-add + aktresources.Remove(aktresource); + aktresource.LangID:= newlang; + aktresources.Add(aktresource); +end; + +procedure raw_write_string(Stream: TMemoryStream; str: rcstrtype); +var + i: integer; + u: UnicodeString; + r: RawByteString = ''; +begin + u:= str.v^; + if str.cp = CP_UTF16 then begin + for i:=1 to length(u) do + Stream.WriteWord(NtoLE(Word(u[i]))); + end else begin + widestringmanager.Unicode2AnsiMoveProc(@u[1], r, str.cp, Length(u)); + Stream.WriteBuffer(r[1], Length(r)); + end; +end; + +procedure raw_write_int(Stream: TMemoryStream; num: rcnumtype); +begin + if num.long then + Stream.WriteDWord(NtoLE(num.v)) + else + Stream.WriteWord(NtoLE(Word(num.v))); +end; + +procedure stringtable_begin(); +begin + // create dummy resource that we will use to capture suboptions + create_resource(TResourceDesc.create(1), TResourceDesc.create(1)); + aktresources.Remove(aktresource); +end; + +procedure stringtable_add(ident: Word; str: AnsiString); +var + table: word; + r: TStringTableResource; +begin + table:= (ident div 16) + 1; + try + { TODO : This is stupid } + r:= aktresources.Find(RT_STRING, table, aktresource.LangID) as TStringTableResource; + except + on e: EResourceNotFoundException do begin + r:= TStringTableResource.Create; + r.LangID:= aktresource.LangID; + r.MemoryFlags:= aktresource.MemoryFlags; + r.Characteristics:= aktresource.Characteristics; + r.Version:= aktresource.Version; + r.FirstID:= ident; + aktresources.Add(r); + end; + end; + r.Strings[ident]:= str; +end; + +procedure stringtable_end(); +begin + FreeAndNil(aktresource); +end; + +function make_version(a, b, c, d: Word): TFileProductVersion; +begin + Result[0]:= a; + Result[1]:= b; + Result[2]:= c; + Result[3]:= d; +end; + +procedure version_string_tab_begin(lcs: AnsiString); +var + vst: TVersionStringTable; +begin + vst:= TVersionStringTable.Create(lcs); + TVersionResource(aktresource).StringFileInfo.Add(vst); +end; + +procedure version_string_tab_add(key, value: AnsiString); +begin + TVersionResource(aktresource).StringFileInfo.Items[TVersionResource(aktresource).StringFileInfo.Count-1].Add(key, value); +end; + +procedure version_var_translation_add(langid, cpid: word); +var + ti: TVerTranslationInfo; +begin + ti.language:= langid; + ti.codepage:= cpid; + TVersionResource(aktresource).VarFileInfo.Add(ti); +end; + +procedure SetDefaults; +begin + language:= $0409; // MS RC starts up as en-US + PragmaCodePage('DEFAULT'); +end; + +procedure DisposePools; +var + s: PStrPoolItem; +begin + while stringpool <> nil do begin + s:= stringpool; + stringpool:= s^.next; + dispose(s^.str); + dispose(s); + end; +end; + diff --git a/packages/fcl-res/src/rcreader.pp b/packages/fcl-res/src/rcreader.pp new file mode 100644 index 0000000000..d63b35f0b9 --- /dev/null +++ b/packages/fcl-res/src/rcreader.pp @@ -0,0 +1,133 @@ +{ + This file is part of the Free Pascal run time library. + Copyright (c) 2008 by Giulio Bernardi + + Resource reader/compiler for MS RC script files + + See the file COPYING.FPC, included in this distribution, + for details about the copyright. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + + **********************************************************************} + +unit rcreader; + +{$MODE OBJFPC} {$H+} + +interface + +uses + Classes, SysUtils, resource; + +type + + { TRCResourceReader } + + TRCResourceReader = class(TAbstractResourceReader) + private + fExtensions : string; + fDescription : string; + fRCIncludeDirs: TStringList; + fRCDefines: TStringList; + protected + function GetExtensions : string; override; + function GetDescription : string; override; + procedure Load(aResources : TResources; aStream : TStream); override; + function CheckMagic(aStream : TStream) : boolean; override; + procedure ReadRCFile(aResources : TResources; aLocation: String; aStream : TStream); + public + constructor Create; override; + destructor Destroy; override; + property RCIncludeDirs: TStringList read fRCIncludeDirs; + property RCDefines: TStringList read fRCDefines; + end; + +implementation + +uses + StreamIO, resdatastream, resfactory, lexlib, rcparser; + +{ TRCResourceReader } + +function TRCResourceReader.GetExtensions: string; +begin + Result:=fExtensions; +end; + +function TRCResourceReader.GetDescription: string; +begin + Result:=fDescription; +end; + +procedure TRCResourceReader.Load(aResources: TResources; aStream: TStream); +var + fd: String; +begin + if aStream is TFileStream then + fd:= ExtractFilePath(TFileStream(aStream).FileName) + else + fd:= IncludeTrailingPathDelimiter(GetCurrentDir); + try + ReadRCFile(aResources, fd, aStream); + except + on e : EReadError do + raise EResourceReaderUnexpectedEndOfStreamException.Create(''); + end; +end; + +function TRCResourceReader.CheckMagic(aStream: TStream): boolean; +begin + { TODO : Check for Text-Only file } + Result:= True; +end; + +procedure TRCResourceReader.ReadRCFile(aResources: TResources; aLocation: String; aStream: TStream); +var + i: Integer; +begin + AssignStream(lexlib.yyinput, aStream); + Reset(lexlib.yyinput); + try + rcparser.yyfilename:= '#MAIN.RC'; + rcparser.SetDefaults; + SetTextCodePage(lexlib.yyinput, rcparser.opt_code_page); + rcparser.yinclude:= tyinclude.Create; + rcparser.yinclude.WorkDir:= aLocation; + rcparser.yinclude.SearchPaths.Assign(fRCIncludeDirs); + rcparser.ypreproc:= typreproc.Create; + rcparser.ypreproc.Defines.Add('RC_INVOKED', ''); + for i:= 0 to fRCDefines.Count-1 do + rcparser.ypreproc.Defines.KeyData[fRCDefines.Names[i]]:= fRCDefines.ValueFromIndex[i]; + rcparser.aktresources:= aResources; + if rcparser.yyparse <> 0 then + raise EReadError.Create('Parse Error'); + finally + rcparser.DisposePools; + FreeAndNil(rcparser.ypreproc); + FreeAndNil(rcparser.yinclude); + end; +end; + +constructor TRCResourceReader.Create; +begin + fExtensions:='.rc'; + fDescription:='RC script resource reader'; + fRCDefines:= TStringList.Create; + fRCIncludeDirs:= TStringList.Create; +end; + +destructor TRCResourceReader.Destroy; +begin + fRCIncludeDirs.Free; + fRCDefines.Free; + inherited; +end; + +initialization + { don't register automatically, as this is essentially a "catch all" } + //TResources.RegisterReader('.rc',TRCResourceReader); + +end. diff --git a/packages/fcl-res/src/resource.pp b/packages/fcl-res/src/resource.pp index 0638880ee8..224bf0e461 100644 --- a/packages/fcl-res/src/resource.pp +++ b/packages/fcl-res/src/resource.pp @@ -44,6 +44,7 @@ const RT_ANIICON = 22; //Animated icon. RT_HTML = 23; //HTML. RT_MANIFEST = 24; //Microsoft Windows XP: Side-by-Side Assembly XML Manifest. + RT_DLGINIT = 240; //Never present in compiled form CREATEPROCESS_MANIFEST_RESOURCE_ID = 1; ISOLATIONAWARE_MANIFEST_RESOURCE_ID = 2; diff --git a/packages/fcl-res/src/stringtableresource.pp b/packages/fcl-res/src/stringtableresource.pp index 76f3009388..6e0c212802 100644 --- a/packages/fcl-res/src/stringtableresource.pp +++ b/packages/fcl-res/src/stringtableresource.pp @@ -21,13 +21,13 @@ interface uses Classes, SysUtils, resource; - + type EStringTableResourceException = class(EResourceException); EStringTableNameNotAllowedException = class(EStringTableResourceException); EStringTableIndexOutOfBoundsException = class(EStringTableResourceException); - + resourcestring SNameNotAllowed = 'Resource ID must be an ordinal in the range 1-4096'; SIndexOutOfBounds = 'String ID out of bounds: %d'; @@ -42,7 +42,7 @@ type fName : TResourceDesc; fFirstID : word; fCount : integer; - fList : TStringList; + fList : array of UnicodeString; fCanChangeDesc : boolean; function IDtoIndex(const aId : word) : integer; procedure CheckListLoaded; @@ -85,54 +85,47 @@ end; procedure TStringTableResource.CheckListLoaded; var i : integer; begin - if fList<>nil then exit; - fList:=TStringList.Create; - fList.Capacity:=16; + if Length(fList) <> 0 then exit; + SetLength(fList, fCount); + for i:=0 to high(fList) do + fList[i]:= ''; if RawData.Size=0 then exit; RawData.Position:=0; - for i:=0 to 15 do - fList.Add(ReadWideString); + for i:=0 to high(fList) do + fList[i]:= ReadWideString; end; function TStringTableResource.ReadWideString: string; -var ws : widestring; +var ws : unicodestring; w : word; i : integer; begin RawData.ReadBuffer(w,2); - {$IFDEF ENDIAN_BIG} - w:=SwapEndian(w); - {$ENDIF} + w:= LEtoN(w); setlength(ws,w); for i:=1 to length(ws) do begin RawData.ReadBuffer(w,2); - {$IFDEF ENDIAN_BIG} - w:=SwapEndian(w); - {$ENDIF} + w:= LEtoN(w); ws[i]:=widechar(w); end; Result:=ws; end; procedure TStringTableResource.WriteWideString(const aString: string); -var ws : widestring; +var ws : unicodestring; w : word; i : integer; begin w:=length(aString); - {$IFDEF ENDIAN_BIG} - w:=SwapEndian(w); - {$ENDIF} + w:= NtoLE(w); RawData.WriteBuffer(w,2); ws:=aString; for i:=1 to length(ws) do begin w:=word(ws[i]); - {$IFDEF ENDIAN_BIG} - w:=SwapEndian(w); - {$ENDIF} + w:= NtoLE(w); RawData.WriteBuffer(w,2); end; end; @@ -157,8 +150,8 @@ begin CheckIndex(id); CheckListLoaded; idx:=IDtoIndex(id); - if idx>=fList.Count then Result:='' - else Result:=fList[idx]; + if idx>high(fList) then Result:= '' + else Result:= fList[idx]; end; procedure TStringTableResource.SetString(id: word; aString: string); @@ -167,13 +160,7 @@ begin CheckIndex(id); CheckListLoaded; idx:=IDtoIndex(id); - if idx=fList.Count then - begin - for i:=fList.Count to idx-1 do - fList.Add(''); - fList.Add(aString); - end; + fList[idx]:= aString; end; procedure TStringTableResource.UpdateRawData; @@ -184,7 +171,7 @@ begin RawData.Position:=0; for i:=FirstID to LastID do WriteWideString(Strings[i]); - FreeAndNil(fList); + fList:= nil; end; function TStringTableResource.GetType: TResourceDesc; @@ -223,7 +210,7 @@ constructor TStringTableResource.Create; begin inherited Create; fCanChangeDesc:=false; - fList:=nil; + fList:= nil; fType:=TResourceDesc.Create(RT_STRING); fName:=TResourceDesc.Create(1); fCount:=16; @@ -248,8 +235,7 @@ destructor TStringTableResource.Destroy; begin fType.Free; fName.Free; - if fList<>nil then - fList.Free; + SetLength(fList, 0); inherited Destroy; end; diff --git a/packages/fcl-res/src/yyinclude.pp b/packages/fcl-res/src/yyinclude.pp new file mode 100644 index 0000000000..73a928ef0f --- /dev/null +++ b/packages/fcl-res/src/yyinclude.pp @@ -0,0 +1,127 @@ +{%MainUnit rcparser.pas} + +{$IFDEF INC_HEADER} + +type + tyinclude = class + const + yi_maxlevels = 5; + var + stack: array[0..yi_maxlevels] of record + yyinput : Text; (* input and output file *) + yyline : String; (* current input line *) + yylineno, yycolno : Integer; (* current input position *) + fn : AnsiString; + prev_wrap : yywrap_t; + end; + level: integer; + WorkDir: string; + SearchPaths: TStringList; + public + constructor Create; + destructor Destroy; override; + class function wrapone(): Boolean; static; + function push(const incfile: ansistring): Boolean; + function pop(): Boolean; + function expand(fn: AnsiString): AnsiString; + end; + +var + yinclude: tyinclude; + +{$ELSE} + +class function tyinclude.wrapone(): Boolean; +begin + Result:= yinclude.pop; +end; + +function tyinclude.push(const incfile: ansistring): Boolean; +begin + stack[level].yyinput:= yyinput; + stack[level].yyline:= yyline; + stack[level].yylineno:= yylineno; + stack[level].yycolno:= yycolno; + stack[level].prev_wrap:= yywrap; + stack[level].fn:= yyfilename; + inc(level); + yywrap:= @tyinclude.wrapone; + AssignFile(yyinput, incfile); + Reset(yyinput); + yyfilename:= incfile; + yyline:= ''; + yylineno:= 0; + yycolno:= 0; + {$if declared(ypreproc)} + ypreproc.newfile(yyfilename); + {$endif} + Result:= true; +end; + +function tyinclude.pop(): Boolean; +begin + Close(yyinput); + Result:= level = 0; + if not Result then begin + Dec(level); + yyinput:= stack[level].yyinput; + yyline:= stack[level].yyline; + yylineno:= stack[level].yylineno; + yycolno:= stack[level].yycolno; + yywrap:= stack[level].prev_wrap; + yyfilename:= stack[level].fn; + {$if declared(ypreproc)} + ypreproc.newfile(yyfilename); + {$endif} + end; +end; + +function tyinclude.expand(fn: AnsiString): AnsiString; +var + i: integer; + f: string; +begin + result:= ''; + if Length(fn) > 3 then begin + if (fn[1] = '<') and (fn[length(fn)] = '>') then begin + fn:= copy(fn, 2, Length(fn)-2); + for i:= 0 to SearchPaths.Count - 1 do begin + f:= ConcatPaths([SearchPaths[i], fn]); + if FileExists(f) then + Exit(f); + end; + yyerror('Include file not found on search paths: <'+fn+'>'); + end + else if (fn[1] = '"') and (fn[length(fn)] = '"') then begin + fn:= copy(fn, 2, Length(fn)-2); + f:= ConcatPaths([WorkDir, fn]); + if FileExists(f) then + Exit(f); + if fn = 'windows.h' then begin + // treat windows.h as an alias for windres.h + f:= ConcatPaths([WorkDir, 'windres.h']); + if FileExists(f) then + Exit(f); + end; + yyerror('Include file not found: "'+fn+'"'); + end; + end; + yyerror('Invalid include directive: "'+fn+'"'); +end; + +constructor tyinclude.Create; +begin + inherited Create; + level:= 0; + WorkDir:= GetCurrentDir; + SearchPaths:= TStringList.Create; +end; + +destructor tyinclude.Destroy; +begin + FreeAndNil(SearchPaths); + inherited; +end; + +{$ENDIF} + diff --git a/packages/fcl-res/src/yypreproc.pp b/packages/fcl-res/src/yypreproc.pp new file mode 100644 index 0000000000..4dcfbb8263 --- /dev/null +++ b/packages/fcl-res/src/yypreproc.pp @@ -0,0 +1,160 @@ +{%MainUnit rcparser.pas} + +{$IFDEF INC_HEADER} + +type + typreproc = class + const + yp_maxlevels = 16; + var + Defines: TStringHashTable; + skip : array[0..yp_maxlevels-1] of boolean; + cheadermode: boolean; + level : longint; + public + constructor Create; + destructor Destroy; override; + function isdefine(ident: string): boolean; + function getdefine(ident: string): string; + function useline(line: string): boolean; + procedure newfile(fn: string); + end; + +var + ypreproc: typreproc; + +{$ELSE} + +constructor typreproc.Create; +begin + inherited Create; + Defines:= TStringHashTable.Create; + level:= 0; + cheadermode:= false; + fillchar(skip,sizeof(skip),0); +end; + +destructor typreproc.Destroy; +begin + FreeAndNil(Defines); + inherited; +end; + +function Copy2SpaceDelTrim(var s: string): string; +const + whitespace = [#9, ' ']; +var + p: integer; +begin + p:= PosSet(whitespace, s); + if p <= 0 then begin + result:= s; + s:= ''; + end else begin + result:= Copy(S, 1, p-1); + while (p < Length(s)) and (s[p] in whitespace) do + inc(p); + Delete(s, 1, p-1); + end; +end; + +function Substring(s: string; First, Last: integer): string; +begin + Result:= Copy(s, First, Last-First+1); +end; + +function typreproc.isdefine(ident: string): boolean; +begin + Result:= Defines.IndexOf(ident) >= 0; +end; + +function typreproc.getdefine(ident: string): string; +begin + Result:= Defines[ident]; +end; + +function typreproc.useline(line: string): boolean; +var + w, word, arg1: string; +begin + Result:= true; + w:= trim(line); + if (yystate <= 1) and + (Length(w) > 2) and (w[1] = '#') then begin + Delete(w, 1, 1); + word:= Copy2SpaceDelTrim(w); + case word of + 'ifdef': begin + inc(Level); + if Level >= yp_maxlevels then begin + yyerror('Too many ifdef levels'); + exit; + end; + skip[level]:= (skip[level-1] or (not isdefine(w))); + end; + 'ifndef': begin + inc(Level); + if Level >= yp_maxlevels then begin + yyerror('Too many ifdef levels'); + exit; + end; + skip[level]:= (skip[level-1] or (isdefine(w))); + end; + 'if': begin + inc(Level); + if Level >= yp_maxlevels then begin + yyerror('Too many ifdef levels'); + exit; + end; + { TODO : implement some expressions? for now, always returns false } + skip[level]:= (skip[level-1] or False); + end; + 'else': begin + skip[level]:= skip[level-1] or (not skip[level]); + end; + 'endif': begin + skip[level]:= false; + if Level = 0 then begin + yyerror('Too many endif found'); + exit; + end; + dec(level); + end; + else + if not skip[level] then + case word of + 'pragma': begin + if StartsStr('code_page(', w) then begin + arg1:= Substring(w, Length('code_page(') + 1, Pos(')', w) - 1); + PragmaCodePage(arg1); + end; + end; + 'define': begin + arg1:= Copy2SpaceDelTrim(w); + Defines[arg1]:= w; + end; + 'undef': begin + Defines.Remove(w); + end; + 'include': begin + arg1:= yinclude.expand(w); + yinclude.push(arg1); + end; + end; + end; + Result:= false; + end else begin + Result:= (not cheadermode) and (not skip[level]); + end; +end; + +procedure typreproc.newfile(fn: string); +var + ex: String; +begin + ex:= UpperCase(ExtractFileExt(yyfilename)); + cheadermode:= (ex = '.C') or (ex = '.H'); +end; + + +{$ENDIF} diff --git a/packages/fpmake_add.inc b/packages/fpmake_add.inc index 10d8383d89..69f4182224 100644 --- a/packages/fpmake_add.inc +++ b/packages/fpmake_add.inc @@ -118,6 +118,7 @@ add_syslog(ADirectory+IncludeTrailingPathDelimiter('syslog')); add_tcl(ADirectory+IncludeTrailingPathDelimiter('tcl')); add_tosunits(ADirectory+IncludeTrailingPathDelimiter('tosunits')); + add_tplylib(ADirectory+IncludeTrailingPathDelimiter('tplylib')); add_univint(ADirectory+IncludeTrailingPathDelimiter('univint')); add_unixutil(ADirectory+IncludeTrailingPathDelimiter('unixutil')); add_unzip(ADirectory+IncludeTrailingPathDelimiter('unzip')); diff --git a/packages/fpmake_proc.inc b/packages/fpmake_proc.inc index 34756b0cee..d1f8cc806b 100644 --- a/packages/fpmake_proc.inc +++ b/packages/fpmake_proc.inc @@ -679,6 +679,12 @@ begin {$include tosunits/fpmake.pp} end; +procedure add_tplylib(const ADirectory: string); +begin + with Installer do +{$include tplylib/fpmake.pp} +end; + procedure add_univint(const ADirectory: string); begin with Installer do diff --git a/packages/tplylib/Makefile b/packages/tplylib/Makefile new file mode 100644 index 0000000000..d9b9a13657 --- /dev/null +++ b/packages/tplylib/Makefile @@ -0,0 +1,2745 @@ +# +# Don't edit, this file is generated by FPCMake Version 2.0.0 +# +default: all +MAKEFILETARGETS=i386-linux i386-go32v2 i386-win32 i386-os2 i386-freebsd i386-beos i386-haiku i386-netbsd i386-solaris i386-netware i386-openbsd i386-wdosx i386-darwin i386-emx i386-watcom i386-netwlibc i386-wince i386-embedded i386-symbian i386-nativent i386-iphonesim i386-android i386-aros m68k-linux m68k-netbsd m68k-amiga m68k-atari m68k-palmos m68k-macosclassic m68k-embedded powerpc-linux powerpc-netbsd powerpc-amiga powerpc-macosclassic powerpc-darwin powerpc-morphos powerpc-embedded powerpc-wii powerpc-aix sparc-linux sparc-netbsd sparc-solaris sparc-embedded x86_64-linux x86_64-freebsd x86_64-haiku x86_64-netbsd x86_64-solaris x86_64-openbsd x86_64-darwin x86_64-win64 x86_64-embedded x86_64-iphonesim x86_64-android x86_64-aros x86_64-dragonfly arm-linux arm-netbsd arm-palmos arm-wince arm-gba arm-nds arm-embedded arm-symbian arm-android arm-aros arm-freertos arm-ios powerpc64-linux powerpc64-darwin powerpc64-embedded powerpc64-aix avr-embedded armeb-linux armeb-embedded mips-linux mipsel-linux mipsel-embedded mipsel-android mips64el-linux jvm-java jvm-android i8086-embedded i8086-msdos i8086-win16 aarch64-linux aarch64-darwin aarch64-win64 aarch64-android aarch64-ios wasm-wasm sparc64-linux riscv32-linux riscv32-embedded riscv64-linux riscv64-embedded xtensa-linux xtensa-embedded xtensa-freertos z80-embedded z80-zxspectrum z80-msxdos z80-amstradcpc +BSDs = freebsd netbsd openbsd darwin dragonfly +UNIXs = linux $(BSDs) solaris qnx haiku aix +LIMIT83fs = go32v2 os2 emx watcom msdos win16 atari +OSNeedsComspecToRunBatch = go32v2 watcom +FORCE: +.PHONY: FORCE +override PATH:=$(patsubst %/,%,$(subst \,/,$(PATH))) +ifneq ($(findstring darwin,$(OSTYPE)),) +inUnix=1 #darwin +SEARCHPATH:=$(filter-out .,$(subst :, ,$(PATH))) +else +ifeq ($(findstring ;,$(PATH)),) +inUnix=1 +SEARCHPATH:=$(filter-out .,$(subst :, ,$(PATH))) +else +SEARCHPATH:=$(subst ;, ,$(PATH)) +endif +endif +SEARCHPATH+=$(patsubst %/,%,$(subst \,/,$(dir $(MAKE)))) +PWD:=$(strip $(wildcard $(addsuffix /pwd.exe,$(SEARCHPATH)))) +ifeq ($(PWD),) +PWD:=$(strip $(wildcard $(addsuffix /pwd,$(SEARCHPATH)))) +ifeq ($(PWD),) +$(error You need the GNU utils package to use this Makefile) +else +PWD:=$(firstword $(PWD)) +SRCEXEEXT= +endif +else +PWD:=$(firstword $(PWD)) +SRCEXEEXT=.exe +endif +ifndef inUnix +ifeq ($(OS),Windows_NT) +inWinNT=1 +else +ifdef OS2_SHELL +inOS2=1 +endif +endif +else +ifneq ($(findstring cygdrive,$(PATH)),) +inCygWin=1 +endif +endif +ifdef inUnix +SRCBATCHEXT=.sh +else +ifdef inOS2 +SRCBATCHEXT=.cmd +else +SRCBATCHEXT=.bat +endif +endif +ifdef COMSPEC +ifneq ($(findstring $(OS_SOURCE),$(OSNeedsComspecToRunBatch)),) +ifndef RUNBATCH +RUNBATCH=$(COMSPEC) /C +endif +endif +endif +ifdef inUnix +PATHSEP=/ +else +PATHSEP:=$(subst /,\,/) +ifdef inCygWin +PATHSEP=/ +endif +endif +ifdef PWD +BASEDIR:=$(subst \,/,$(shell $(PWD))) +ifdef inCygWin +ifneq ($(findstring /cygdrive/,$(BASEDIR)),) +BASENODIR:=$(patsubst /cygdrive%,%,$(BASEDIR)) +BASEDRIVE:=$(firstword $(subst /, ,$(BASENODIR))) +BASEDIR:=$(subst /cygdrive/$(BASEDRIVE)/,$(BASEDRIVE):/,$(BASEDIR)) +endif +endif +else +BASEDIR=. +endif +ifdef inOS2 +ifndef ECHO +ECHO:=$(strip $(wildcard $(addsuffix /gecho$(SRCEXEEXT),$(SEARCHPATH)))) +ifeq ($(ECHO),) +ECHO:=$(strip $(wildcard $(addsuffix /echo$(SRCEXEEXT),$(SEARCHPATH)))) +ifeq ($(ECHO),) +ECHO=echo +else +ECHO:=$(firstword $(ECHO)) +endif +else +ECHO:=$(firstword $(ECHO)) +endif +endif +export ECHO +endif +override DEFAULT_FPCDIR=../.. +ifndef FPC +ifdef PP +FPC=$(PP) +endif +endif +ifndef FPC +FPCPROG:=$(strip $(wildcard $(addsuffix /fpc$(SRCEXEEXT),$(SEARCHPATH)))) +ifneq ($(FPCPROG),) +FPCPROG:=$(firstword $(FPCPROG)) +ifneq ($(CPU_TARGET),) +FPC:=$(shell $(FPCPROG) -P$(CPU_TARGET) -PB) +else +FPC:=$(shell $(FPCPROG) -PB) +endif +ifneq ($(findstring Error,$(FPC)),) +override FPC=$(firstword $(strip $(wildcard $(addsuffix /ppc386$(SRCEXEEXT),$(SEARCHPATH))))) +else +ifeq ($(strip $(wildcard $(FPC))),) +FPC:=$(firstword $(FPCPROG)) +endif +endif +else +override FPC=$(firstword $(strip $(wildcard $(addsuffix /ppc386$(SRCEXEEXT),$(SEARCHPATH))))) +endif +endif +override FPC:=$(subst $(SRCEXEEXT),,$(FPC)) +override FPC:=$(subst \,/,$(FPC))$(SRCEXEEXT) +FOUNDFPC:=$(strip $(wildcard $(FPC))) +ifeq ($(FOUNDFPC),) +FOUNDFPC=$(strip $(wildcard $(addsuffix /$(FPC),$(SEARCHPATH)))) +ifeq ($(FOUNDFPC),) +$(error Compiler $(FPC) not found) +endif +endif +ifndef FPC_COMPILERINFO +FPC_COMPILERINFO:=$(shell $(FPC) -iVSPTPSOTO) +endif +ifndef FPC_VERSION +FPC_VERSION:=$(word 1,$(FPC_COMPILERINFO)) +endif +export FPC FPC_VERSION FPC_COMPILERINFO +unexport CHECKDEPEND ALLDEPENDENCIES +ifndef CPU_TARGET +ifdef CPU_TARGET_DEFAULT +CPU_TARGET=$(CPU_TARGET_DEFAULT) +endif +endif +ifndef OS_TARGET +ifdef OS_TARGET_DEFAULT +OS_TARGET=$(OS_TARGET_DEFAULT) +endif +endif +ifndef CPU_SOURCE +CPU_SOURCE:=$(word 2,$(FPC_COMPILERINFO)) +endif +ifndef CPU_TARGET +CPU_TARGET:=$(word 3,$(FPC_COMPILERINFO)) +endif +ifndef OS_SOURCE +OS_SOURCE:=$(word 4,$(FPC_COMPILERINFO)) +endif +ifndef OS_TARGET +OS_TARGET:=$(word 5,$(FPC_COMPILERINFO)) +endif +FULL_TARGET=$(CPU_TARGET)-$(OS_TARGET) +FULL_SOURCE=$(CPU_SOURCE)-$(OS_SOURCE) +ifeq ($(CPU_TARGET),armeb) +ARCH=arm +override FPCOPT+=-Cb +else +ifeq ($(CPU_TARGET),armel) +ARCH=arm +override FPCOPT+=-CaEABI +else +ARCH=$(CPU_TARGET) +endif +endif +ifeq ($(FULL_TARGET),arm-embedded) +ifeq ($(SUBARCH),) +$(error When compiling for arm-embedded, a sub-architecture (e.g. SUBARCH=armv4t or SUBARCH=armv7m) must be defined) +endif +override FPCOPT+=-Cp$(SUBARCH) +endif +ifeq ($(FULL_TARGET),avr-embedded) +ifeq ($(SUBARCH),) +$(error When compiling for avr-embedded, a sub-architecture (e.g. SUBARCH=avr25 or SUBARCH=avr35) must be defined) +endif +override FPCOPT+=-Cp$(SUBARCH) +endif +ifeq ($(FULL_TARGET),mipsel-embedded) +ifeq ($(SUBARCH),) +$(error When compiling for mipsel-embedded, a sub-architecture (e.g. SUBARCH=pic32mx) must be defined) +endif +override FPCOPT+=-Cp$(SUBARCH) +endif +ifeq ($(FULL_TARGET),xtensa-embedded) +ifeq ($(SUBARCH),) +$(error When compiling for xtensa-embedded, a sub-architecture (e.g. SUBARCH=lx106 or SUBARCH=lx6) must be defined) +endif +override FPCOPT+=-Cp$(SUBARCH) +endif +ifeq ($(FULL_TARGET),xtensa-freertos) +ifeq ($(SUBARCH),) +$(error When compiling for xtensa-freertos, a sub-architecture (e.g. SUBARCH=lx106 or SUBARCH=lx6) must be defined) +endif +override FPCOPT+=-Cp$(SUBARCH) +endif +ifeq ($(FULL_TARGET),arm-freertos) +ifeq ($(SUBARCH),) +$(error When compiling for arm-freertos, a sub-architecture (e.g. SUBARCH=armv6m or SUBARCH=armv7em) must be defined) +endif +override FPCOPT+=-Cp$(SUBARCH) +endif +ifneq ($(findstring $(OS_SOURCE),$(LIMIT83fs)),) +TARGETSUFFIX=$(OS_TARGET) +SOURCESUFFIX=$(OS_SOURCE) +else +ifneq ($(findstring $(OS_TARGET),$(LIMIT83fs)),) +TARGETSUFFIX=$(OS_TARGET) +else +TARGETSUFFIX=$(FULL_TARGET) +endif +SOURCESUFFIX=$(FULL_SOURCE) +endif +ifneq ($(FULL_TARGET),$(FULL_SOURCE)) +CROSSCOMPILE=1 +endif +ifeq ($(findstring makefile,$(MAKECMDGOALS)),) +ifeq ($(findstring $(FULL_TARGET),$(MAKEFILETARGETS)),) +$(error The Makefile doesn't support target $(FULL_TARGET), please run fpcmake first) +endif +endif +ifneq ($(findstring $(OS_TARGET),$(BSDs)),) +BSDhier=1 +endif +ifeq ($(OS_TARGET),linux) +linuxHier=1 +endif +ifndef CROSSCOMPILE +BUILDFULLNATIVE=1 +export BUILDFULLNATIVE +endif +ifdef BUILDFULLNATIVE +BUILDNATIVE=1 +export BUILDNATIVE +endif +export OS_TARGET OS_SOURCE ARCH CPU_TARGET CPU_SOURCE FULL_TARGET FULL_SOURCE TARGETSUFFIX SOURCESUFFIX CROSSCOMPILE +ifdef FPCDIR +override FPCDIR:=$(subst \,/,$(FPCDIR)) +ifeq ($(wildcard $(addprefix $(FPCDIR)/,rtl)),) +override FPCDIR=wrong +endif +else +override FPCDIR=wrong +endif +ifdef DEFAULT_FPCDIR +ifeq ($(FPCDIR),wrong) +override FPCDIR:=$(subst \,/,$(DEFAULT_FPCDIR)) +ifeq ($(wildcard $(addprefix $(FPCDIR)/,rtl)),) +override FPCDIR=wrong +endif +endif +endif +ifeq ($(FPCDIR),wrong) +ifdef inUnix +override FPCDIR=/usr/local/lib/fpc/$(FPC_VERSION) +ifeq ($(wildcard $(FPCDIR)/units),) +override FPCDIR=/usr/lib/fpc/$(FPC_VERSION) +endif +else +override FPCDIR:=$(subst /$(FPC),,$(firstword $(strip $(wildcard $(addsuffix /$(FPC),$(SEARCHPATH)))))) +override FPCDIR:=$(FPCDIR)/.. +ifeq ($(wildcard $(addprefix $(FPCDIR)/,rtl)),) +override FPCDIR:=$(FPCDIR)/.. +ifeq ($(wildcard $(addprefix $(FPCDIR)/,rtl)),) +override FPCDIR:=$(BASEDIR) +ifeq ($(wildcard $(addprefix $(FPCDIR)/,rtl)),) +override FPCDIR=c:/pp +endif +endif +endif +endif +endif +ifndef CROSSBINDIR +CROSSBINDIR:=$(wildcard $(FPCDIR)/bin/$(TARGETSUFFIX)) +endif +ifneq ($(findstring $(OS_TARGET),darwin iphonesim ios),) +ifneq ($(findstring $(OS_SOURCE),darwin ios),) +DARWIN2DARWIN=1 +endif +endif +ifndef BINUTILSPREFIX +ifndef CROSSBINDIR +ifdef CROSSCOMPILE +ifneq ($(OS_TARGET),msdos) +ifndef DARWIN2DARWIN +ifneq ($(CPU_TARGET),jvm) +BINUTILSPREFIX=$(CPU_TARGET)-$(OS_TARGET)- +ifeq ($(OS_TARGET),android) +ifeq ($(CPU_TARGET),arm) +BINUTILSPREFIX=arm-linux-androideabi- +else +ifeq ($(CPU_TARGET),i386) +BINUTILSPREFIX=i686-linux-android- +else +BINUTILSPREFIX=$(CPU_TARGET)-linux-android- +endif +endif +endif +endif +endif +else +BINUTILSPREFIX=$(OS_TARGET)- +endif +endif +endif +endif +UNITSDIR:=$(wildcard $(FPCDIR)/units/$(TARGETSUFFIX)) +ifeq ($(UNITSDIR),) +UNITSDIR:=$(wildcard $(FPCDIR)/units/$(OS_TARGET)) +endif +PACKAGESDIR:=$(wildcard $(FPCDIR) $(FPCDIR)/packages) +ifndef FPCFPMAKE +ifdef CROSSCOMPILE +ifeq ($(strip $(wildcard $(addsuffix /compiler/ppc$(SRCEXEEXT),$(FPCDIR)))),) +FPCPROG:=$(strip $(wildcard $(addsuffix /fpc$(SRCEXEEXT),$(SEARCHPATH)))) +ifneq ($(FPCPROG),) +FPCPROG:=$(firstword $(FPCPROG)) +FPCFPMAKE:=$(shell $(FPCPROG) -PB) +ifeq ($(strip $(wildcard $(FPCFPMAKE))),) +FPCFPMAKE:=$(firstword $(FPCPROG)) +endif +else +override FPCFPMAKE=$(firstword $(strip $(wildcard $(addsuffix /ppc386$(SRCEXEEXT),$(SEARCHPATH))))) +endif +else +FPCFPMAKE=$(strip $(wildcard $(addsuffix /compiler/ppc$(SRCEXEEXT),$(FPCDIR)))) +FPMAKE_SKIP_CONFIG=-n +export FPCFPMAKE +export FPMAKE_SKIP_CONFIG +endif +else +FPMAKE_SKIP_CONFIG=-n +FPCFPMAKE=$(FPC) +endif +endif +override PACKAGE_NAME=tplylib +override PACKAGE_VERSION=3.3.1 +FPMAKE_BIN_CLEAN=$(wildcard ./fpmake$(SRCEXEEXT)) +ifdef OS_TARGET +FPC_TARGETOPT+=--os=$(OS_TARGET) +endif +ifdef CPU_TARGET +FPC_TARGETOPT+=--cpu=$(CPU_TARGET) +endif +LOCALFPMAKE=./fpmake$(SRCEXEEXT) +override INSTALL_FPCPACKAGE=y +ifdef REQUIRE_UNITSDIR +override UNITSDIR+=$(REQUIRE_UNITSDIR) +endif +ifdef REQUIRE_PACKAGESDIR +override PACKAGESDIR+=$(REQUIRE_PACKAGESDIR) +endif +ifdef ZIPINSTALL +ifneq ($(findstring $(OS_TARGET),$(UNIXs)),) +UNIXHier=1 +endif +else +ifneq ($(findstring $(OS_SOURCE),$(UNIXs)),) +UNIXHier=1 +endif +endif +ifndef INSTALL_PREFIX +ifdef PREFIX +INSTALL_PREFIX=$(PREFIX) +endif +endif +ifndef INSTALL_PREFIX +ifdef UNIXHier +INSTALL_PREFIX=/usr/local +else +ifdef INSTALL_FPCPACKAGE +INSTALL_BASEDIR:=/pp +else +INSTALL_BASEDIR:=/$(PACKAGE_NAME) +endif +endif +endif +export INSTALL_PREFIX +ifdef INSTALL_FPCSUBDIR +export INSTALL_FPCSUBDIR +endif +ifndef DIST_DESTDIR +DIST_DESTDIR:=$(BASEDIR) +endif +export DIST_DESTDIR +ifndef COMPILER_UNITTARGETDIR +ifdef PACKAGEDIR_MAIN +COMPILER_UNITTARGETDIR=$(PACKAGEDIR_MAIN)/units/$(TARGETSUFFIX) +else +COMPILER_UNITTARGETDIR=units/$(TARGETSUFFIX) +endif +endif +ifndef COMPILER_TARGETDIR +COMPILER_TARGETDIR=. +endif +ifndef INSTALL_BASEDIR +ifdef UNIXHier +ifdef INSTALL_FPCPACKAGE +INSTALL_BASEDIR:=$(INSTALL_PREFIX)/lib/fpc/$(FPC_VERSION) +else +INSTALL_BASEDIR:=$(INSTALL_PREFIX)/lib/$(PACKAGE_NAME) +endif +else +INSTALL_BASEDIR:=$(INSTALL_PREFIX) +endif +endif +ifndef INSTALL_BINDIR +ifdef UNIXHier +INSTALL_BINDIR:=$(INSTALL_PREFIX)/bin +else +INSTALL_BINDIR:=$(INSTALL_BASEDIR)/bin +ifdef INSTALL_FPCPACKAGE +ifdef CROSSCOMPILE +ifdef CROSSINSTALL +INSTALL_BINDIR:=$(INSTALL_BINDIR)/$(SOURCESUFFIX) +else +INSTALL_BINDIR:=$(INSTALL_BINDIR)/$(TARGETSUFFIX) +endif +else +INSTALL_BINDIR:=$(INSTALL_BINDIR)/$(TARGETSUFFIX) +endif +endif +endif +endif +ifndef INSTALL_UNITDIR +INSTALL_UNITDIR:=$(INSTALL_BASEDIR)/units/$(TARGETSUFFIX) +ifdef INSTALL_FPCPACKAGE +ifdef PACKAGE_NAME +INSTALL_UNITDIR:=$(INSTALL_UNITDIR)/$(PACKAGE_NAME) +endif +endif +endif +ifndef INSTALL_LIBDIR +ifdef UNIXHier +INSTALL_LIBDIR:=$(INSTALL_PREFIX)/lib +else +INSTALL_LIBDIR:=$(INSTALL_UNITDIR) +endif +endif +ifndef INSTALL_SOURCEDIR +ifdef UNIXHier +ifdef BSDhier +SRCPREFIXDIR=share/src +else +ifdef linuxHier +SRCPREFIXDIR=share/src +else +SRCPREFIXDIR=src +endif +endif +ifdef INSTALL_FPCPACKAGE +ifdef INSTALL_FPCSUBDIR +INSTALL_SOURCEDIR:=$(INSTALL_PREFIX)/$(SRCPREFIXDIR)/fpc-$(FPC_VERSION)/$(INSTALL_FPCSUBDIR)/$(PACKAGE_NAME) +else +INSTALL_SOURCEDIR:=$(INSTALL_PREFIX)/$(SRCPREFIXDIR)/fpc-$(FPC_VERSION)/$(PACKAGE_NAME) +endif +else +INSTALL_SOURCEDIR:=$(INSTALL_PREFIX)/$(SRCPREFIXDIR)/$(PACKAGE_NAME)-$(PACKAGE_VERSION) +endif +else +ifdef INSTALL_FPCPACKAGE +ifdef INSTALL_FPCSUBDIR +INSTALL_SOURCEDIR:=$(INSTALL_BASEDIR)/source/$(INSTALL_FPCSUBDIR)/$(PACKAGE_NAME) +else +INSTALL_SOURCEDIR:=$(INSTALL_BASEDIR)/source/$(PACKAGE_NAME) +endif +else +INSTALL_SOURCEDIR:=$(INSTALL_BASEDIR)/source +endif +endif +endif +ifndef INSTALL_DOCDIR +ifdef UNIXHier +ifdef BSDhier +DOCPREFIXDIR=share/doc +else +ifdef linuxHier +DOCPREFIXDIR=share/doc +else +DOCPREFIXDIR=doc +endif +endif +ifdef INSTALL_FPCPACKAGE +INSTALL_DOCDIR:=$(INSTALL_PREFIX)/$(DOCPREFIXDIR)/fpc-$(FPC_VERSION)/$(PACKAGE_NAME) +else +INSTALL_DOCDIR:=$(INSTALL_PREFIX)/$(DOCPREFIXDIR)/$(PACKAGE_NAME)-$(PACKAGE_VERSION) +endif +else +ifdef INSTALL_FPCPACKAGE +INSTALL_DOCDIR:=$(INSTALL_BASEDIR)/doc/$(PACKAGE_NAME) +else +INSTALL_DOCDIR:=$(INSTALL_BASEDIR)/doc +endif +endif +endif +ifndef INSTALL_EXAMPLEDIR +ifdef UNIXHier +ifdef INSTALL_FPCPACKAGE +ifdef BSDhier +INSTALL_EXAMPLEDIR:=$(INSTALL_PREFIX)/share/examples/fpc-$(FPC_VERSION)/$(PACKAGE_NAME) +else +ifdef linuxHier +INSTALL_EXAMPLEDIR:=$(INSTALL_DOCDIR)/examples +else +INSTALL_EXAMPLEDIR:=$(INSTALL_PREFIX)/doc/fpc-$(FPC_VERSION)/examples/$(PACKAGE_NAME) +endif +endif +else +ifdef BSDhier +INSTALL_EXAMPLEDIR:=$(INSTALL_PREFIX)/share/examples/$(PACKAGE_NAME)-$(PACKAGE_VERSION) +else +ifdef linuxHier +INSTALL_EXAMPLEDIR:=$(INSTALL_DOCDIR)/examples/$(PACKAGE_NAME)-$(PACKAGE_VERSION) +else +INSTALL_EXAMPLEDIR:=$(INSTALL_PREFIX)/doc/$(PACKAGE_NAME)-$(PACKAGE_VERSION) +endif +endif +endif +else +ifdef INSTALL_FPCPACKAGE +INSTALL_EXAMPLEDIR:=$(INSTALL_BASEDIR)/examples/$(PACKAGE_NAME) +else +INSTALL_EXAMPLEDIR:=$(INSTALL_BASEDIR)/examples +endif +endif +endif +ifndef INSTALL_DATADIR +INSTALL_DATADIR=$(INSTALL_BASEDIR) +endif +ifndef INSTALL_SHAREDDIR +INSTALL_SHAREDDIR=$(INSTALL_PREFIX)/lib +endif +ifdef CROSSCOMPILE +ifndef CROSSBINDIR +CROSSBINDIR:=$(wildcard $(CROSSTARGETDIR)/bin/$(SOURCESUFFIX)) +ifeq ($(CROSSBINDIR),) +CROSSBINDIR:=$(wildcard $(INSTALL_BASEDIR)/cross/$(TARGETSUFFIX)/bin/$(FULL_SOURCE)) +endif +endif +else +CROSSBINDIR= +endif +ifeq ($(OS_SOURCE),linux) +ifndef GCCLIBDIR +ifeq ($(CPU_TARGET),i386) +ifneq ($(findstring x86_64,$(shell uname -a)),) +ifeq ($(BINUTILSPREFIX),) +GCCLIBDIR:=$(shell dirname `gcc -m32 -print-libgcc-file-name`) +else +CROSSGCCOPT=-m32 +endif +endif +endif +ifeq ($(CPU_TARGET),powerpc) +ifeq ($(BINUTILSPREFIX),) +GCCLIBDIR:=$(shell dirname `gcc -m32 -print-libgcc-file-name`) +else +CROSSGCCOPT=-m32 +endif +endif +ifeq ($(CPU_TARGET),powerpc64) +ifeq ($(BINUTILSPREFIX),) +GCCLIBDIR:=$(shell dirname `gcc -m64 -print-libgcc-file-name`) +else +CROSSGCCOPT=-m64 +endif +endif +ifeq ($(CPU_TARGET),sparc) +ifneq ($(findstring sparc64,$(shell uname -a)),) +ifeq ($(BINUTILSPREFIX),) +GCCLIBDIR:=$(shell dirname `gcc -m32 -print-libgcc-file-name`) +else +CROSSGCCOPT=-m32 +endif +endif +endif +endif +ifdef FPCFPMAKE +FPCFPMAKE_CPU_TARGET=$(shell $(FPCFPMAKE) -iTP) +ifeq ($(CPU_TARGET),$(FPCFPMAKE_CPU_TARGET)) +FPCMAKEGCCLIBDIR:=$(GCCLIBDIR) +endif +endif +ifndef FPCMAKEGCCLIBDIR +FPCMAKEGCCLIBDIR:=$(shell dirname `gcc -print-libgcc-file-name`) +endif +ifndef GCCLIBDIR +CROSSGCC=$(strip $(wildcard $(addsuffix /$(BINUTILSPREFIX)gcc$(SRCEXEEXT),$(SEARCHPATH)))) +ifneq ($(CROSSGCC),) +GCCLIBDIR:=$(shell dirname `$(CROSSGCC) $(CROSSGCCOPT) -print-libgcc-file-name`) +endif +endif +endif +ifdef inUnix +ifeq ($(OS_SOURCE),netbsd) +OTHERLIBDIR:=/usr/pkg/lib +endif +export GCCLIBDIR FPCMAKEGCCLIBDIR OTHERLIBDIR +endif +BATCHEXT=.bat +LOADEREXT=.as +EXEEXT=.exe +PPLEXT=.ppl +PPUEXT=.ppu +OEXT=.o +LTOEXT=.bc +ASMEXT=.s +SMARTEXT=.sl +STATICLIBEXT=.a +SHAREDLIBEXT=.so +SHAREDLIBPREFIX=libfp +STATICLIBPREFIX=libp +IMPORTLIBPREFIX=libimp +RSTEXT=.rst +EXEDBGEXT=.dbg +ifeq ($(OS_TARGET),go32v1) +STATICLIBPREFIX= +SHORTSUFFIX=v1 +endif +ifeq ($(OS_TARGET),go32v2) +STATICLIBPREFIX= +SHORTSUFFIX=dos +IMPORTLIBPREFIX= +endif +ifeq ($(OS_TARGET),watcom) +STATICLIBPREFIX= +OEXT=.obj +ASMEXT=.asm +SHAREDLIBEXT=.dll +SHORTSUFFIX=wat +IMPORTLIBPREFIX= +endif +ifneq ($(CPU_TARGET),jvm) +ifeq ($(OS_TARGET),android) +BATCHEXT=.sh +EXEEXT= +HASSHAREDLIB=1 +SHORTSUFFIX=lnx +endif +endif +ifeq ($(OS_TARGET),linux) +BATCHEXT=.sh +EXEEXT= +HASSHAREDLIB=1 +SHORTSUFFIX=lnx +endif +ifeq ($(OS_TARGET),dragonfly) +BATCHEXT=.sh +EXEEXT= +HASSHAREDLIB=1 +SHORTSUFFIX=df +endif +ifeq ($(OS_TARGET),freebsd) +BATCHEXT=.sh +EXEEXT= +HASSHAREDLIB=1 +SHORTSUFFIX=fbs +endif +ifeq ($(OS_TARGET),netbsd) +BATCHEXT=.sh +EXEEXT= +HASSHAREDLIB=1 +SHORTSUFFIX=nbs +endif +ifeq ($(OS_TARGET),openbsd) +BATCHEXT=.sh +EXEEXT= +HASSHAREDLIB=1 +SHORTSUFFIX=obs +endif +ifeq ($(OS_TARGET),win32) +SHAREDLIBEXT=.dll +SHORTSUFFIX=w32 +endif +ifeq ($(OS_TARGET),os2) +BATCHEXT=.cmd +AOUTEXT=.out +STATICLIBPREFIX= +SHAREDLIBEXT=.dll +SHORTSUFFIX=os2 +ECHO=echo +IMPORTLIBPREFIX= +endif +ifeq ($(OS_TARGET),emx) +BATCHEXT=.cmd +AOUTEXT=.out +STATICLIBPREFIX= +SHAREDLIBEXT=.dll +SHORTSUFFIX=emx +ECHO=echo +IMPORTLIBPREFIX= +endif +ifeq ($(OS_TARGET),amiga) +EXEEXT= +SHAREDLIBEXT=.library +SHORTSUFFIX=amg +endif +ifeq ($(OS_TARGET),aros) +EXEEXT= +SHAREDLIBEXT=.library +SHORTSUFFIX=aros +endif +ifeq ($(OS_TARGET),morphos) +EXEEXT= +SHAREDLIBEXT=.library +SHORTSUFFIX=mos +endif +ifeq ($(OS_TARGET),atari) +EXEEXT=.ttp +SHORTSUFFIX=ata +endif +ifeq ($(OS_TARGET),beos) +BATCHEXT=.sh +EXEEXT= +SHORTSUFFIX=be +endif +ifeq ($(OS_TARGET),haiku) +BATCHEXT=.sh +EXEEXT= +SHORTSUFFIX=hai +endif +ifeq ($(OS_TARGET),solaris) +BATCHEXT=.sh +EXEEXT= +SHORTSUFFIX=sun +endif +ifeq ($(OS_TARGET),qnx) +BATCHEXT=.sh +EXEEXT= +SHORTSUFFIX=qnx +endif +ifeq ($(OS_TARGET),netware) +EXEEXT=.nlm +STATICLIBPREFIX= +SHORTSUFFIX=nw +IMPORTLIBPREFIX=imp +endif +ifeq ($(OS_TARGET),netwlibc) +EXEEXT=.nlm +STATICLIBPREFIX= +SHORTSUFFIX=nwl +IMPORTLIBPREFIX=imp +endif +ifeq ($(OS_TARGET),macosclassic) +BATCHEXT= +EXEEXT= +DEBUGSYMEXT=.xcoff +SHORTSUFFIX=mac +IMPORTLIBPREFIX=imp +endif +ifneq ($(findstring $(OS_TARGET),darwin iphonesim ios),) +BATCHEXT=.sh +EXEEXT= +HASSHAREDLIB=1 +SHORTSUFFIX=dwn +EXEDBGEXT=.dSYM +endif +ifeq ($(OS_TARGET),gba) +EXEEXT=.gba +SHAREDLIBEXT=.so +SHORTSUFFIX=gba +endif +ifeq ($(OS_TARGET),symbian) +SHAREDLIBEXT=.dll +SHORTSUFFIX=symbian +endif +ifeq ($(OS_TARGET),NativeNT) +SHAREDLIBEXT=.dll +SHORTSUFFIX=nativent +endif +ifeq ($(OS_TARGET),wii) +EXEEXT=.dol +SHAREDLIBEXT=.so +SHORTSUFFIX=wii +endif +ifeq ($(OS_TARGET),aix) +BATCHEXT=.sh +EXEEXT= +SHAREDLIBEXT=.a +SHORTSUFFIX=aix +endif +ifeq ($(OS_TARGET),java) +OEXT=.class +ASMEXT=.j +SHAREDLIBEXT=.jar +SHORTSUFFIX=java +endif +ifeq ($(CPU_TARGET),jvm) +ifeq ($(OS_TARGET),android) +OEXT=.class +ASMEXT=.j +SHAREDLIBEXT=.jar +SHORTSUFFIX=android +endif +endif +ifeq ($(OS_TARGET),msdos) +STATICLIBPREFIX= +STATICLIBEXT=.a +SHORTSUFFIX=d16 +endif +ifeq ($(OS_TARGET),msxdos) +STATICLIBPREFIX= +STATICLIBEXT=.a +SHORTSUFFIX=msd +endif +ifeq ($(OS_TARGET),embedded) +ifeq ($(CPU_TARGET),i8086) +STATICLIBPREFIX= +STATICLIBEXT=.a +else +EXEEXT=.bin +endif +ifeq ($(CPU_TARGET),z80) +OEXT=.rel +endif +SHORTSUFFIX=emb +endif +ifeq ($(OS_TARGET),win16) +STATICLIBPREFIX= +STATICLIBEXT=.a +SHAREDLIBEXT=.dll +SHORTSUFFIX=w16 +endif +ifeq ($(OS_TARGET),zxspectrum) +OEXT=.rel +endif +ifneq ($(findstring $(OS_SOURCE),$(LIMIT83fs)),) +FPCMADE=fpcmade.$(SHORTSUFFIX) +ZIPSUFFIX=$(SHORTSUFFIX) +ZIPCROSSPREFIX= +ZIPSOURCESUFFIX=src +ZIPEXAMPLESUFFIX=exm +else +FPCMADE=fpcmade.$(TARGETSUFFIX) +ZIPSOURCESUFFIX=.source +ZIPEXAMPLESUFFIX=.examples +ifdef CROSSCOMPILE +ZIPSUFFIX=.$(SOURCESUFFIX) +ZIPCROSSPREFIX=$(TARGETSUFFIX)- +else +ZIPSUFFIX=.$(TARGETSUFFIX) +ZIPCROSSPREFIX= +endif +endif +ifndef ECHO +ECHO:=$(strip $(wildcard $(addsuffix /gecho$(SRCEXEEXT),$(SEARCHPATH)))) +ifeq ($(ECHO),) +ECHO:=$(strip $(wildcard $(addsuffix /echo$(SRCEXEEXT),$(SEARCHPATH)))) +ifeq ($(ECHO),) +ECHO= __missing_command_ECHO +else +ECHO:=$(firstword $(ECHO)) +endif +else +ECHO:=$(firstword $(ECHO)) +endif +endif +export ECHO +ifndef DATE +DATE:=$(strip $(wildcard $(addsuffix /gdate$(SRCEXEEXT),$(SEARCHPATH)))) +ifeq ($(DATE),) +DATE:=$(strip $(wildcard $(addsuffix /date$(SRCEXEEXT),$(SEARCHPATH)))) +ifeq ($(DATE),) +DATE= __missing_command_DATE +else +DATE:=$(firstword $(DATE)) +endif +else +DATE:=$(firstword $(DATE)) +endif +endif +export DATE +ifndef GINSTALL +GINSTALL:=$(strip $(wildcard $(addsuffix /ginstall$(SRCEXEEXT),$(SEARCHPATH)))) +ifeq ($(GINSTALL),) +GINSTALL:=$(strip $(wildcard $(addsuffix /install$(SRCEXEEXT),$(SEARCHPATH)))) +ifeq ($(GINSTALL),) +GINSTALL= __missing_command_GINSTALL +else +GINSTALL:=$(firstword $(GINSTALL)) +endif +else +GINSTALL:=$(firstword $(GINSTALL)) +endif +endif +export GINSTALL +ifndef CPPROG +CPPROG:=$(strip $(wildcard $(addsuffix /cp$(SRCEXEEXT),$(SEARCHPATH)))) +ifeq ($(CPPROG),) +CPPROG= __missing_command_CPPROG +else +CPPROG:=$(firstword $(CPPROG)) +endif +endif +export CPPROG +ifndef RMPROG +RMPROG:=$(strip $(wildcard $(addsuffix /rm$(SRCEXEEXT),$(SEARCHPATH)))) +ifeq ($(RMPROG),) +RMPROG= __missing_command_RMPROG +else +RMPROG:=$(firstword $(RMPROG)) +endif +endif +export RMPROG +ifndef MVPROG +MVPROG:=$(strip $(wildcard $(addsuffix /mv$(SRCEXEEXT),$(SEARCHPATH)))) +ifeq ($(MVPROG),) +MVPROG= __missing_command_MVPROG +else +MVPROG:=$(firstword $(MVPROG)) +endif +endif +export MVPROG +ifndef MKDIRPROG +MKDIRPROG:=$(strip $(wildcard $(addsuffix /gmkdir$(SRCEXEEXT),$(SEARCHPATH)))) +ifeq ($(MKDIRPROG),) +MKDIRPROG:=$(strip $(wildcard $(addsuffix /mkdir$(SRCEXEEXT),$(SEARCHPATH)))) +ifeq ($(MKDIRPROG),) +MKDIRPROG= __missing_command_MKDIRPROG +else +MKDIRPROG:=$(firstword $(MKDIRPROG)) +endif +else +MKDIRPROG:=$(firstword $(MKDIRPROG)) +endif +endif +export MKDIRPROG +ifndef ECHOREDIR +ifndef inUnix +ECHOREDIR=echo +else +ECHOREDIR=$(ECHO) +endif +endif +ifndef COPY +COPY:=$(CPPROG) -fp +endif +ifndef COPYTREE +COPYTREE:=$(CPPROG) -Rfp +endif +ifndef MKDIRTREE +MKDIRTREE:=$(MKDIRPROG) -p +endif +ifndef MOVE +MOVE:=$(MVPROG) -f +endif +ifndef DEL +DEL:=$(RMPROG) -f +endif +ifndef DELTREE +DELTREE:=$(RMPROG) -rf +endif +ifndef INSTALL +ifdef inUnix +INSTALL:=$(GINSTALL) -c -m 644 +else +INSTALL:=$(COPY) +endif +endif +ifndef INSTALLEXE +ifdef inUnix +INSTALLEXE:=$(GINSTALL) -c -m 755 +else +INSTALLEXE:=$(COPY) +endif +endif +ifndef MKDIR +MKDIR:=$(GINSTALL) -m 755 -d +endif +export ECHOREDIR COPY COPYTREE MOVE DEL DELTREE INSTALL INSTALLEXE MKDIR +ifndef PPUMOVE +PPUMOVE:=$(strip $(wildcard $(addsuffix /ppumove$(SRCEXEEXT),$(SEARCHPATH)))) +ifeq ($(PPUMOVE),) +PPUMOVE= __missing_command_PPUMOVE +else +PPUMOVE:=$(firstword $(PPUMOVE)) +endif +endif +export PPUMOVE +ifndef FPCMAKE +FPCMAKE:=$(strip $(wildcard $(addsuffix /fpcmake$(SRCEXEEXT),$(SEARCHPATH)))) +ifeq ($(FPCMAKE),) +FPCMAKE= __missing_command_FPCMAKE +else +FPCMAKE:=$(firstword $(FPCMAKE)) +endif +endif +export FPCMAKE +ifndef ZIPPROG +ZIPPROG:=$(strip $(wildcard $(addsuffix /zip$(SRCEXEEXT),$(SEARCHPATH)))) +ifeq ($(ZIPPROG),) +ZIPPROG= __missing_command_ZIPPROG +else +ZIPPROG:=$(firstword $(ZIPPROG)) +endif +endif +export ZIPPROG +ifndef TARPROG +TARPROG:=$(strip $(wildcard $(addsuffix /gtar$(SRCEXEEXT),$(SEARCHPATH)))) +ifeq ($(TARPROG),) +TARPROG:=$(strip $(wildcard $(addsuffix /tar$(SRCEXEEXT),$(SEARCHPATH)))) +ifeq ($(TARPROG),) +TARPROG= __missing_command_TARPROG +else +TARPROG:=$(firstword $(TARPROG)) +endif +else +TARPROG:=$(firstword $(TARPROG)) +endif +endif +export TARPROG +ASNAME=$(BINUTILSPREFIX)as +LDNAME=$(BINUTILSPREFIX)ld +ARNAME=$(BINUTILSPREFIX)ar +RCNAME=$(BINUTILSPREFIX)rc +NASMNAME=$(BINUTILSPREFIX)nasm +ifndef ASPROG +ifdef CROSSBINDIR +ASPROG=$(CROSSBINDIR)/$(ASNAME)$(SRCEXEEXT) +else +ASPROG=$(ASNAME) +endif +endif +ifndef LDPROG +ifdef CROSSBINDIR +LDPROG=$(CROSSBINDIR)/$(LDNAME)$(SRCEXEEXT) +else +LDPROG=$(LDNAME) +endif +endif +ifndef RCPROG +ifdef CROSSBINDIR +RCPROG=$(CROSSBINDIR)/$(RCNAME)$(SRCEXEEXT) +else +RCPROG=$(RCNAME) +endif +endif +ifndef ARPROG +ifdef CROSSBINDIR +ARPROG=$(CROSSBINDIR)/$(ARNAME)$(SRCEXEEXT) +else +ARPROG=$(ARNAME) +endif +endif +ifndef NASMPROG +ifdef CROSSBINDIR +NASMPROG=$(CROSSBINDIR)/$(NASMNAME)$(SRCEXEEXT) +else +NASMPROG=$(NASMNAME) +endif +endif +AS=$(ASPROG) +LD=$(LDPROG) +RC=$(RCPROG) +AR=$(ARPROG) +NASM=$(NASMPROG) +ifdef inUnix +PPAS=./ppas$(SRCBATCHEXT) +else +PPAS=ppas$(SRCBATCHEXT) +endif +ifdef inUnix +LDCONFIG=ldconfig +else +LDCONFIG= +endif +ifdef DATE +DATESTR:=$(shell $(DATE) +%Y%m%d) +else +DATESTR= +endif +ZIPOPT=-9 +ZIPEXT=.zip +ifeq ($(USETAR),bz2) +TAROPT=vj +TAREXT=.tar.bz2 +else +TAROPT=vz +TAREXT=.tar.gz +endif +override REQUIRE_PACKAGES=rtl fpmkunit +ifeq ($(FULL_TARGET),i386-linux) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),i386-go32v2) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),i386-win32) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),i386-os2) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),i386-freebsd) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),i386-beos) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),i386-haiku) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),i386-netbsd) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),i386-solaris) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),i386-netware) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),i386-openbsd) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),i386-wdosx) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),i386-darwin) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),i386-emx) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),i386-watcom) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),i386-netwlibc) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),i386-wince) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),i386-embedded) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),i386-symbian) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),i386-nativent) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),i386-iphonesim) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),i386-android) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),i386-aros) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),m68k-linux) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),m68k-netbsd) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),m68k-amiga) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),m68k-atari) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),m68k-palmos) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),m68k-macosclassic) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),m68k-embedded) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),powerpc-linux) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),powerpc-netbsd) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),powerpc-amiga) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),powerpc-macosclassic) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),powerpc-darwin) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),powerpc-morphos) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),powerpc-embedded) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),powerpc-wii) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),powerpc-aix) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),sparc-linux) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),sparc-netbsd) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),sparc-solaris) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),sparc-embedded) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),x86_64-linux) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),x86_64-freebsd) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),x86_64-haiku) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),x86_64-netbsd) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),x86_64-solaris) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),x86_64-openbsd) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),x86_64-darwin) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),x86_64-win64) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),x86_64-embedded) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),x86_64-iphonesim) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),x86_64-android) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),x86_64-aros) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),x86_64-dragonfly) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),arm-linux) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),arm-netbsd) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),arm-palmos) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),arm-wince) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),arm-gba) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),arm-nds) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),arm-embedded) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),arm-symbian) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),arm-android) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),arm-aros) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),arm-freertos) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),arm-ios) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),powerpc64-linux) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),powerpc64-darwin) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),powerpc64-embedded) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),powerpc64-aix) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),avr-embedded) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),armeb-linux) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),armeb-embedded) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),mips-linux) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),mipsel-linux) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),mipsel-embedded) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),mipsel-android) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),mips64el-linux) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),jvm-java) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),jvm-android) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),i8086-embedded) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),i8086-msdos) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),i8086-win16) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),aarch64-linux) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),aarch64-darwin) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),aarch64-win64) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),aarch64-android) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),aarch64-ios) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),wasm-wasm) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),sparc64-linux) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),riscv32-linux) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),riscv32-embedded) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),riscv64-linux) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),riscv64-embedded) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),xtensa-linux) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),xtensa-embedded) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),xtensa-freertos) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),z80-embedded) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),z80-zxspectrum) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),z80-msxdos) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifeq ($(FULL_TARGET),z80-amstradcpc) +REQUIRE_PACKAGES_RTL=1 +REQUIRE_PACKAGES_PASZLIB=1 +REQUIRE_PACKAGES_FCL-PROCESS=1 +REQUIRE_PACKAGES_HASH=1 +REQUIRE_PACKAGES_LIBTAR=1 +REQUIRE_PACKAGES_FPMKUNIT=1 +endif +ifdef REQUIRE_PACKAGES_RTL +PACKAGEDIR_RTL:=$(firstword $(subst /Makefile.fpc,,$(strip $(wildcard $(addsuffix /rtl/Makefile.fpc,$(PACKAGESDIR)))))) +ifneq ($(PACKAGEDIR_RTL),) +ifneq ($(wildcard $(PACKAGEDIR_RTL)/units/$(TARGETSUFFIX)),) +UNITDIR_RTL=$(PACKAGEDIR_RTL)/units/$(TARGETSUFFIX) +else +UNITDIR_RTL=$(PACKAGEDIR_RTL) +endif +ifneq ($(wildcard $(PACKAGEDIR_RTL)/units/$(SOURCESUFFIX)),) +UNITDIR_FPMAKE_RTL=$(PACKAGEDIR_RTL)/units/$(SOURCESUFFIX) +else +ifneq ($(wildcard $(PACKAGEDIR_RTL)/units_bs/$(SOURCESUFFIX)),) +UNITDIR_FPMAKE_RTL=$(PACKAGEDIR_RTL)/units_bs/$(SOURCESUFFIX) +else +UNITDIR_FPMAKE_RTL=$(PACKAGEDIR_RTL) +endif +endif +ifdef CHECKDEPEND +$(PACKAGEDIR_RTL)/$(OS_TARGET)/$(FPCMADE): + $(MAKE) -C $(PACKAGEDIR_RTL)/$(OS_TARGET) $(FPCMADE) +override ALLDEPENDENCIES+=$(PACKAGEDIR_RTL)/$(OS_TARGET)/$(FPCMADE) +endif +else +PACKAGEDIR_RTL= +UNITDIR_RTL:=$(subst /Package.fpc,,$(strip $(wildcard $(addsuffix /rtl/Package.fpc,$(UNITSDIR))))) +ifneq ($(UNITDIR_RTL),) +UNITDIR_RTL:=$(firstword $(UNITDIR_RTL)) +else +UNITDIR_RTL= +endif +endif +ifdef UNITDIR_RTL +override COMPILER_UNITDIR+=$(UNITDIR_RTL) +endif +ifdef UNITDIR_FPMAKE_RTL +override COMPILER_FPMAKE_UNITDIR+=$(UNITDIR_FPMAKE_RTL) +endif +endif +ifdef REQUIRE_PACKAGES_PASZLIB +PACKAGEDIR_PASZLIB:=$(firstword $(subst /Makefile.fpc,,$(strip $(wildcard $(addsuffix /paszlib/Makefile.fpc,$(PACKAGESDIR)))))) +ifneq ($(PACKAGEDIR_PASZLIB),) +ifneq ($(wildcard $(PACKAGEDIR_PASZLIB)/units/$(TARGETSUFFIX)),) +UNITDIR_PASZLIB=$(PACKAGEDIR_PASZLIB)/units/$(TARGETSUFFIX) +else +UNITDIR_PASZLIB=$(PACKAGEDIR_PASZLIB) +endif +ifneq ($(wildcard $(PACKAGEDIR_PASZLIB)/units/$(SOURCESUFFIX)),) +UNITDIR_FPMAKE_PASZLIB=$(PACKAGEDIR_PASZLIB)/units/$(SOURCESUFFIX) +else +ifneq ($(wildcard $(PACKAGEDIR_PASZLIB)/units_bs/$(SOURCESUFFIX)),) +UNITDIR_FPMAKE_PASZLIB=$(PACKAGEDIR_PASZLIB)/units_bs/$(SOURCESUFFIX) +else +UNITDIR_FPMAKE_PASZLIB=$(PACKAGEDIR_PASZLIB) +endif +endif +ifdef CHECKDEPEND +$(PACKAGEDIR_PASZLIB)/$(FPCMADE): + $(MAKE) -C $(PACKAGEDIR_PASZLIB) $(FPCMADE) +override ALLDEPENDENCIES+=$(PACKAGEDIR_PASZLIB)/$(FPCMADE) +endif +else +PACKAGEDIR_PASZLIB= +UNITDIR_PASZLIB:=$(subst /Package.fpc,,$(strip $(wildcard $(addsuffix /paszlib/Package.fpc,$(UNITSDIR))))) +ifneq ($(UNITDIR_PASZLIB),) +UNITDIR_PASZLIB:=$(firstword $(UNITDIR_PASZLIB)) +else +UNITDIR_PASZLIB= +endif +endif +ifdef UNITDIR_PASZLIB +override COMPILER_UNITDIR+=$(UNITDIR_PASZLIB) +endif +ifdef UNITDIR_FPMAKE_PASZLIB +override COMPILER_FPMAKE_UNITDIR+=$(UNITDIR_FPMAKE_PASZLIB) +endif +endif +ifdef REQUIRE_PACKAGES_FCL-PROCESS +PACKAGEDIR_FCL-PROCESS:=$(firstword $(subst /Makefile.fpc,,$(strip $(wildcard $(addsuffix /fcl-process/Makefile.fpc,$(PACKAGESDIR)))))) +ifneq ($(PACKAGEDIR_FCL-PROCESS),) +ifneq ($(wildcard $(PACKAGEDIR_FCL-PROCESS)/units/$(TARGETSUFFIX)),) +UNITDIR_FCL-PROCESS=$(PACKAGEDIR_FCL-PROCESS)/units/$(TARGETSUFFIX) +else +UNITDIR_FCL-PROCESS=$(PACKAGEDIR_FCL-PROCESS) +endif +ifneq ($(wildcard $(PACKAGEDIR_FCL-PROCESS)/units/$(SOURCESUFFIX)),) +UNITDIR_FPMAKE_FCL-PROCESS=$(PACKAGEDIR_FCL-PROCESS)/units/$(SOURCESUFFIX) +else +ifneq ($(wildcard $(PACKAGEDIR_FCL-PROCESS)/units_bs/$(SOURCESUFFIX)),) +UNITDIR_FPMAKE_FCL-PROCESS=$(PACKAGEDIR_FCL-PROCESS)/units_bs/$(SOURCESUFFIX) +else +UNITDIR_FPMAKE_FCL-PROCESS=$(PACKAGEDIR_FCL-PROCESS) +endif +endif +ifdef CHECKDEPEND +$(PACKAGEDIR_FCL-PROCESS)/$(FPCMADE): + $(MAKE) -C $(PACKAGEDIR_FCL-PROCESS) $(FPCMADE) +override ALLDEPENDENCIES+=$(PACKAGEDIR_FCL-PROCESS)/$(FPCMADE) +endif +else +PACKAGEDIR_FCL-PROCESS= +UNITDIR_FCL-PROCESS:=$(subst /Package.fpc,,$(strip $(wildcard $(addsuffix /fcl-process/Package.fpc,$(UNITSDIR))))) +ifneq ($(UNITDIR_FCL-PROCESS),) +UNITDIR_FCL-PROCESS:=$(firstword $(UNITDIR_FCL-PROCESS)) +else +UNITDIR_FCL-PROCESS= +endif +endif +ifdef UNITDIR_FCL-PROCESS +override COMPILER_UNITDIR+=$(UNITDIR_FCL-PROCESS) +endif +ifdef UNITDIR_FPMAKE_FCL-PROCESS +override COMPILER_FPMAKE_UNITDIR+=$(UNITDIR_FPMAKE_FCL-PROCESS) +endif +endif +ifdef REQUIRE_PACKAGES_HASH +PACKAGEDIR_HASH:=$(firstword $(subst /Makefile.fpc,,$(strip $(wildcard $(addsuffix /hash/Makefile.fpc,$(PACKAGESDIR)))))) +ifneq ($(PACKAGEDIR_HASH),) +ifneq ($(wildcard $(PACKAGEDIR_HASH)/units/$(TARGETSUFFIX)),) +UNITDIR_HASH=$(PACKAGEDIR_HASH)/units/$(TARGETSUFFIX) +else +UNITDIR_HASH=$(PACKAGEDIR_HASH) +endif +ifneq ($(wildcard $(PACKAGEDIR_HASH)/units/$(SOURCESUFFIX)),) +UNITDIR_FPMAKE_HASH=$(PACKAGEDIR_HASH)/units/$(SOURCESUFFIX) +else +ifneq ($(wildcard $(PACKAGEDIR_HASH)/units_bs/$(SOURCESUFFIX)),) +UNITDIR_FPMAKE_HASH=$(PACKAGEDIR_HASH)/units_bs/$(SOURCESUFFIX) +else +UNITDIR_FPMAKE_HASH=$(PACKAGEDIR_HASH) +endif +endif +ifdef CHECKDEPEND +$(PACKAGEDIR_HASH)/$(FPCMADE): + $(MAKE) -C $(PACKAGEDIR_HASH) $(FPCMADE) +override ALLDEPENDENCIES+=$(PACKAGEDIR_HASH)/$(FPCMADE) +endif +else +PACKAGEDIR_HASH= +UNITDIR_HASH:=$(subst /Package.fpc,,$(strip $(wildcard $(addsuffix /hash/Package.fpc,$(UNITSDIR))))) +ifneq ($(UNITDIR_HASH),) +UNITDIR_HASH:=$(firstword $(UNITDIR_HASH)) +else +UNITDIR_HASH= +endif +endif +ifdef UNITDIR_HASH +override COMPILER_UNITDIR+=$(UNITDIR_HASH) +endif +ifdef UNITDIR_FPMAKE_HASH +override COMPILER_FPMAKE_UNITDIR+=$(UNITDIR_FPMAKE_HASH) +endif +endif +ifdef REQUIRE_PACKAGES_LIBTAR +PACKAGEDIR_LIBTAR:=$(firstword $(subst /Makefile.fpc,,$(strip $(wildcard $(addsuffix /libtar/Makefile.fpc,$(PACKAGESDIR)))))) +ifneq ($(PACKAGEDIR_LIBTAR),) +ifneq ($(wildcard $(PACKAGEDIR_LIBTAR)/units/$(TARGETSUFFIX)),) +UNITDIR_LIBTAR=$(PACKAGEDIR_LIBTAR)/units/$(TARGETSUFFIX) +else +UNITDIR_LIBTAR=$(PACKAGEDIR_LIBTAR) +endif +ifneq ($(wildcard $(PACKAGEDIR_LIBTAR)/units/$(SOURCESUFFIX)),) +UNITDIR_FPMAKE_LIBTAR=$(PACKAGEDIR_LIBTAR)/units/$(SOURCESUFFIX) +else +ifneq ($(wildcard $(PACKAGEDIR_LIBTAR)/units_bs/$(SOURCESUFFIX)),) +UNITDIR_FPMAKE_LIBTAR=$(PACKAGEDIR_LIBTAR)/units_bs/$(SOURCESUFFIX) +else +UNITDIR_FPMAKE_LIBTAR=$(PACKAGEDIR_LIBTAR) +endif +endif +ifdef CHECKDEPEND +$(PACKAGEDIR_LIBTAR)/$(FPCMADE): + $(MAKE) -C $(PACKAGEDIR_LIBTAR) $(FPCMADE) +override ALLDEPENDENCIES+=$(PACKAGEDIR_LIBTAR)/$(FPCMADE) +endif +else +PACKAGEDIR_LIBTAR= +UNITDIR_LIBTAR:=$(subst /Package.fpc,,$(strip $(wildcard $(addsuffix /libtar/Package.fpc,$(UNITSDIR))))) +ifneq ($(UNITDIR_LIBTAR),) +UNITDIR_LIBTAR:=$(firstword $(UNITDIR_LIBTAR)) +else +UNITDIR_LIBTAR= +endif +endif +ifdef UNITDIR_LIBTAR +override COMPILER_UNITDIR+=$(UNITDIR_LIBTAR) +endif +ifdef UNITDIR_FPMAKE_LIBTAR +override COMPILER_FPMAKE_UNITDIR+=$(UNITDIR_FPMAKE_LIBTAR) +endif +endif +ifdef REQUIRE_PACKAGES_FPMKUNIT +PACKAGEDIR_FPMKUNIT:=$(firstword $(subst /Makefile.fpc,,$(strip $(wildcard $(addsuffix /fpmkunit/Makefile.fpc,$(PACKAGESDIR)))))) +ifneq ($(PACKAGEDIR_FPMKUNIT),) +ifneq ($(wildcard $(PACKAGEDIR_FPMKUNIT)/units/$(TARGETSUFFIX)),) +UNITDIR_FPMKUNIT=$(PACKAGEDIR_FPMKUNIT)/units/$(TARGETSUFFIX) +else +UNITDIR_FPMKUNIT=$(PACKAGEDIR_FPMKUNIT) +endif +ifneq ($(wildcard $(PACKAGEDIR_FPMKUNIT)/units/$(SOURCESUFFIX)),) +UNITDIR_FPMAKE_FPMKUNIT=$(PACKAGEDIR_FPMKUNIT)/units/$(SOURCESUFFIX) +else +ifneq ($(wildcard $(PACKAGEDIR_FPMKUNIT)/units_bs/$(SOURCESUFFIX)),) +UNITDIR_FPMAKE_FPMKUNIT=$(PACKAGEDIR_FPMKUNIT)/units_bs/$(SOURCESUFFIX) +else +UNITDIR_FPMAKE_FPMKUNIT=$(PACKAGEDIR_FPMKUNIT) +endif +endif +ifdef CHECKDEPEND +$(PACKAGEDIR_FPMKUNIT)/$(FPCMADE): + $(MAKE) -C $(PACKAGEDIR_FPMKUNIT) $(FPCMADE) +override ALLDEPENDENCIES+=$(PACKAGEDIR_FPMKUNIT)/$(FPCMADE) +endif +else +PACKAGEDIR_FPMKUNIT= +UNITDIR_FPMKUNIT:=$(subst /Package.fpc,,$(strip $(wildcard $(addsuffix /fpmkunit/Package.fpc,$(UNITSDIR))))) +ifneq ($(UNITDIR_FPMKUNIT),) +UNITDIR_FPMKUNIT:=$(firstword $(UNITDIR_FPMKUNIT)) +else +UNITDIR_FPMKUNIT= +endif +endif +ifdef UNITDIR_FPMKUNIT +override COMPILER_UNITDIR+=$(UNITDIR_FPMKUNIT) +endif +ifdef UNITDIR_FPMAKE_FPMKUNIT +override COMPILER_FPMAKE_UNITDIR+=$(UNITDIR_FPMAKE_FPMKUNIT) +endif +endif +ifndef NOCPUDEF +override FPCOPTDEF=$(ARCH) +endif +ifneq ($(OS_TARGET),$(OS_SOURCE)) +override FPCOPT+=-T$(OS_TARGET) +endif +ifneq ($(CPU_TARGET),$(CPU_SOURCE)) +override FPCOPT+=-P$(ARCH) +endif +ifeq ($(OS_SOURCE),openbsd) +override FPCOPT+=-FD$(NEW_BINUTILS_PATH) +override FPCMAKEOPT+=-FD$(NEW_BINUTILS_PATH) +override FPMAKE_BUILD_OPT+=-FD$(NEW_BINUTILS_PATH) +endif +ifndef CROSSBOOTSTRAP +ifneq ($(BINUTILSPREFIX),) +override FPCOPT+=-XP$(BINUTILSPREFIX) +endif +ifneq ($(BINUTILSPREFIX),) +override FPCOPT+=-Xr$(RLINKPATH) +endif +endif +ifndef CROSSCOMPILE +ifneq ($(BINUTILSPREFIX),) +override FPCMAKEOPT+=-XP$(BINUTILSPREFIX) +override FPMAKE_BUILD_OPT+=-XP$(BINUTILSPREFIX) +endif +endif +ifdef UNITDIR +override FPCOPT+=$(addprefix -Fu,$(UNITDIR)) +endif +ifdef LIBDIR +override FPCOPT+=$(addprefix -Fl,$(LIBDIR)) +endif +ifdef OBJDIR +override FPCOPT+=$(addprefix -Fo,$(OBJDIR)) +endif +ifdef INCDIR +override FPCOPT+=$(addprefix -Fi,$(INCDIR)) +endif +ifdef LINKSMART +override FPCOPT+=-XX +endif +ifdef CREATESMART +override FPCOPT+=-CX +endif +ifdef DEBUG +override FPCOPT+=-gl +override FPCOPTDEF+=DEBUG +endif +ifdef RELEASE +FPCCPUOPT:=-O2 +override FPCOPT+=-Ur -Xs $(FPCCPUOPT) -n +override FPCOPTDEF+=RELEASE +endif +ifdef STRIP +override FPCOPT+=-Xs +endif +ifdef OPTIMIZE +override FPCOPT+=-O2 +endif +ifdef VERBOSE +override FPCOPT+=-vwni +endif +ifdef COMPILER_OPTIONS +override FPCOPT+=$(COMPILER_OPTIONS) +endif +ifdef COMPILER_UNITDIR +override FPCOPT+=$(addprefix -Fu,$(COMPILER_UNITDIR)) +endif +ifdef COMPILER_LIBRARYDIR +override FPCOPT+=$(addprefix -Fl,$(COMPILER_LIBRARYDIR)) +endif +ifdef COMPILER_OBJECTDIR +override FPCOPT+=$(addprefix -Fo,$(COMPILER_OBJECTDIR)) +endif +ifdef COMPILER_INCLUDEDIR +override FPCOPT+=$(addprefix -Fi,$(COMPILER_INCLUDEDIR)) +endif +ifdef CROSSBINDIR +override FPCOPT+=-FD$(CROSSBINDIR) +endif +ifdef COMPILER_TARGETDIR +override FPCOPT+=-FE$(COMPILER_TARGETDIR) +ifeq ($(COMPILER_TARGETDIR),.) +override TARGETDIRPREFIX= +else +override TARGETDIRPREFIX=$(COMPILER_TARGETDIR)/ +endif +endif +ifdef COMPILER_UNITTARGETDIR +override FPCOPT+=-FU$(COMPILER_UNITTARGETDIR) +ifeq ($(COMPILER_UNITTARGETDIR),.) +override UNITTARGETDIRPREFIX= +else +override UNITTARGETDIRPREFIX=$(COMPILER_UNITTARGETDIR)/ +endif +else +ifdef COMPILER_TARGETDIR +override COMPILER_UNITTARGETDIR=$(COMPILER_TARGETDIR) +override UNITTARGETDIRPREFIX=$(TARGETDIRPREFIX) +endif +endif +ifdef CREATESHARED +override FPCOPT+=-Cg +endif +ifneq ($(findstring $(OS_TARGET),dragonfly freebsd openbsd netbsd linux solaris),) +ifneq ($(findstring $(CPU_TARGET),x86_64 mips mipsel),) +override FPCOPT+=-Cg +endif +endif +ifdef LINKSHARED +endif +ifdef GCCLIBDIR +override FPCOPT+=-Fl$(GCCLIBDIR) +ifdef FPCMAKEGCCLIBDIR +override FPCMAKEOPT+=-Fl$(FPCMAKEGCCLIBDIR) +else +override FPCMAKEOPT+=-Fl$(GCCLIBDIR) +endif +endif +ifdef OTHERLIBDIR +override FPCOPT+=$(addprefix -Fl,$(OTHERLIBDIR)) +endif +ifdef OPT +override FPCOPT+=$(OPT) +endif +ifdef FPMAKEBUILDOPT +override FPMAKE_BUILD_OPT+=$(FPMAKEBUILDOPT) +endif +ifdef FPCOPTDEF +override FPCOPT+=$(addprefix -d,$(FPCOPTDEF)) +endif +ifdef CFGFILE +override FPCOPT+=@$(CFGFILE) +endif +ifdef USEENV +override FPCEXTCMD:=$(FPCOPT) +override FPCOPT:=!FPCEXTCMD +export FPCEXTCMD +endif +override AFULL_TARGET=$(CPU_TARGET)-$(OS_TARGET) +override AFULL_SOURCE=$(CPU_SOURCE)-$(OS_SOURCE) +ifneq ($(AFULL_TARGET),$(AFULL_SOURCE)) +override ACROSSCOMPILE=1 +endif +ifdef ACROSSCOMPILE +override FPCOPT+=$(CROSSOPT) +endif +override COMPILER:=$(strip $(FPC) $(FPCOPT)) +ifneq (,$(findstring -sh ,$(COMPILER))) +UseEXECPPAS=1 +endif +ifneq (,$(findstring -s ,$(COMPILER))) +ifeq ($(FULL_SOURCE),$(FULL_TARGET)) +UseEXECPPAS=1 +endif +endif +ifneq ($(UseEXECPPAS),1) +EXECPPAS= +else +ifdef RUNBATCH +EXECPPAS:=@$(RUNBATCH) $(PPAS) +else +EXECPPAS:=@$(PPAS) +endif +endif +ifdef TARGET_RSTS +override RSTFILES=$(addsuffix $(RSTEXT),$(TARGET_RSTS)) +override CLEANRSTFILES+=$(RSTFILES) +endif +.PHONY: fpc_install fpc_sourceinstall fpc_exampleinstall +ifdef INSTALL_UNITS +override INSTALLPPUFILES+=$(addsuffix $(PPUEXT),$(INSTALL_UNITS)) +endif +ifdef INSTALL_BUILDUNIT +override INSTALLPPUFILES:=$(filter-out $(INSTALL_BUILDUNIT)$(PPUEXT),$(INSTALLPPUFILES)) +endif +ifdef INSTALLPPUFILES +ifneq ($(IMPORTLIBPREFIX)-$(STATICLIBEXT),$(STATICLIBPREFIX)-$(STATICLIBEXT)) +override INSTALLPPULINKFILES:=$(subst $(PPUEXT),$(OEXT),$(INSTALLPPUFILES)) $(subst $(PPUEXT),$(LTOEXT),$(INSTALLPPUFILES)) $(addprefix $(STATICLIBPREFIX),$(subst $(PPUEXT),$(STATICLIBEXT),$(INSTALLPPUFILES))) $(addprefix $(IMPORTLIBPREFIX),$(subst $(PPUEXT),$(STATICLIBEXT),$(INSTALLPPUFILES))) +else +override INSTALLPPULINKFILES:=$(subst $(PPUEXT),$(OEXT),$(INSTALLPPUFILES)) $(subst $(PPUEXT),$(LTOEXT),$(INSTALLPPUFILES)) $(addprefix $(STATICLIBPREFIX),$(subst $(PPUEXT),$(STATICLIBEXT),$(INSTALLPPUFILES))) +endif +ifneq ($(UNITTARGETDIRPREFIX),) +override INSTALLPPUFILENAMES:=$(notdir $(INSTALLPPUFILES)) +override INSTALLPPULINKFILENAMES:=$(notdir $(INSTALLPPULINKFILES)) +override INSTALLPPUFILES=$(addprefix $(UNITTARGETDIRPREFIX),$(INSTALLPPUFILENAMES)) +override INSTALLPPULINKFILES=$(wildcard $(addprefix $(UNITTARGETDIRPREFIX),$(INSTALLPPULINKFILENAMES))) +endif +override INSTALL_CREATEPACKAGEFPC=1 +endif +ifdef INSTALLEXEFILES +ifneq ($(TARGETDIRPREFIX),) +override INSTALLEXEFILES:=$(addprefix $(TARGETDIRPREFIX),$(notdir $(INSTALLEXEFILES))) +endif +endif +fpc_install: all $(INSTALLTARGET) +ifdef INSTALLEXEFILES + $(MKDIR) $(INSTALL_BINDIR) + $(INSTALLEXE) $(INSTALLEXEFILES) $(INSTALL_BINDIR) +endif +ifdef INSTALL_CREATEPACKAGEFPC +ifdef FPCMAKE +ifdef PACKAGE_VERSION +ifneq ($(wildcard Makefile.fpc),) + $(FPCMAKE) -p -T$(CPU_TARGET)-$(OS_TARGET) Makefile.fpc + $(MKDIR) $(INSTALL_UNITDIR) + $(INSTALL) Package.fpc $(INSTALL_UNITDIR) +endif +endif +endif +endif +ifdef INSTALLPPUFILES + $(MKDIR) $(INSTALL_UNITDIR) + $(INSTALL) $(INSTALLPPUFILES) $(INSTALL_UNITDIR) +ifneq ($(INSTALLPPULINKFILES),) + $(INSTALL) $(INSTALLPPULINKFILES) $(INSTALL_UNITDIR) +endif +ifneq ($(wildcard $(LIB_FULLNAME)),) + $(MKDIR) $(INSTALL_LIBDIR) + $(INSTALL) $(LIB_FULLNAME) $(INSTALL_LIBDIR) +ifdef inUnix + ln -sf $(LIB_FULLNAME) $(INSTALL_LIBDIR)/$(LIB_NAME) +endif +endif +endif +ifdef INSTALL_FILES + $(MKDIR) $(INSTALL_DATADIR) + $(INSTALL) $(INSTALL_FILES) $(INSTALL_DATADIR) +endif +fpc_sourceinstall: distclean + $(MKDIR) $(INSTALL_SOURCEDIR) + $(COPYTREE) $(BASEDIR)/* $(INSTALL_SOURCEDIR) +fpc_exampleinstall: $(EXAMPLEINSTALLTARGET) $(addsuffix _distclean,$(TARGET_EXAMPLEDIRS)) +ifdef HASEXAMPLES + $(MKDIR) $(INSTALL_EXAMPLEDIR) +endif +ifdef EXAMPLESOURCEFILES + $(COPY) $(EXAMPLESOURCEFILES) $(INSTALL_EXAMPLEDIR) +endif +ifdef TARGET_EXAMPLEDIRS + $(COPYTREE) $(addsuffix /*,$(TARGET_EXAMPLEDIRS)) $(INSTALL_EXAMPLEDIR) +endif +.PHONY: fpc_distinstall +fpc_distinstall: install exampleinstall +.PHONY: fpc_zipinstall fpc_zipsourceinstall fpc_zipexampleinstall +ifndef PACKDIR +ifndef inUnix +PACKDIR=$(BASEDIR)/../fpc-pack +else +PACKDIR=/tmp/fpc-pack +endif +endif +ifndef ZIPNAME +ifdef DIST_ZIPNAME +ZIPNAME=$(DIST_ZIPNAME) +else +ZIPNAME=$(PACKAGE_NAME) +endif +endif +ifndef FULLZIPNAME +FULLZIPNAME=$(ZIPCROSSPREFIX)$(ZIPPREFIX)$(ZIPNAME)$(ZIPSUFFIX) +endif +ifndef ZIPTARGET +ifdef DIST_ZIPTARGET +ZIPTARGET=DIST_ZIPTARGET +else +ZIPTARGET=install +endif +endif +ifndef USEZIP +ifdef inUnix +USETAR=1 +endif +endif +ifndef inUnix +USEZIPWRAPPER=1 +endif +ifdef USEZIPWRAPPER +ZIPPATHSEP=$(PATHSEP) +ZIPWRAPPER=$(subst /,$(PATHSEP),$(DIST_DESTDIR)/fpczip$(SRCBATCHEXT)) +else +ZIPPATHSEP=/ +endif +ZIPCMD_CDPACK:=cd $(subst /,$(ZIPPATHSEP),$(PACKDIR)) +ZIPCMD_CDBASE:=cd $(subst /,$(ZIPPATHSEP),$(BASEDIR)) +ifdef USETAR +ZIPDESTFILE:=$(DIST_DESTDIR)/$(FULLZIPNAME)$(TAREXT) +ZIPCMD_ZIP:=$(TARPROG) c$(TAROPT)f $(ZIPDESTFILE) * +else +ZIPDESTFILE:=$(DIST_DESTDIR)/$(FULLZIPNAME)$(ZIPEXT) +ZIPCMD_ZIP:=$(subst /,$(ZIPPATHSEP),$(ZIPPROG)) -Dr $(ZIPOPT) $(ZIPDESTFILE) * +endif +fpc_zipinstall: + $(MAKE) $(ZIPTARGET) INSTALL_PREFIX=$(PACKDIR) ZIPINSTALL=1 + $(MKDIR) $(DIST_DESTDIR) + $(DEL) $(ZIPDESTFILE) +ifdef USEZIPWRAPPER +ifneq ($(ECHOREDIR),echo) + $(ECHOREDIR) -e "$(subst \,\\,$(ZIPCMD_CDPACK))" > $(ZIPWRAPPER) + $(ECHOREDIR) -e "$(subst \,\\,$(ZIPCMD_ZIP))" >> $(ZIPWRAPPER) + $(ECHOREDIR) -e "$(subst \,\\,$(ZIPCMD_CDBASE))" >> $(ZIPWRAPPER) +else + echo $(ZIPCMD_CDPACK) > $(ZIPWRAPPER) + echo $(ZIPCMD_ZIP) >> $(ZIPWRAPPER) + echo $(ZIPCMD_CDBASE) >> $(ZIPWRAPPER) +endif +ifdef inUnix + /bin/sh $(ZIPWRAPPER) +else +ifdef RUNBATCH + $(RUNBATCH) $(ZIPWRAPPER) +else + $(ZIPWRAPPER) +endif +endif + $(DEL) $(ZIPWRAPPER) +else + $(ZIPCMD_CDPACK) ; $(ZIPCMD_ZIP) ; $(ZIPCMD_CDBASE) +endif + $(DELTREE) $(PACKDIR) +fpc_zipsourceinstall: + $(MAKE) fpc_zipinstall ZIPTARGET=sourceinstall ZIPSUFFIX=$(ZIPSOURCESUFFIX) +fpc_zipexampleinstall: +ifdef HASEXAMPLES + $(MAKE) fpc_zipinstall ZIPTARGET=exampleinstall ZIPSUFFIX=$(ZIPEXAMPLESUFFIX) +endif +fpc_zipdistinstall: + $(MAKE) fpc_zipinstall ZIPTARGET=distinstall +.PHONY: fpc_clean fpc_cleanall fpc_distclean +ifdef EXEFILES +override CLEANEXEFILES:=$(addprefix $(TARGETDIRPREFIX),$(CLEANEXEFILES)) +override CLEANEXEDBGFILES:=$(addprefix $(TARGETDIRPREFIX),$(CLEANEXEDBGFILES)) +endif +ifdef CLEAN_PROGRAMS +override CLEANEXEFILES+=$(addprefix $(TARGETDIRPREFIX),$(addsuffix $(EXEEXT), $(CLEAN_PROGRAMS))) +override CLEANEXEDBGFILES+=$(addprefix $(TARGETDIRPREFIX),$(addsuffix $(EXEDBGEXT), $(CLEAN_PROGRAMS))) +endif +ifdef CLEAN_UNITS +override CLEANPPUFILES+=$(addsuffix $(PPUEXT),$(CLEAN_UNITS)) +endif +ifdef CLEANPPUFILES +override CLEANPPULINKFILES:=$(subst $(PPUEXT),$(OEXT),$(CLEANPPUFILES)) $(subst $(PPUEXT),$(LTOEXT),$(CLEANPPUFILES)) $(addprefix $(STATICLIBPREFIX),$(subst $(PPUEXT),$(STATICLIBEXT),$(CLEANPPUFILES))) $(addprefix $(IMPORTLIBPREFIX),$(subst $(PPUEXT),$(STATICLIBEXT),$(CLEANPPUFILES))) +ifdef DEBUGSYMEXT +override CLEANPPULINKFILES+=$(subst $(PPUEXT),$(DEBUGSYMEXT),$(CLEANPPUFILES)) +endif +override CLEANPPUFILENAMES:=$(CLEANPPUFILES) +override CLEANPPUFILES=$(addprefix $(UNITTARGETDIRPREFIX),$(CLEANPPUFILENAMES)) +override CLEANPPULINKFILENAMES:=$(CLEANPPULINKFILES) +override CLEANPPULINKFILES=$(wildcard $(addprefix $(UNITTARGETDIRPREFIX),$(CLEANPPULINKFILENAMES))) +endif +fpc_clean: $(CLEANTARGET) +ifdef CLEANEXEFILES + -$(DEL) $(CLEANEXEFILES) +endif +ifdef CLEANEXEDBGFILES + -$(DELTREE) $(CLEANEXEDBGFILES) +endif +ifdef CLEANPPUFILES + -$(DEL) $(CLEANPPUFILES) +endif +ifneq ($(CLEANPPULINKFILES),) + -$(DEL) $(CLEANPPULINKFILES) +endif +ifdef CLEANRSTFILES + -$(DEL) $(addprefix $(UNITTARGETDIRPREFIX),$(CLEANRSTFILES)) +endif +ifdef CLEAN_FILES + -$(DEL) $(CLEAN_FILES) +endif +ifdef LIB_NAME + -$(DEL) $(LIB_NAME) $(LIB_FULLNAME) +endif + -$(DEL) $(FPCMADE) *$(FULL_TARGET).fpm Package.fpc *$(ASMEXT) + -$(DEL) $(FPCEXTFILE) $(REDIRFILE) script*.res link*.res *_script.res *_link.res + -$(DEL) $(PPAS) *_ppas$(BATCHEXT) ppas$(BATCHEXT) ppaslink$(BATCHEXT) +fpc_cleanall: $(CLEANTARGET) +ifdef CLEANEXEFILES + -$(DEL) $(CLEANEXEFILES) +endif +ifdef COMPILER_UNITTARGETDIR +ifdef CLEANPPUFILES + -$(DEL) $(CLEANPPUFILES) +endif +ifneq ($(CLEANPPULINKFILES),) + -$(DEL) $(CLEANPPULINKFILES) +endif +ifdef CLEANRSTFILES + -$(DEL) $(addprefix $(UNITTARGETDIRPREFIX),$(CLEANRSTFILES)) +endif +endif +ifdef CLEAN_FILES + -$(DEL) $(CLEAN_FILES) +endif + -$(DELTREE) units + -$(DELTREE) bin + -$(DEL) *$(OEXT) *$(LTOEXT) *$(PPUEXT) *$(RSTEXT) *$(ASMEXT) *$(STATICLIBEXT) *$(SHAREDLIBEXT) *$(PPLEXT) +ifneq ($(PPUEXT),.ppu) + -$(DEL) *.o *.ppu *.a +endif + -$(DELTREE) *$(SMARTEXT) + -$(DEL) fpcmade.* Package.fpc *.fpm + -$(DEL) $(FPCEXTFILE) $(REDIRFILE) script*.res link*.res *_script.res *_link.res + -$(DEL) $(PPAS) *_ppas$(BATCHEXT) ppas$(BATCHEXT) ppaslink$(BATCHEXT) +ifdef AOUTEXT + -$(DEL) *$(AOUTEXT) +endif +ifdef DEBUGSYMEXT + -$(DEL) *$(DEBUGSYMEXT) +endif +ifdef LOCALFPMAKEBIN + -$(DEL) $(LOCALFPMAKEBIN) + -$(DEL) $(FPMAKEBINOBJ) +endif +fpc_distclean: cleanall +.PHONY: fpc_baseinfo +override INFORULES+=fpc_baseinfo +fpc_baseinfo: + @$(ECHO) + @$(ECHO) == Package info == + @$(ECHO) Package Name..... $(PACKAGE_NAME) + @$(ECHO) Package Version.. $(PACKAGE_VERSION) + @$(ECHO) + @$(ECHO) == Configuration info == + @$(ECHO) + @$(ECHO) FPC.......... $(FPC) + @$(ECHO) FPC Version.. $(FPC_VERSION) + @$(ECHO) Source CPU... $(CPU_SOURCE) + @$(ECHO) Target CPU... $(CPU_TARGET) + @$(ECHO) Source OS.... $(OS_SOURCE) + @$(ECHO) Target OS.... $(OS_TARGET) + @$(ECHO) Full Source.. $(FULL_SOURCE) + @$(ECHO) Full Target.. $(FULL_TARGET) + @$(ECHO) SourceSuffix. $(SOURCESUFFIX) + @$(ECHO) TargetSuffix. $(TARGETSUFFIX) + @$(ECHO) FPC fpmake... $(FPCFPMAKE) + @$(ECHO) + @$(ECHO) == Directory info == + @$(ECHO) + @$(ECHO) Required pkgs... $(REQUIRE_PACKAGES) + @$(ECHO) + @$(ECHO) Basedir......... $(BASEDIR) + @$(ECHO) FPCDir.......... $(FPCDIR) + @$(ECHO) CrossBinDir..... $(CROSSBINDIR) + @$(ECHO) UnitsDir........ $(UNITSDIR) + @$(ECHO) PackagesDir..... $(PACKAGESDIR) + @$(ECHO) + @$(ECHO) GCC library..... $(GCCLIBDIR) + @$(ECHO) Other library... $(OTHERLIBDIR) + @$(ECHO) + @$(ECHO) == Tools info == + @$(ECHO) + @$(ECHO) As........ $(AS) + @$(ECHO) Ld........ $(LD) + @$(ECHO) Ar........ $(AR) + @$(ECHO) Rc........ $(RC) + @$(ECHO) + @$(ECHO) Mv........ $(MVPROG) + @$(ECHO) Cp........ $(CPPROG) + @$(ECHO) Rm........ $(RMPROG) + @$(ECHO) GInstall.. $(GINSTALL) + @$(ECHO) Echo...... $(ECHO) + @$(ECHO) Shell..... $(SHELL) + @$(ECHO) Date...... $(DATE) + @$(ECHO) FPCMake... $(FPCMAKE) + @$(ECHO) PPUMove... $(PPUMOVE) + @$(ECHO) Zip....... $(ZIPPROG) + @$(ECHO) + @$(ECHO) == Object info == + @$(ECHO) + @$(ECHO) Target Loaders........ $(TARGET_LOADERS) + @$(ECHO) Target Units.......... $(TARGET_UNITS) + @$(ECHO) Target Implicit Units. $(TARGET_IMPLICITUNITS) + @$(ECHO) Target Programs....... $(TARGET_PROGRAMS) + @$(ECHO) Target Dirs........... $(TARGET_DIRS) + @$(ECHO) Target Examples....... $(TARGET_EXAMPLES) + @$(ECHO) Target ExampleDirs.... $(TARGET_EXAMPLEDIRS) + @$(ECHO) + @$(ECHO) Clean Units......... $(CLEAN_UNITS) + @$(ECHO) Clean Files......... $(CLEAN_FILES) + @$(ECHO) + @$(ECHO) Install Units....... $(INSTALL_UNITS) + @$(ECHO) Install Files....... $(INSTALL_FILES) + @$(ECHO) + @$(ECHO) == Install info == + @$(ECHO) + @$(ECHO) DateStr.............. $(DATESTR) + @$(ECHO) ZipName.............. $(ZIPNAME) + @$(ECHO) ZipPrefix............ $(ZIPPREFIX) + @$(ECHO) ZipCrossPrefix....... $(ZIPCROSSPREFIX) + @$(ECHO) ZipSuffix............ $(ZIPSUFFIX) + @$(ECHO) FullZipName.......... $(FULLZIPNAME) + @$(ECHO) Install FPC Package.. $(INSTALL_FPCPACKAGE) + @$(ECHO) + @$(ECHO) Install base dir..... $(INSTALL_BASEDIR) + @$(ECHO) Install binary dir... $(INSTALL_BINDIR) + @$(ECHO) Install library dir.. $(INSTALL_LIBDIR) + @$(ECHO) Install units dir.... $(INSTALL_UNITDIR) + @$(ECHO) Install source dir... $(INSTALL_SOURCEDIR) + @$(ECHO) Install doc dir...... $(INSTALL_DOCDIR) + @$(ECHO) Install example dir.. $(INSTALL_EXAMPLEDIR) + @$(ECHO) Install data dir..... $(INSTALL_DATADIR) + @$(ECHO) + @$(ECHO) Dist destination dir. $(DIST_DESTDIR) + @$(ECHO) Dist zip name........ $(DIST_ZIPNAME) + @$(ECHO) +.PHONY: fpc_info +fpc_info: $(INFORULES) +.PHONY: fpc_makefile fpc_makefiles fpc_makefile_sub1 fpc_makefile_sub2 \ + fpc_makefile_dirs +fpc_makefile: + $(FPCMAKE) -w -T$(OS_TARGET) Makefile.fpc +fpc_makefile_sub1: +ifdef TARGET_DIRS + $(FPCMAKE) -w -T$(OS_TARGET) $(addsuffix /Makefile.fpc,$(TARGET_DIRS)) +endif +ifdef TARGET_EXAMPLEDIRS + $(FPCMAKE) -w -T$(OS_TARGET) $(addsuffix /Makefile.fpc,$(TARGET_EXAMPLEDIRS)) +endif +fpc_makefile_sub2: $(addsuffix _makefile_dirs,$(TARGET_DIRS) $(TARGET_EXAMPLEDIRS)) +fpc_makefile_dirs: fpc_makefile_sub1 fpc_makefile_sub2 +fpc_makefiles: fpc_makefile fpc_makefile_dirs +units: +examples: +shared: +sourceinstall: fpc_sourceinstall +exampleinstall: fpc_exampleinstall +zipexampleinstall: fpc_zipexampleinstall +info: fpc_info +makefiles: fpc_makefiles +.PHONY: units examples shared sourceinstall exampleinstall zipexampleinstall info makefiles +ifneq ($(wildcard fpcmake.loc),) +include fpcmake.loc +endif +override FPCOPT:=$(filter-out -FU%,$(FPCOPT)) +override FPCOPT:=$(filter-out -FE%,$(FPCOPT)) +override FPCOPT:=$(filter-out $(addprefix -Fu,$(COMPILER_UNITDIR)),$(FPCOPT))# Compose general fpmake-parameters +ifdef FPMAKEOPT +FPMAKE_OPT+=$(FPMAKEOPT) +endif +FPMAKE_OPT+=--localunitdir=../.. +FPMAKE_OPT+=--globalunitdir=.. +FPMAKE_OPT+=$(FPC_TARGETOPT) +FPMAKE_OPT+=$(addprefix -o ,$(FPCOPT)) +FPMAKE_OPT+=--compiler=$(FPC) +FPMAKE_OPT+=-bu +.NOTPARALLEL: +fpmake$(SRCEXEEXT): fpmake.pp + $(FPCFPMAKE) fpmake.pp $(FPMAKE_SKIP_CONFIG) $(addprefix -Fu,$(COMPILER_FPMAKE_UNITDIR)) $(FPCMAKEOPT) $(OPT) +all: fpmake$(SRCEXEEXT) + $(LOCALFPMAKE) compile $(FPMAKE_OPT) +smart: fpmake$(SRCEXEEXT) + $(LOCALFPMAKE) compile $(FPMAKE_OPT) -o -XX -o -CX +release: fpmake$(SRCEXEEXT) + $(LOCALFPMAKE) compile $(FPMAKE_OPT) -o -dRELEASE +debug: fpmake$(SRCEXEEXT) + $(LOCALFPMAKE) compile $(FPMAKE_OPT) -o -dDEBUG +ifeq ($(FPMAKE_BIN_CLEAN),) +clean: +else +clean: + $(FPMAKE_BIN_CLEAN) clean $(FPMAKE_OPT) +endif +ifeq ($(FPMAKE_BIN_CLEAN),) +distclean: $(addsuffix _distclean,$(TARGET_DIRS)) fpc_cleanall +else +distclean: +ifdef inUnix + { $(FPMAKE_BIN_CLEAN) distclean $(FPMAKE_OPT); if [ $$? != "0" ]; then { echo Something wrong with fpmake exectable. Remove the executable and call make recursively to recover.; $(DEL) $(FPMAKE_BIN_CLEAN); $(MAKE) fpc_cleanall; }; fi; } +else + $(FPMAKE_BIN_CLEAN) distclean $(FPMAKE_OPT) +endif + -$(DEL) $(LOCALFPMAKE) +endif +cleanall: distclean +install: fpmake$(SRCEXEEXT) +ifdef UNIXHier + $(LOCALFPMAKE) install $(FPMAKE_OPT) --prefix=$(INSTALL_PREFIX) --baseinstalldir=$(INSTALL_LIBDIR)/fpc/$(FPC_VERSION) --unitinstalldir=$(INSTALL_UNITDIR) +else + $(LOCALFPMAKE) install $(FPMAKE_OPT) --prefix=$(INSTALL_BASEDIR) --baseinstalldir=$(INSTALL_BASEDIR) --unitinstalldir=$(INSTALL_UNITDIR) +endif +distinstall: fpmake$(SRCEXEEXT) +ifdef UNIXHier + $(LOCALFPMAKE) install $(FPMAKE_OPT) --prefix=$(INSTALL_PREFIX) --baseinstalldir=$(INSTALL_LIBDIR)/fpc/$(FPC_VERSION) --unitinstalldir=$(INSTALL_UNITDIR) -ie -fsp 0 +else + $(LOCALFPMAKE) install $(FPMAKE_OPT) --prefix=$(INSTALL_BASEDIR) --baseinstalldir=$(INSTALL_BASEDIR) --unitinstalldir=$(INSTALL_UNITDIR) -ie -fsp 0 +endif +zipinstall: fpmake$(SRCEXEEXT) + $(LOCALFPMAKE) zipinstall $(FPMAKE_OPT) --zipprefix=$(DIST_DESTDIR)/$(ZIPPREFIX) +zipdistinstall: fpmake$(SRCEXEEXT) + $(LOCALFPMAKE) zipinstall $(FPMAKE_OPT) --zipprefix=$(DIST_DESTDIR)/$(ZIPPREFIX) -ie -fsp 0 +zipsourceinstall: fpmake$(SRCEXEEXT) +ifdef UNIXHier + $(LOCALFPMAKE) archive $(FPMAKE_OPT) --zipprefix=$(DIST_DESTDIR)/$(ZIPPREFIX) --prefix=share/src/fpc-\$$\(PACKAGEVERSION\)/$(INSTALL_FPCSUBDIR)/\$$\(PACKAGEDIRECTORY\) +else + $(LOCALFPMAKE) archive $(FPMAKE_OPT) --zipprefix=$(DIST_DESTDIR)/$(ZIPPREFIX) --prefix=source\\$(INSTALL_FPCSUBDIR)\\\$$\(PACKAGEDIRECTORY\) +endif diff --git a/packages/tplylib/Makefile.fpc b/packages/tplylib/Makefile.fpc new file mode 100644 index 0000000000..62133821ce --- /dev/null +++ b/packages/tplylib/Makefile.fpc @@ -0,0 +1,102 @@ +# +# Makefile.fpc for running fpmake +# + +[package] +name=tplylib +version=3.3.1 + +[require] +packages=rtl fpmkunit + +[install] +fpcpackage=y + +[default] +fpcdir=../.. + +[prerules] +FPMAKE_BIN_CLEAN=$(wildcard ./fpmake$(SRCEXEEXT)) +ifdef OS_TARGET +FPC_TARGETOPT+=--os=$(OS_TARGET) +endif +ifdef CPU_TARGET +FPC_TARGETOPT+=--cpu=$(CPU_TARGET) +endif +LOCALFPMAKE=./fpmake$(SRCEXEEXT) + +[rules] +# Do not pass the Makefile's unit and binary target locations. Fpmake uses it's own. +override FPCOPT:=$(filter-out -FU%,$(FPCOPT)) +override FPCOPT:=$(filter-out -FE%,$(FPCOPT)) +# Do not pass the package-unitdirectories. Fpmake adds those and this way they don't apear in the .fpm +override FPCOPT:=$(filter-out $(addprefix -Fu,$(COMPILER_UNITDIR)),$(FPCOPT))# Compose general fpmake-parameters +# Compose general fpmake-parameters +ifdef FPMAKEOPT +FPMAKE_OPT+=$(FPMAKEOPT) +endif +FPMAKE_OPT+=--localunitdir=../.. +FPMAKE_OPT+=--globalunitdir=.. +FPMAKE_OPT+=$(FPC_TARGETOPT) +FPMAKE_OPT+=$(addprefix -o ,$(FPCOPT)) +FPMAKE_OPT+=--compiler=$(FPC) +FPMAKE_OPT+=-bu +.NOTPARALLEL: + +fpmake$(SRCEXEEXT): fpmake.pp + $(FPCFPMAKE) fpmake.pp $(FPMAKE_SKIP_CONFIG) $(addprefix -Fu,$(COMPILER_FPMAKE_UNITDIR)) $(FPCMAKEOPT) $(OPT) +all: fpmake$(SRCEXEEXT) + $(LOCALFPMAKE) compile $(FPMAKE_OPT) +smart: fpmake$(SRCEXEEXT) + $(LOCALFPMAKE) compile $(FPMAKE_OPT) -o -XX -o -CX +release: fpmake$(SRCEXEEXT) + $(LOCALFPMAKE) compile $(FPMAKE_OPT) -o -dRELEASE +debug: fpmake$(SRCEXEEXT) + $(LOCALFPMAKE) compile $(FPMAKE_OPT) -o -dDEBUG +# If no fpmake exists and (dist)clean is called, do not try to build fpmake, it will +# most often fail because the dependencies are cleared. +# In case of a clean, simply do nothing +ifeq ($(FPMAKE_BIN_CLEAN),) +clean: +else +clean: + $(FPMAKE_BIN_CLEAN) clean $(FPMAKE_OPT) +endif +# In case of a distclean, perform an 'old'-style distclean. This to avoid problems +# when the package is compiled using fpcmake prior to running this clean using fpmake +ifeq ($(FPMAKE_BIN_CLEAN),) +distclean: $(addsuffix _distclean,$(TARGET_DIRS)) fpc_cleanall +else +distclean: +ifdef inUnix + { $(FPMAKE_BIN_CLEAN) distclean $(FPMAKE_OPT); if [ $$? != "0" ]; then { echo Something wrong with fpmake exectable. Remove the executable and call make recursively to recover.; $(DEL) $(FPMAKE_BIN_CLEAN); $(MAKE) fpc_cleanall; }; fi; } +else + $(FPMAKE_BIN_CLEAN) distclean $(FPMAKE_OPT) +endif + -$(DEL) $(LOCALFPMAKE) +endif +cleanall: distclean +install: fpmake$(SRCEXEEXT) +ifdef UNIXHier + $(LOCALFPMAKE) install $(FPMAKE_OPT) --prefix=$(INSTALL_PREFIX) --baseinstalldir=$(INSTALL_LIBDIR)/fpc/$(FPC_VERSION) --unitinstalldir=$(INSTALL_UNITDIR) +else + $(LOCALFPMAKE) install $(FPMAKE_OPT) --prefix=$(INSTALL_BASEDIR) --baseinstalldir=$(INSTALL_BASEDIR) --unitinstalldir=$(INSTALL_UNITDIR) +endif +# distinstall also installs the example-sources and omits the location of the source- +# files from the fpunits.cfg files. +distinstall: fpmake$(SRCEXEEXT) +ifdef UNIXHier + $(LOCALFPMAKE) install $(FPMAKE_OPT) --prefix=$(INSTALL_PREFIX) --baseinstalldir=$(INSTALL_LIBDIR)/fpc/$(FPC_VERSION) --unitinstalldir=$(INSTALL_UNITDIR) -ie -fsp 0 +else + $(LOCALFPMAKE) install $(FPMAKE_OPT) --prefix=$(INSTALL_BASEDIR) --baseinstalldir=$(INSTALL_BASEDIR) --unitinstalldir=$(INSTALL_UNITDIR) -ie -fsp 0 +endif +zipinstall: fpmake$(SRCEXEEXT) + $(LOCALFPMAKE) zipinstall $(FPMAKE_OPT) --zipprefix=$(DIST_DESTDIR)/$(ZIPPREFIX) +zipdistinstall: fpmake$(SRCEXEEXT) + $(LOCALFPMAKE) zipinstall $(FPMAKE_OPT) --zipprefix=$(DIST_DESTDIR)/$(ZIPPREFIX) -ie -fsp 0 +zipsourceinstall: fpmake$(SRCEXEEXT) +ifdef UNIXHier + $(LOCALFPMAKE) archive $(FPMAKE_OPT) --zipprefix=$(DIST_DESTDIR)/$(ZIPPREFIX) --prefix=share/src/fpc-\$$\(PACKAGEVERSION\)/$(INSTALL_FPCSUBDIR)/\$$\(PACKAGEDIRECTORY\) +else + $(LOCALFPMAKE) archive $(FPMAKE_OPT) --zipprefix=$(DIST_DESTDIR)/$(ZIPPREFIX) --prefix=source\\$(INSTALL_FPCSUBDIR)\\\$$\(PACKAGEDIRECTORY\) +endif diff --git a/packages/tplylib/fpmake.pp b/packages/tplylib/fpmake.pp new file mode 100644 index 0000000000..1756b0e391 --- /dev/null +++ b/packages/tplylib/fpmake.pp @@ -0,0 +1,54 @@ +{$ifndef ALLPACKAGES} +{$mode objfpc}{$H+} +program fpmake; + +uses fpmkunit; + +Var + T : TTarget; + P : TPackage; +begin + With Installer do + begin +{$endif ALLPACKAGES} + + P:=AddPackage('tplylib'); + P.ShortName:='tplylib'; +{$ifdef ALLPACKAGES} + P.Directory:=ADirectory; +{$endif ALLPACKAGES} + P.Version:='3.3.1'; + + { java and jvm-android do not support + fpc_get_output used in these sources } + if Defaults.CPU=jvm then + P.OSes := P.OSes - [java,android]; + { palmos does not support command line parameters } + P.OSes := P.OSes - [palmos]; + { Program does not fit in 16-bit memory constraints } + P.OSes := P.OSes - [msdos,win16]; + { avr-embedded and i8086-embedded do not meet needed requirements } + if Defaults.CPU in [avr,i8086] then + P.OSes := P.OSes - [embedded]; + + P.Author := ''; + P.License := 'LGPL with modification'; + P.HomepageURL := 'www.freepascal.org'; + P.Email := ''; + P.Description := 'Library units for a compiler generator for Turbo Pascal and compatibles.'; + P.NeedLibC:= false; + + P.SourcePath.Add('src'); + P.IncludePath.Add('src'); + + P.Options.Add('-Sg'); + + P.Targets.AddUnit('lexlib.pas'); + P.Targets.AddUnit('yacclib.pas'); + +{$ifndef ALLPACKAGES} + Run; + end; +end. +{$endif ALLPACKAGES} + diff --git a/utils/tply/lexlib.pas b/packages/tplylib/src/lexlib.pas similarity index 95% rename from utils/tply/lexlib.pas rename to packages/tplylib/src/lexlib.pas index d22bbdec52..a2658db7b3 100644 --- a/utils/tply/lexlib.pas +++ b/packages/tplylib/src/lexlib.pas @@ -70,15 +70,15 @@ yyleng : Byte (* length of matched text *) put_char by another suitable set of routines, e.g. if you want to read from/write to memory, etc. *) -function get_char : Char; +var get_char: function : Char; (* obtain one character from the input file (null character at end-of- file) *) -procedure unget_char ( c : Char ); +var unget_char : procedure ( c : Char ); (* return one character to the input file to be reread in subsequent calls to get_char *) -procedure put_char ( c : Char ); +var put_char: procedure ( c : Char ); (* write one character to the output file *) (* Utility routines: *) @@ -185,7 +185,7 @@ var bufptr : Integer; buf : array [1..max_chars] of Char; -function get_char : Char; +function lexlib_get_char : Char; var i : Integer; begin if (bufptr=0) and not eof(yyinput) then @@ -199,15 +199,15 @@ function get_char : Char; end; if bufptr>0 then begin - get_char := buf[bufptr]; + lexlib_get_char := buf[bufptr]; dec(bufptr); inc(yycolno); end else - get_char := #0; + lexlib_get_char := #0; end(*get_char*); -procedure unget_char ( c : Char ); +procedure lexlib_unget_char ( c : Char ); begin if bufptr=max_chars then fatal('input buffer overflow'); inc(bufptr); @@ -215,7 +215,7 @@ procedure unget_char ( c : Char ); buf[bufptr] := c; end(*unget_char*); -procedure put_char ( c : Char ); +procedure lexlib_put_char ( c : Char ); begin if c=#0 then { ignore } @@ -285,7 +285,7 @@ procedure reject; begin yyreject := true; for i := yyleng+1 to yysleng do - yytext := yytext+get_char; + yytext := yytext+get_char(); dec(yymatches); end(*reject*); @@ -334,7 +334,7 @@ procedure yynew; procedure yyscan; begin if yyleng=255 then fatal('yytext overflow'); - yyactchar := get_char; + yyactchar := get_char(); inc(yyleng); yytext[yyleng] := yyactchar; end(*yyscan*); @@ -380,7 +380,7 @@ function yyfind ( var n : Integer ) : Boolean; function yydefault : Boolean; begin yyreject := false; - yyactchar := get_char; + yyactchar := get_char(); if yyactchar<>#0 then begin put_char(yyactchar); @@ -406,6 +406,9 @@ procedure yyclear; begin yywrap := @lexlib_yywrap; + get_char:= @lexlib_get_char; + unget_char:= @lexlib_unget_char; + put_char:= @lexlib_put_char; assign(yyinput, ''); assign(yyoutput, ''); reset(yyinput); rewrite(yyoutput); diff --git a/utils/tply/yacclib.pas b/packages/tplylib/src/yacclib.pas similarity index 100% rename from utils/tply/yacclib.pas rename to packages/tplylib/src/yacclib.pas diff --git a/utils/fpcres/fpcres.pas b/utils/fpcres/fpcres.pas index 034d9f0a66..65fab5d2ec 100644 --- a/utils/fpcres/fpcres.pas +++ b/utils/fpcres/fpcres.pas @@ -23,12 +23,11 @@ uses closablefilestream, resource, //readers resreader, coffreader, winpeimagereader, elfreader, machoreader, - externalreader, dfmreader, tlbreader, + externalreader, dfmreader, tlbreader, rcreader, //writers reswriter, coffwriter, xcoffwriter, elfwriter, machowriter, externalwriter, //misc - elfconsts, cofftypes, machotypes, externaltypes - ; + elfconsts, cofftypes, machotypes, externaltypes; const halt_no_err = 0; @@ -66,6 +65,10 @@ begin writeln(' --version, -V Show program version.'); writeln(' --verbose, -v Be verbose.'); writeln(' --input, -i Ignored for compatibility.'); + writeln(' --include, -I RC files: add a path for include searches'); + writeln(' --define, -D [=]'); + writeln(' RC files: define a symbol (and value)'); + writeln(' --undefine, -U RC files: undefine a symbol'); writeln(' --output, -o Set the output file name.'); writeln(' -of Set the output file format. Supported formats:'); writeln(' res, elf, coff, mach-o, external'); @@ -212,6 +215,9 @@ begin resources:=TResources.Create; sourcefiles:=TSourceFiles.Create; sourcefiles.FileList.AddStrings(params.InputFiles); + sourcefiles.RCDefines.AddStrings(params.RCDefines); + sourcefiles.RCIncludeDirs.AddStrings(params.RCIncludeDirs); + sourcefiles.RCMode:=CurrentTarget.objformat=ofRes; try sourcefiles.Load(resources); except diff --git a/utils/fpcres/paramparser.pas b/utils/fpcres/paramparser.pas index ab0ff926b3..b66f17e4d9 100644 --- a/utils/fpcres/paramparser.pas +++ b/utils/fpcres/paramparser.pas @@ -45,8 +45,12 @@ type fInputFiles : TStringList; fOutputFile : string; fTarget : TResTarget; + fRCIncludeDirs: TStringList; + fRCDefines: TStringList; procedure ParseInputFiles(aList : TStringList; var index : integer; const parname : string); + procedure ParseRCInclude(aList: TStringList; var index: integer; const parname: string); + procedure ParseRCUnDefine(aList: TStringList; var index: integer; const parname: string); procedure ParseOutputFile(aList : TStringList; var index : integer; const parname : string); procedure ParseOutputFormat(aList : TStringList; var index : integer; const parname : string);virtual; procedure ParseArchitecture(aList : TStringList; var index : integer; const parname : string);virtual; @@ -65,6 +69,8 @@ type property Version : boolean read fVersion; property Verbose : boolean read fVerbose; property InputFiles : TStringList read fInputFiles; + property RCIncludeDirs: TStringList read fRCIncludeDirs; + property RCDefines: TStringList read fRCDefines; property OutputFile : string read fOutputFile write fOutputFile; property Target : TResTarget read fTarget; end; @@ -195,6 +201,42 @@ begin end; end; +procedure TParameters.ParseRCInclude(aList: TStringList; var index: integer; + const parname : string); +var + tmp: String; +begin + inc(index); + tmp:=DoMandatoryArgument(aList,index); + if tmp='' then + raise EArgumentMissingException.Create(parname); + fRCIncludeDirs.Add(tmp); +end; + +procedure TParameters.ParseRCUnDefine(aList: TStringList; var index: integer; + const parname : string); +var + tmp: String; + i: integer; +begin + inc(index); + tmp:=DoMandatoryArgument(aList,index); + if tmp='' then + raise EArgumentMissingException.Create(parname); + if (parname='-D') or (parname='--define') then begin + i:= pos('=', tmp); + if i<1 then + fRCDefines.Values[tmp]:= '' + else + fRCDefines.Values[Copy(tmp, 1, i-1)]:= Copy(tmp, i+1); + end else begin + i:= fRCDefines.IndexOfName(tmp); + if i >= 0 then + fRCDefines.Delete(i); + end; + fRCIncludeDirs.Add(tmp); +end; + procedure TParameters.ParseOutputFile(aList: TStringList; var index: integer; const parname : string); begin @@ -361,6 +403,11 @@ begin fVerbose:=true else if ((tmp='-i') or (tmp='--input')) then ParseInputFiles(fList,i,tmp) + else if ((tmp='-I') or (tmp='--include')) then + ParseRCInclude(fList,i,tmp) + else if ((tmp='-D') or (tmp='--define')) + or ((tmp='-U') or (tmp='--undefine')) then + ParseRCUnDefine(fList,i,tmp) else if ((tmp='-o') or (tmp='--output')) then ParseOutputFile(fList,i,tmp) else if (tmp='-of') then @@ -386,10 +433,14 @@ end; constructor TParameters.Create; begin + inherited Create; fHelp:=false; fVersion:=false; fVerbose:=false; fInputFiles:=TStringList.Create; + fRCIncludeDirs:= TStringList.Create; + fRCIncludeDirs.Duplicates:= dupIgnore; + fRCDefines:= TStringList.Create; fOutputFile:=''; fTarget.machine:=mtnone; GetDefaultSubMachineForMachine(fTarget.machine); @@ -398,7 +449,10 @@ end; destructor TParameters.Destroy; begin + fRCDefines.Free; + fRCIncludeDirs.Free; fInputFiles.Free; + inherited; end; end. diff --git a/utils/fpcres/sourcehandler.pas b/utils/fpcres/sourcehandler.pas index a47400d92b..534710fbf8 100644 --- a/utils/fpcres/sourcehandler.pas +++ b/utils/fpcres/sourcehandler.pas @@ -36,33 +36,46 @@ type private protected fFileList : TStringList; + fRCIncludeDirs: TStringList; + fRCDefines: TStringList; fStreamList : TFPList; + fRCMode: Boolean; public constructor Create; destructor Destroy; override; procedure Load(aResources : TResources); property FileList : TStringList read fFileList; + property RCIncludeDirs: TStringList read fRCIncludeDirs; + property RCDefines: TStringList read fRCDefines; + property RCMode: Boolean read fRCMode write fRCMode; end; implementation -uses msghandler, closablefilestream; +uses msghandler, closablefilestream, rcreader; { TSourceFiles } constructor TSourceFiles.Create; begin + inherited Create; fFileList:=TStringList.Create; fStreamList:=TFPList.Create; + fRCDefines:= TStringList.Create; + fRCIncludeDirs:= TStringList.Create; + fRCMode:=False; end; destructor TSourceFiles.Destroy; var i : integer; begin + fRCIncludeDirs.Free; + fRCDefines.Free; fFileList.Free; for i:=0 to fStreamList.Count-1 do TStream(fStreamList[i]).Free; fStreamList.Free; + inherited; end; procedure TSourceFiles.Load(aResources: TResources); @@ -70,7 +83,9 @@ var aReader : TAbstractResourceReader; aStream : TClosableFileStream; i : integer; tmpres : TResources; + olddir : String; begin + olddir:=GetCurrentDir; tmpres:=TResources.Create; try for i:=0 to fFileList.Count-1 do @@ -82,18 +97,30 @@ begin raise ECantOpenFileException.Create(fFileList[i]); end; fStreamList.Add(aStream); - try - aReader:=TResources.FindReader(aStream); - except - raise EUnknownInputFormatException.Create(fFileList[i]); - end; + { the RC reader reads anything, so handle that separately } + if fRCMode then + aReader:=TRCResourceReader.Create + else + try + aReader:=TResources.FindReader(aStream); + except + raise EUnknownInputFormatException.Create(fFileList[i]); + end; Messages.DoVerbose(Format('Chosen reader: %s',[aReader.Description])); try Messages.DoVerbose('Reading resource information...'); + if aReader is TRCResourceReader then begin + TRCResourceReader(aReader).RCIncludeDirs.Assign(fRCIncludeDirs); + TRCResourceReader(aReader).RCDefines.Assign(fRCDefines); + SetCurrentDir(ExtractFilePath(ExpandFileName(fFileList[i]))); + end; tmpres.LoadFromStream(aStream,aReader); aResources.MoveFrom(tmpres); Messages.DoVerbose('Resource information read'); finally + if aReader is TRCResourceReader then begin + SetCurrentDir(olddir); + end; aReader.Free; end; end; diff --git a/utils/tply/fpmake.pp b/utils/tply/fpmake.pp index 61d0840a0e..ffe280135c 100644 --- a/utils/tply/fpmake.pp +++ b/utils/tply/fpmake.pp @@ -39,6 +39,8 @@ begin P.Directory:=ADirectory; P.Version:='3.2.1'; + P.Dependencies.Add('tplylib'); + P.Options.Add('-Sg'); T:=P.Targets.AddProgram('plex.pas'); @@ -62,10 +64,6 @@ begin T.Dependencies.AddUnit('yacclr0'); T.Dependencies.AddUnit('yacctabl'); - - P.Targets.AddUnit('lexlib.pas'); - P.Targets.AddUnit('yacclib.pas'); - P.Targets.AddUnit('lexbase.pas').install:=false; P.Targets.AddUnit('lexopt.pas').install:=false; P.Targets.AddUnit('lexdfa.pas').install:=false; diff --git a/utils/tply/lexdfa.pas b/utils/tply/lexdfa.pas index d43ef7ce31..5c3811ca60 100644 --- a/utils/tply/lexdfa.pas +++ b/utils/tply/lexdfa.pas @@ -53,7 +53,8 @@ procedure makeDFATable; begin (* initialize start states: *) for i := 2 to 2*n_start_states+1 do - setunion(first_pos_table^[i]^, first_pos_table^[i mod 2]^); + if not start_excl^[i div 2] then + setunion(first_pos_table^[i]^, first_pos_table^[i mod 2]^); for i := 0 to 2*n_start_states+1 do act_state := newState(first_pos_table^[i]); act_state := -1; diff --git a/utils/tply/lextable.pas b/utils/tply/lextable.pas index 1902196fc3..49b4db4ead 100644 --- a/utils/tply/lextable.pas +++ b/utils/tply/lextable.pas @@ -105,6 +105,8 @@ FirstPosTable = array [0..2*max_start_states+1] of IntSetPtr; default, states 2..2*n_start_states+1 user-defined start states) *) +StartStateExclusive = array[0..max_start_states] of Boolean; + StateTableEntry = record state_pos : IntSetPtr; (* positions covered by state *) @@ -137,6 +139,7 @@ optimize : Boolean; (* status of the optimization option *) sym_table : ^SymTable; (* symbol table *) pos_table : ^PosTable; (* position table *) first_pos_table : ^FirstPosTable; (* first positions table *) +start_excl : ^StartStateExclusive; (* user-defined start state type *) state_table : ^StateTable; (* DFA state table *) trans_table : ^TransTable; (* DFA transition table *) @@ -460,6 +463,7 @@ begin new(sym_table); new(pos_table); new(first_pos_table); + new(start_excl); new(state_table); new(trans_table); diff --git a/utils/tply/plex.pas b/utils/tply/plex.pas index 9ea37b962f..b23192e611 100644 --- a/utils/tply/plex.pas +++ b/utils/tply/plex.pas @@ -88,7 +88,7 @@ procedure next_section; var n_rules : Integer; (* current number of rules *) -procedure define_start_state ( symbol : String; pos : Integer ); +procedure define_start_state ( symbol : String; pos : Integer; excl : Boolean ); (* process start state definition *) begin {$ifdef fpc} @@ -106,6 +106,7 @@ procedure define_start_state ( symbol : String; pos : Integer ); writeln(yyout, 'const ', symbol, ' = ', 2*start_state, ';'); first_pos_table^[2*start_state] := newIntSet; first_pos_table^[2*start_state+1] := newIntSet; + start_excl^[start_state] := excl; end else error(symbol_already_defined, pos) @@ -505,12 +506,12 @@ procedure definitions; begin split(line, 2); com := upper(itemv(1)); - if (com='%S') or (com='%START') then + if (com='%S') or (com='%START') or (com='%X') then begin split(line, max_items); for i := 2 to itemc do if check_id(itemv(i)) then - define_start_state(itemv(i), itempos[i]) + define_start_state(itemv(i), itempos[i], com='%X') else error(syntax_error, itempos[i]); end