From 6829cde41372c5de757774594c5029c66c003caa Mon Sep 17 00:00:00 2001 From: Benjamin Rosseaux Date: Tue, 21 Jun 2016 23:56:08 +0200 Subject: [PATCH 01/12] - Initial commit --- bin/btpc.exe | Bin 0 -> 53387 bytes examples/maketest.bat | 2 + examples/test.pas | 36 + src/btpc.dpr | 2766 +++++++++++++++++++++++++++++++++++++++++ src/makeself.bat | 6 + src/rtl.asm | 211 ++++ 6 files changed, 3021 insertions(+) create mode 100644 bin/btpc.exe create mode 100644 examples/maketest.bat create mode 100644 examples/test.pas create mode 100644 src/btpc.dpr create mode 100644 src/makeself.bat create mode 100644 src/rtl.asm diff --git a/bin/btpc.exe b/bin/btpc.exe new file mode 100644 index 0000000000000000000000000000000000000000..86acfb212c9e4d5852d6213b71d8c4d8978d1da1 GIT binary patch literal 53387 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 literal 0 HcmV?d00001 diff --git a/examples/maketest.bat b/examples/maketest.bat new file mode 100644 index 0000000..474a886 --- /dev/null +++ b/examples/maketest.bat @@ -0,0 +1,2 @@ +@echo off +btpc < test.pas > test.exe diff --git a/examples/test.pas b/examples/test.pas new file mode 100644 index 0000000..ece32c9 --- /dev/null +++ b/examples/test.pas @@ -0,0 +1,36 @@ +program Test; +{$ifdef fpc} + {$mode delphi} +{$endif} +{$ifdef Win32} + {$define Windows} +{$endif} +{$ifdef Win64} + {$define Windows} +{$endif} +{$ifdef WinCE} + {$define Windows} +{$endif} +{$ifdef Windows} + {$apptype console} +{$endif} +{$r+,s+} + +procedure x; + procedure y; + begin + WriteLn('BLA'); + end; +begin + y; +end; + +var a,b:integer; +begin + for a:=1 to 16 do begin + for b:=16 downto 1 do begin + WriteLn(a:5,b:5); + end; + end; + x; +end. \ No newline at end of file diff --git a/src/btpc.dpr b/src/btpc.dpr new file mode 100644 index 0000000..c09521d --- /dev/null +++ b/src/btpc.dpr @@ -0,0 +1,2766 @@ +(****************************************************************************** + * BeRoTinyPascal * + ****************************************************************************** + * A self-hosting capable tiny pascal compiler for the Win32 x86 platform * + ****************************************************************************** + * Version 2016-06-21-23-44-0000 * + ****************************************************************************** + * zlib license * + *============================================================================* + * * + * Copyright (C) 2006-2016, Benjamin Rosseaux (benjamin@rosseaux.com) * + * * + * This software is provided 'as-is', without any express or implied * + * warranty. In no event will the authors be held liable for any damages * + * arising from the use of this software. * + * * + * Permission is granted to anyone to use this software for any purpose, * + * including commercial applications, and to alter it and redistribute it * + * freely, subject to the following restrictions: * + * * + * 1. The origin of this software must not be misrepresented; you must not * + * claim that you wrote the original software. If you use this software * + * in a product, an acknowledgement in the product documentation would be * + * appreciated but is not required. * + * 2. Altered source versions must be plainly marked as such, and must not be * + * misrepresented as being the original software. * + * 3. This notice may not be removed or altered from any source distribution. * + * * + ****************************************************************************** + * General guidelines for code contributors * + *============================================================================* + * * + * 1. Make sure you are legally allowed to make a contribution under the zlib * + * license. * + * 2. The zlib license header goes at the top of each source file, with * + * appropriate copyright notice. * + * 3. After a pull request, check the status of your pull request on * + http://github.com/BeRo1985/berotinypacal * + * 4. Write code, which is compatible with Delphi 7-XE7 and FreePascal >= 3.0 * + * and even with BeRoTinyPascal itself, so don't use generics/templates, * + * operator overloading and another newer syntax features than Delphi 7 * + * and BeRoTinyPascal have support for that * + * 5. Don't use any libraries/units except the RTL system unit functions * + * 7. Make sure the code compiles with Delphi 7, FreePascal >= 3.0 and with * + * BeRoTinyPascal itself * + * * + ******************************************************************************) +program BTPC; { BeRoTinyPascalCompiler } +{$ifdef fpc} + {$mode delphi} +{$endif} +{$ifdef Win32} + {$define Windows} +{$endif} +{$ifdef Win64} + {$define Windows} +{$endif} +{$ifdef WinCE} + {$define Windows} +{$endif} +{$ifdef Windows} + {$apptype console} +{$endif} + +const MaximalCodeSize=262144; + MaximalIdentifiers=512; + MaximalTypes=32; + MaximalList=10; + MaximalAlfa=20; + MaximalStringLength=255; + MaximalCases=256; + + OPNone=-1; + OPAdd=0; + OPNeg=1; + OPMul=2; + OPDivD=3; + OPRemD=4; + OPDiv2=5; + OPRem2=6; + OPEqlI=7; + OPNEqI=8; + OPLssI=9; + OPLeqI=10; + OPGtrI=11; + OPGEqI=12; + OPDupl=13; + OPSwap=14; + OPAndB=15; + OPOrB=16; + OPLoad=17; + OPStore=18; + OPHalt=19; + OPWrI=20; + OPWrC=21; + OPWrL=22; + OPRdI=23; + OPRdC=24; + OPRdL=25; + OPEOF=26; + OPEOL=27; + OPLdC=28; + OPLdA=29; + OPLdLA=30; + OPLdL=31; + OPLdG=32; + OPStL=33; + OPStG=34; + OPMove=35; + OPCopy=36; + OPAddC=37; + OPMulC=38; + OPJmp=39; + OPJZ=40; + OPCall=41; + OPAdjS=42; + OPExit=43; + + TokIdent=0; + TokNumber=1; + TokStrC=2; + TokPlus=3; + TokMinus=4; + TokMul=5; + TokLBracket=6; + TokRBracket=7; + TokColon=8; + TokEql=9; + TokNEq=10; + TokLss=11; + TokLEq=12; + TokGtr=13; + TokGEq=14; + TokLParent=15; + TokRParent=16; + TokComma=17; + TokSemi=18; + TokPeriod=19; + TokAssign=20; + SymBEGIN=21; + SymEND=22; + SymIF=23; + SymTHEN=24; + SymELSE=25; + SymWHILE=26; + SymDO=27; + SymCASE=28; + SymREPEAT=29; + SymUNTIL=30; + SymFOR=31; + SymTO=32; + SymDOWNTO=33; + SymNOT=34; + SymDIV=35; + SymMOD=36; + SymAND=37; + SymOR=38; + SymCONST=39; + SymVAR=40; + SymTYPE=41; + SymARRAY=42; + SymOF=43; + SymPACKED=44; + SymRECORD=45; + SymPROGRAM=46; + SymFORWARD=47; + SymHALT=48; + SymFUNC=49; + SymPROC=50; + + IdCONST=0; + IdVAR=1; + IdFIELD=2; + IdTYPE=3; + IdFUNC=4; + + KindSIMPLE=0; + KindARRAY=1; + KindRECORD=2; + + TypeINT=1; + TypeBOOL=2; + TypeCHAR=3; + TypeSTR=4; + + FunCHR=0; + FunORD=1; + FunWRITE=2; + FunWRITELN=3; + FunREAD=4; + FunREADLN=5; + FunEOF=6; + FunEOFLN=7; + +type TAlfa=array[1..MaximalAlfa] of char; + + TIdent=record + Name:TAlfa; + Link:integer; + TypeDefinition:integer; + Kind:integer; + Value:integer; + VariableLevel:integer; + VariableAddress:integer; + ReferencedParameter:boolean; + Offset:integer; + FunctionLevel:integer; + FunctionAddress:integer; + LastParameter:integer; + ReturnAddress:integer; + Inside:boolean; + end; + + TType=record + Size:integer; + Kind:integer; + StartIndex:integer; + EndIndex:integer; + SubType:integer; + Fields:integer; + end; + +var CurrentChar:char; + CurrentColumn:integer; + CurrentLine:integer; + CurrentSymbol:integer; + CurrentIdentifer:TAlfa; + CurrentNumber:integer; + CurrentString:array[1..255] of char; + CurrentStringLength:integer; + FunctionDeclarationIndex:integer; + Keywords:array[SymBEGIN..SymPROC] of TAlfa; + LastOpcode:integer; + CurrentLevel:integer; + IsLabeled:boolean; + SymbolNameList:array[-1..MaximalList] of integer; + IdentifierPosition:integer; + TypePosition:integer; + Identifiers:array[0..MaximalIdentifiers] of TIdent; + Types:array[1..MaximalTypes] of TType; + Code:array[0..MaximalCodeSize] of integer; + CodePosition:integer; + StackPosition:integer; + +function StringCompare(var s1,s2:TAlfa):boolean; +var f:boolean; + i:integer; +begin + f:=true; + i:=1; + while f and (i<=MaximalAlfa) do begin + f:=(s1[i]=s2[i]); + i:=i+1; + end; + StringCompare:=f; +end; + +procedure StringCopy(var Dest:TAlfa;Src:TAlfa); +begin + Dest:=Src; +end; + +procedure Error(n:integer); +begin + Write('Error ',n:1,': '); + case n of + TokIdent:begin + Write('Identifier expected'); + end; + TokNumber:begin + Write('Number expected'); + end; + TokStrC:begin + Write('String expected'); + end; + TokPlus:begin + Write('"+" expected'); + end; + TokMinus:begin + Write('"-" expected'); + end; + TokMul:begin + Write('"*" expected'); + end; + TokLBracket:begin + Write('"[" expected'); + end; + TokRBracket:begin + Write('"]" expected'); + end; + TokColon:begin + Write('":" expected'); + end; + TokEql:begin + Write('"=" expected'); + end; + TokNEq:begin + Write('"<>" expected'); + end; + TokLss:begin + Write('"<" expected'); + end; + TokLEq:begin + Write('"<=" expected'); + end; + TokGtr:begin + Write('">" expected'); + end; + TokGEq:begin + Write('">)" expected'); + end; + TokLParent:begin + Write('"(" expected'); + end; + TokRParent:begin + Write('")" expected'); + end; + TokComma:begin + Write('"," expected'); + end; + TokSemi:begin + Write('";" expected'); + end; + TokPeriod:begin + Write('"." expected'); + end; + TokAssign:begin + Write('":=" expected'); + end; + SymBEGIN:begin + Write('"begin" expected'); + end; + SymEND:begin + Write('"end" expected'); + end; + SymIF:begin + Write('"if" expected'); + end; + SymTHEN:begin + Write('"then" expected'); + end; + SymELSE:begin + Write('"else" expected'); + end; + SymWHILE:begin + Write('"else" expected'); + end; + SymDO:begin + Write('"do" expected'); + end; + SymCASE:begin + Write('"case" expected'); + end; + SymREPEAT:begin + Write('"repeat" expected'); + end; + SymUNTIL:begin + Write('"until" expected'); + end; + SymFOR:begin + Write('"for" expected'); + end; + SymTO:begin + Write('"to" expected'); + end; + SymDOWNTO:begin + Write('"downto" expected'); + end; + SymNOT:begin + Write('"not" expected'); + end; + SymDIV:begin + Write('"div" expected'); + end; + SymMOD:begin + Write('"mod" expected'); + end; + SymAND:begin + Write('"and" expected'); + end; + SymOR:begin + Write('"or" expected'); + end; + SymCONST:begin + Write('"const" expected'); + end; + SymVAR:begin + Write('"var" expected'); + end; + SymTYPE:begin + Write('"type" expected'); + end; + SymARRAY:begin + Write('"array" expected'); + end; + SymOF:begin + Write('"of" expected'); + end; + SymPACKED:begin + Write('"packed" expected'); + end; + SymRECORD:begin + Write('"record" expected'); + end; + SymPROGRAM:begin + Write('"program" expected'); + end; + SymFORWARD:begin + Write('"forward" expected'); + end; + SymHALT:begin + Write('"halt" expected'); + end; + SymFUNC:begin + Write('"function" expected'); + end; + SymPROC:begin + Write('"procedure" expected'); + end; + 100:begin + Write('String literal must be closed'); + end; + 101:begin + Write('String is empty'); + end; + 102:begin + Write('Bad char'); + end; + 103:begin + Write('Too many identifiers'); + end; + 104:begin + Write('Duplicate identifier'); + end; + 105:begin + Write('Duplicate procedure/function'); + end; + 106:begin + Write('Unknown identifiers'); + end; + 107:begin + Write('Invalid type'); + end; + 108:begin + Write('Record type expected'); + end; + 109:begin + Write('Unknown field'); + end; + 110:begin + Write('Array type expected'); + end; + 111:begin + Write('Non-writeable type'); + end; + 112:begin + Write('Non-readable type'); + end; + 113:begin + Write('Too many argumnts'); + end; + 114:begin + Write('Passing string to var argument isn''t allowed'); + end; + 115:begin + Write('Passing string to non-array argument isn''t allowed'); + end; + 116:begin + Write('Passing string to non-char-array argument isn''t allowed'); + end; + 117:begin + Write('Passing string to wrong sized char-array argument isn''t allowed'); + end; + 118:begin + Write('Too few argumnts'); + end; + 119:begin + Write('Procedure calls inside a expression aren''t allowed'); + end; + 120:begin + Write('Type inside a expression isn''t allowed'); + end; + 121:begin + Write('Expression expected'); + end; + 122:begin + Write('Illegal assigning to function'); + end; + 123:begin + Write('Illegal assigning to constant or type'); + end; + 124:begin + Write('Case expression must be constant'); + end; + 125:begin + Write('Case expression expected'); + end; + 126:begin + Write('":" expected'); + end; + 127:begin + Write('Variable after "FOR" expected'); + end; + 128:begin + Write('Incorrect iterator type'); + end; + 129:begin + Write('"TO" or "DOWNTO" expected'); + end; + 130:begin + Write('Constant expected'); + end; + 131:begin + Write('Identifier or number literal expected'); + end; + 132:begin + Write('First index of array must be less or equal then last'); + end; + 133:begin + Write('Type expected'); + end; + 134:begin + Write('Too many types'); + end; + 135:begin + Write('Too many nested records'); + end; + 136:begin + Write('Too many nested procedures'); + end; + 137:begin + Write('Invalid function return type'); + end; + 138:begin + Write('Too many arguments then at forward declaration'); + end; + 139:begin + Write('Argument name doesn''t match forward declaration'); + end; + 140:begin + Write('Argument type doesn''t match forward declaration'); + end; + 141:begin + Write('Argument var doesn''t match forward declaration'); + end; + 142:begin + Write('Too less arguments then at forward declaration'); + end; + 143:begin + Write('Already forward declared'); + end; + 144:begin + Write('No definition for forward declared'); + end; + 145:begin + Write('Internal negative retn'); + end; + 146:begin + Write('Binary is too big'); + end; + 147:begin + Write('String is too long'); + end; + 148:begin + Write('Too many cases'); + end; + 149:begin + Write('Too large code'); + end; + 150:begin + Write('Incompatible types'); + end; + end; + WriteLn(' at line ',CurrentLine:1,' at column ',CurrentColumn:1); + Halt; +end; + +procedure ReadChar; +begin + if not EOF then begin + read(CurrentChar); + CurrentColumn:=CurrentColumn+1; + if CurrentChar=#10 then begin + CurrentLine:=CurrentLine+1; + CurrentColumn:=0; + end; + end else begin + CurrentChar:=#0; + end; +end; + +function ReadNumber:integer; +var Num:integer; +begin + Num:=0; + if ('0'<=CurrentChar) and (CurrentChar<='9') then begin + while ('0'<=CurrentChar) and (CurrentChar<='9') do begin + Num:=(Num*10)+(ord(CurrentChar)-ord('0')); + ReadChar; + end; + end else if CurrentChar='$' then begin + ReadChar; + while (('0'<=CurrentChar) and (CurrentChar<='9')) or + (('a'<=CurrentChar) and (CurrentChar<='f')) or + (('A'<=CurrentChar) and (CurrentChar<='F')) do begin + if ('0'<=CurrentChar) and (CurrentChar<='9') then begin + Num:=(Num*16)+(ord(CurrentChar)-ord('0')); + end else if ('a'<=CurrentChar) and (CurrentChar<='f') then begin + Num:=(Num*16)+(ord(CurrentChar)-ord('a')+10); + end else if ('A'<=CurrentChar) and (CurrentChar<='F') then begin + Num:=(Num*16)+(ord(CurrentChar)-ord('A')+10); + end; + ReadChar; + end; + end; + ReadNumber:=Num; +end; + +procedure GetSymbol; +var k,s:integer; + StrEnd,InStr:boolean; + LastChar:char; +begin + while (CurrentChar>#0) and (CurrentChar<=' ') do begin + ReadChar; + end; + if (('a'<=CurrentChar) and (CurrentChar<='z')) or (('A'<=CurrentChar) and (CurrentChar<='Z')) then begin + k:=0; + while ((('a'<=CurrentChar) and (CurrentChar<='z')) or (('A'<=CurrentChar) and (CurrentChar<='Z')) or (('0'<=CurrentChar) and (CurrentChar<='9'))) or (CurrentChar='_') do begin + if k<>MaximalAlfa then begin + k:=k+1; + if ('a'<=CurrentChar) and (CurrentChar<='z') then begin + CurrentChar:=chr(ord(CurrentChar)-32); + end; + CurrentIdentifer[k]:=CurrentChar; + end; + ReadChar; + end; + while k<>MaximalAlfa do begin + k:=k+1; + CurrentIdentifer[k]:=' '; + end; + CurrentSymbol:=TokIdent; + s:=SymBEGIN; + while s<=SymPROC do begin + if StringCompare(Keywords[s],CurrentIdentifer) then begin + CurrentSymbol:=s; + end; + s:=s+1; + end; + end else if (('0'<=CurrentChar) and (CurrentChar<='9')) or (CurrentChar='$') then begin + CurrentSymbol:=TokNumber; + CurrentNumber:=ReadNumber; + end else if CurrentChar=':' then begin + ReadChar; + if CurrentChar='=' then begin + ReadChar; + CurrentSymbol:=TokAssign; + end else begin + CurrentSymbol:=TokColon; + end; + end else if CurrentChar='>' then begin + ReadChar; + if CurrentChar='=' then begin + ReadChar; + CurrentSymbol:=TokGEq; + end else begin + CurrentSymbol:=TokGtr; + end; + end else if CurrentChar='<' then begin + ReadChar; + if CurrentChar='=' then begin + ReadChar; + CurrentSymbol:=TokLEq; + end else if CurrentChar='>' then begin + ReadChar; + CurrentSymbol:=TokNEq; + end else begin + CurrentSymbol:=TokLss; + end; + end else if CurrentChar='.' then begin + ReadChar; + if CurrentChar='.' then begin + ReadChar; + CurrentSymbol:=TokColon; + end else begin + CurrentSymbol:=TokPeriod + end; + end else if (CurrentChar='''') or (CurrentChar='#') then begin + CurrentStringLength:=0; + StrEnd:=false; + InStr:=false; + CurrentSymbol:=TokStrC; + while not StrEnd do begin + if InStr then begin + if CurrentChar='''' then begin + ReadChar; + if CurrentChar='''' then begin + if CurrentStringLength=MaximalStringLength then begin + Error(147); + end; + CurrentStringLength:=CurrentStringLength+1; + CurrentString[CurrentStringLength]:=CurrentChar; + ReadChar; + end else begin + InStr:=false; + end; + end else if (CurrentChar=#13) or (CurrentChar=#10) then begin + Error(100); + StrEnd:=true; + end else begin + if CurrentStringLength=MaximalStringLength then begin + Error(147); + end; + CurrentStringLength:=CurrentStringLength+1; + CurrentString[CurrentStringLength]:=CurrentChar; + ReadChar; + end; + end else begin + if CurrentChar='''' then begin + InStr:=true; + ReadChar; + end else if CurrentChar='#' then begin + ReadChar; + if CurrentStringLength=MaximalStringLength then begin + Error(147); + end; + CurrentStringLength:=CurrentStringLength+1; + CurrentString[CurrentStringLength]:=chr(ReadNumber); + end else begin + StrEnd:=true; + end; + end; + end; + if CurrentStringLength=0 then begin + Error(101); + end; + end else if CurrentChar='+' then begin + ReadChar; + CurrentSymbol:=TokPlus; + end else if CurrentChar='-' then begin + ReadChar; + CurrentSymbol:=TokMinus; + end else if CurrentChar='*' then begin + ReadChar; + CurrentSymbol:=TokMul; + end else if CurrentChar='(' then begin + ReadChar; + if CurrentChar='*' then begin + ReadChar; + LastChar:='-'; + while not ((CurrentChar=')') and (LastChar='*')) do begin + LastChar:=CurrentChar; + ReadChar; + end; + ReadChar; + GetSymbol; + end else begin + CurrentSymbol:=TokLParent; + end; + end else if CurrentChar=')' then begin + ReadChar; + CurrentSymbol:=TokRParent; + end else if CurrentChar='[' then begin + ReadChar; + CurrentSymbol:=TokLBracket; + end else if CurrentChar=']' then begin + ReadChar; + CurrentSymbol:=TokRBracket; + end else if CurrentChar='=' then begin + ReadChar; + CurrentSymbol:=TokEql; + end else if CurrentChar=',' then begin + ReadChar; + CurrentSymbol:=TokComma; + end else if CurrentChar=';' then begin + ReadChar; + CurrentSymbol:=TokSemi; + end else if CurrentChar='{' then begin + while CurrentChar<>'}' do begin + ReadChar; + end; + ReadChar; + GetSymbol; + end else begin + Error(102); + end; +end; + +procedure Check(s:integer); +begin + if CurrentSymbol<>s then begin + Error(s); + end; +end; + +procedure Expect(s:integer); +begin + Check(s); + GetSymbol; +end; + +procedure EnterSymbol(CurrentIdentifer:TAlfa;k,t:integer); +var j:integer; +begin + if IdentifierPosition=MaximalIdentifiers then begin + Error(103); + end; + IdentifierPosition:=IdentifierPosition+1; + Identifiers[0].Name:=CurrentIdentifer; + j:=SymbolNameList[CurrentLevel]; + while not StringCompare(Identifiers[j].Name,CurrentIdentifer) do begin + j:=Identifiers[j].Link; + end; + if j<>0 then begin + if Identifiers[j].Kind<>IdFUNC then begin + Error(104); + end; + if (Code[Identifiers[j].FunctionAddress]<>OPJmp) or (Code[Identifiers[j].FunctionAddress+1]>0) then begin + Error(105); + end; + Identifiers[j].Name[1]:='$'; + Code[Identifiers[j].FunctionAddress+1]:=CodePosition; + FunctionDeclarationIndex:=j; + end; + Identifiers[IdentifierPosition].Name:=CurrentIdentifer; + Identifiers[IdentifierPosition].Link:=SymbolNameList[CurrentLevel]; + Identifiers[IdentifierPosition].TypeDefinition:=t; + Identifiers[IdentifierPosition].Kind:=k; + SymbolNameList[CurrentLevel]:=IdentifierPosition; +end; + +function Position:integer; +var i,j:integer; +begin + Identifiers[0].Name:=CurrentIdentifer; + i:=CurrentLevel; + repeat + j:=SymbolNameList[i]; + while not StringCompare(Identifiers[j].Name,CurrentIdentifer) do begin + j:=Identifiers[j].Link; + end; + i:=i-1; + until (i<-1) or (j<>0); + if j=0 then begin + Error(106); + end; + Position:=j; +end; + +procedure EmitCode(Value:integer); +begin + if CodePosition>MaximalCodeSize then begin + Error(149); + end; + Code[CodePosition]:=Value; + CodePosition:=CodePosition+1; +end; + +procedure EmitOpcode(Opcode,a:integer); +begin + case Opcode of + OPDupl,OPEOF,OPEOL,OPLdC,OPLdA,OPLdLA,OPLdL,OPLdG:begin + StackPosition:=StackPosition-4; + end; + OPNeg,OPDiv2,OPRem2,OPSwap,OPLoad,OPHalt,OPWrL,OPRdL,OpAddC,OPMulC, + OPJmp,OPCall,OPExit:begin + end; + OPAdd,OPMul,OPDivD,OPRemD,OPEqlI,OPNEqI,OPLssI,OPLeqI,OPGtrI,OPGEqI,OPAndB, + OPOrB,OPWrC,OPRdI,OPRdC,OPStL,OPStG,OPJZ:begin + StackPosition:=StackPosition+4; + end; + OPStore,OPWrI,OPMove:begin + StackPosition:=StackPosition+8; + end; + OPCopy:begin + StackPosition:=StackPosition-(a-4); + end; + OPAdjS:begin + StackPosition:=StackPosition+a; + end; + end; + if not ((((Opcode=OPAddC) or (Opcode=OPAdjS)) and (a=0)) or ((Opcode=OPMulC) and (a=1))) then begin + if IsLabeled then begin + Code[CodePosition]:=Opcode; + CodePosition:=CodePosition+1; + if Opcode>=OPLdC then begin + Code[CodePosition]:=a; + CodePosition:=CodePosition+1; + end; + IsLabeled:=false; + end else if (LastOpcode=OPLdC) and (Opcode=OPAdd) then begin + Code[CodePosition-2]:=OPAddC; + end else if (LastOpcode=OPLdC) and (Opcode=OPMul) then begin + Code[CodePosition-2]:=OPMulC; + end else if (LastOpcode=OPLdC) and (Opcode=OPNeg) then begin + Code[CodePosition-1]:=-Code[CodePosition-1]; + Opcode:=LastOpcode; + end else if (LastOpcode=OPLdC) and (Code[CodePosition-1]=2) and (Opcode=OPDivD) then begin + Code[CodePosition-2]:=OPDiv2; + CodePosition:=CodePosition-1; + end else if (LastOpcode=OPLdC) and (Code[CodePosition-1]=2) and (Opcode=OPRemD) then begin + Code[CodePosition-2]:=OPRem2; + CodePosition:=CodePosition-1; + end else if (LastOpcode=OPLdA) and (Opcode=OPStore) then begin + Code[CodePosition-2]:=OPStG; + end else if (LastOpcode=OPLdA) and (Opcode=OPLoad) then begin + Code[CodePosition-2]:=OPLdG; + end else if (LastOpcode=OPLdLA) and (Opcode=OPStore) then begin + Code[CodePosition-2]:=OPStL; + end else if (LastOpcode=OPLdLA) and (Opcode=OPLoad) then begin + Code[CodePosition-2]:=OPLdL; + end else begin + EmitCode(Opcode); + if Opcode>=OPLdC then begin + EmitCode(a); + end; + end; + LastOpcode:=Opcode; + end; +end; + +procedure EmitOpcode2(Opcode:integer); +begin + EmitOpcode(Opcode,0); +end; + +function CodeLabel:integer; +begin + CodeLabel:=CodePosition; + IsLabeled:=true; +end; + +procedure EmitAddress(Level,Address:integer); +begin + if Level=0 then begin + EmitOpcode(OPLdA,Address); + end else if Level=CurrentLevel then begin + EmitOpcode(OPLdLA,Address-StackPosition); + end else begin + EmitOpcode(OPLdL,-StackPosition); + while Level+1<>CurrentLevel do begin + EmitOpcode2(OPLoad); + Level:=Level+1; + end; + EmitOpcode(OPAddC,Address); + end; +end; + +procedure EmitAddressVar(IdentifierIndex:integer); +begin + EmitAddress(Identifiers[IdentifierIndex].VariableLevel,Identifiers[IdentifierIndex].VariableAddress); + if Identifiers[IdentifierIndex].ReferencedParameter then begin + EmitOpcode2(OPLoad); + end; +end; + +procedure MustBe(x,y:integer); +begin + if x<>y then begin + if (Types[x].Kind=KindARRAY) and (Types[y].Kind=KindARRAY) and (Types[x].StartIndex=Types[y].StartIndex) and (Types[x].EndIndex=Types[y].EndIndex) then begin + MustBe(Types[x].SubType,Types[y].SubType); + end else begin + Error(107); + end; + end; +end; + +procedure Expression(var x:integer); forward; + +procedure Selector(var t,IdentifierIndex:integer); +var j,x:integer; +begin + t:=Identifiers[IdentifierIndex].TypeDefinition; + GetSymbol; + if (CurrentSymbol=TokPeriod) or (CurrentSymbol=TokLBracket) then begin + EmitAddressVar(IdentifierIndex); + IdentifierIndex:=0; + while (CurrentSymbol=TokPeriod) or (CurrentSymbol=TokLBracket) do begin + case CurrentSymbol of + TokPeriod:begin + if Types[t].Kind<>KindRECORD then begin + Error(108); + end; + GetSymbol; + Check(TokIdent); + j:=Types[t].Fields; + Identifiers[0].Name:=CurrentIdentifer; + while not StringCompare(Identifiers[j].Name,CurrentIdentifer) do begin + j:=Identifiers[j].Link; + end; + if j=0 then begin + Error(109); + end; + EmitOpcode(OPAddC,Identifiers[j].Offset); + t:=Identifiers[j].TypeDefinition; + GetSymbol; + end; + TokLBracket:begin + repeat + if Types[t].Kind<>KindARRAY then begin + Error(110); + end; + GetSymbol; + Expression(x); + MustBe(TypeINT,x); + EmitOpcode(OPAddC,-Types[t].StartIndex); + t:=Types[t].SubType; + EmitOpcode(OPMulC,Types[t].Size); + EmitOpcode2(OPAdd); + until CurrentSymbol<>TokComma; + Expect(TokRBracket) + end; + end; + end; + end; +end; + +procedure VarPar(var t:integer); +var j:integer; +begin + Check(TokIdent); + j:=Position; + Selector(t,j); + if j<>0 then begin + EmitAddressVar(j); + end; +end; + +procedure InternalFunction(n:integer); +var x:integer; +begin + case n of + FunCHR:begin + Expect(TokLParent); + Expression(x); + MustBe(TypeINT,x); + Expect(TokRParent) + end; + FunORD:begin + Expect(TokLParent); + Expression(x); + if x<>TypeBOOL then begin + MustBe(TypeCHAR,x); + end; + Expect(TokRParent); + end; + FunWRITE,FunWRITELN:begin + if n=FunWRITE then begin + Check(TokLParent); + end; + if CurrentSymbol=TokLParent then begin + repeat + GetSymbol; + if CurrentSymbol=TokStrC then begin + x:=1; + while x<=CurrentStringLength do begin + EmitOpcode(OPLdC,ord(CurrentString[x])); + EmitOpcode2(OPWrC); + x:=x+1; + end; + GetSymbol; + end else begin + Expression(x); + if CurrentSymbol=TokColon then begin + MustBe(TypeINT,x); + GetSymbol; + Expression(x); + MustBe(TypeINT,x); + EmitOpcode2(OPWrI); + end else if x=TypeINT then begin + EmitOpcode(OPLdC,1); + EmitOpcode2(OPWrI); + end else if x=TypeCHAR then begin + EmitOpcode2(OPWrC); + end else begin + Error(111); + end; + end; + until CurrentSymbol<>TokComma; + Expect(TokRParent) + end; + if n=FunWRITELN then begin + EmitOpcode2(OPWrL); + end; + end; + FunREAD,FunREADLN:begin + if n=FunREAD then begin + Check(TokLParent); + end; + if CurrentSymbol=TokLParent then begin + repeat + GetSymbol; + VarPar(x); + if x=TypeINT then begin + EmitOpcode2(OPRdI); + end else if x=TypeCHAR then begin + EmitOpcode2(OPRdC); + end else begin + Error(112); + end; + until CurrentSymbol<>TokComma; + Expect(TokRParent); + end; + if n=FunREADLN then begin + EmitOpcode2(OPRdL); + end; + end; + FunEOF:begin + EmitOpcode2(OPEOF); + end; + FunEOFLN:begin + EmitOpcode2(OPEOL); + end; + end; +end; + +procedure FunctionCall(i:integer); +var OldStackPosition,p,x:integer; +begin + GetSymbol; + if Identifiers[i].FunctionLevel<0 then begin + InternalFunction(Identifiers[i].FunctionAddress); + end else begin + if Identifiers[i].TypeDefinition<>0 then begin + EmitOpcode(OPLdC,0); + end; + p:=i; + OldStackPosition:=StackPosition; + if CurrentSymbol=TokLParent then begin + repeat + GetSymbol; + if p=Identifiers[i].LastParameter then begin + Error(113); + end; + p:=p+1; + if Identifiers[p].ReferencedParameter then begin + VarPar(x); + end else begin + Expression(x); + if Types[x].Kind<>KindSIMPLE then begin + EmitOpcode(OPCopy,Types[x].Size); + end; + end; + if x=TypeSTR then begin + if Identifiers[p].ReferencedParameter then begin + Error(114); + end; + if Types[Identifiers[p].TypeDefinition].Kind<>KindARRAY then begin + Error(115); + end; + if Types[Identifiers[p].TypeDefinition].SubType<>TypeCHAR then begin + Error(116); + end; + if ((Types[Identifiers[p].TypeDefinition].EndIndex-Types[Identifiers[p].TypeDefinition].StartIndex)+1)<>CurrentStringLength then begin + Error(117); + end; + end else begin + MustBe(Identifiers[p].TypeDefinition,x); + end; + until CurrentSymbol<>TokComma; + Expect(TokRParent); + end; + if p<>Identifiers[i].LastParameter then begin + Error(118); + end; + if Identifiers[i].FunctionLevel<>0 then begin + EmitAddress(Identifiers[i].FunctionLevel,0); + end; + EmitOpcode(OPCall,Identifiers[i].FunctionAddress); + StackPosition:=OldStackPosition; + end; +end; + +procedure Factor(var t:integer); +var i:integer; +begin + if CurrentSymbol=TokIdent then begin + i:=Position; + t:=Identifiers[i].TypeDefinition; + case Identifiers[i].Kind of + IdCONST:begin + GetSymbol; + EmitOpcode(OPLdC,Identifiers[i].Value); + end; + IdVAR:begin + Selector(t,i); + if i<>0 then begin + EmitAddressVar(i); + end; + if Types[t].Kind=KindSIMPLE then begin + EmitOpcode2(OPLoad); + end; + end; + IdFUNC:begin + if t=0 then begin + Error(119); + end else begin + FunctionCall(i); + end; + end; + IdTYPE:begin + Error(120); + end; + end; + end else if CurrentSymbol=TokNumber then begin + EmitOpcode(OPLdC,CurrentNumber); + t:=TypeINT; + GetSymbol; + end else if CurrentSymbol=TokStrC then begin + i:=CurrentStringLength; + while i>=1 do begin + EmitOpcode(OPLdC,ord(CurrentString[i])); + i:=i-1; + end; + t:=TypeCHAR; + if CurrentStringLength<>1 then begin + t:=TypeSTR; + end; + GetSymbol; + end else if CurrentSymbol=TokLParent then begin + GetSymbol; + Expression(t); + Expect(TokRParent); + end else if CurrentSymbol=SymNOT then begin + GetSymbol; + Factor(t); + MustBe(TypeBOOL,t); + EmitOpcode2(OPNeg); + EmitOpcode(OPAddC,1); + end else begin + Error(121); + end; +end; + +procedure Term(var x:integer); +var y:integer; +begin + Factor(x); + while (CurrentSymbol=SymAND) or (CurrentSymbol=TokMul) or (CurrentSymbol=SymDIV) or (CurrentSymbol=SymMOD) do begin + if CurrentSymbol=SymAND then begin + MustBe(TypeBOOL,x); + end else begin + MustBe(TypeINT,x); + end; + case CurrentSymbol of + TokMul:begin + GetSymbol; + Factor(y); + EmitOpcode2(OPMul); + end; + SymDIV:begin + GetSymbol; + Factor(y); + EmitOpcode2(OPDivD); + end; + SymMOD:begin + GetSymbol; + Factor(y); + EmitOpcode2(OPRemD); + end; + SymAND:begin + GetSymbol; + Factor(y); + EmitOpcode2(OPAndB); + end; + end; + MustBe(x,y); + end; +end; + +procedure SimpleExpression(var x:integer); +var y:integer; +begin + if CurrentSymbol=TokPlus then begin + GetSymbol; + Term(x); + MustBe(TypeINT,x); + end else if CurrentSymbol=TokMinus then begin + GetSymbol; + Term(x); + MustBe(TypeINT,x); + EmitOpcode2(OPNeg); + end else begin + Term(x); + end; + while (CurrentSymbol=SymOR) or (CurrentSymbol=TokPlus) or (CurrentSymbol=TokMinus) do begin + if CurrentSymbol=SymOR then begin + MustBe(TypeBOOL,x); + end else begin + MustBe(TypeINT,x); + end; + case CurrentSymbol of + TokPlus:begin + GetSymbol; + Term(y); + EmitOpcode2(OPAdd); + end; + TokMinus:begin + GetSymbol; + Term(y); + EmitOpcode2(OPNeg); + EmitOpcode2(OPAdd); + end; + SymOR:begin + GetSymbol; + Term(y); + EmitOpcode2(OPOrB); + end; + end; + MustBe(x,y); + end; +end; + +procedure Expression(var x:integer); +var o,y:integer; +begin + SimpleExpression(x); + if (CurrentSymbol=TokEql) or (CurrentSymbol=TokNEq) or (CurrentSymbol=TokLss) or (CurrentSymbol=TokLEq) or (CurrentSymbol=TokGtr) or (CurrentSymbol=TokGEq) then begin + if (x=TypeSTR) or (Types[x].Kind<>KindSIMPLE) then begin + Error(150); + end; + o:=CurrentSymbol; + GetSymbol; + SimpleExpression(y); + MustBe(x,y); + case o of + TokEql:begin + EmitOpcode2(OPEqlI); + end; + TokNEq:begin + EmitOpcode2(OPNEqI); + end; + TokLss:begin + EmitOpcode2(OPLssI); + end; + TokLEq:begin + EmitOpcode2(OPLeqI); + end; + TokGtr:begin + EmitOpcode2(OPGtrI); + end; + TokGEq:begin + EmitOpcode2(OPGEqI); + end; + end; + x:=TypeBOOL; + end; +end; + +procedure Statement; +var L:array[1..MaximalCases] of integer; + m,n,i,j,t,x,r,OldStackPosition:integer; +begin + if CurrentSymbol=TokIdent then begin + i:=Position; + case Identifiers[i].Kind of + IdVAR:begin + Selector(t,i); + Expect(TokAssign); + Expression(x); + MustBe(t,x); + if i=0 then begin + EmitOpcode2(OPSwap); + end else begin + EmitAddressVar(i); + end; + if Types[t].Kind=KindSIMPLE then begin + EmitOpcode2(OPStore); + end else begin + EmitOpcode(OPMove,Types[t].Size); + end; + end; + IdFUNC:begin + if Identifiers[i].TypeDefinition=0 then begin + FunctionCall(i); + end else begin + if not Identifiers[i].Inside then begin + Error(122); + end; + GetSymbol; + Expect(TokAssign); + Expression(x); + MustBe(Identifiers[i].TypeDefinition,x); + EmitAddress(Identifiers[i].FunctionLevel+1,Identifiers[i].ReturnAddress); + EmitOpcode2(OPStore); + end; + end; + IdCONST,IdFIELD,IdTYPE:Error(123); + end; + end else if CurrentSymbol=SymIF then begin + GetSymbol; + Expression(t); + MustBe(TypeBOOL,t); + Expect(SymTHEN); + i:=CodeLabel; + EmitOpcode(OPJZ,0); + Statement; + if CurrentSymbol=SymELSE then begin + GetSymbol; + j:=CodeLabel; + EmitOpcode(OPJmp,0); + Code[i+1]:=CodeLabel; + i:=j; + Statement; + end; + Code[i+1]:=CodeLabel; + end else if CurrentSymbol=SymCASE then begin + GetSymbol; + Expression(t); + MustBe(TypeINT,t); + Expect(SymOF); + j:=0; + m:=0; + repeat + if j<>0 then begin + Code[j+1]:=CodeLabel; + end; + n:=m; + repeat + if n<>m then begin + GetSymbol; + end; + EmitOpcode2(OPDupl); + if CurrentSymbol=TokIdent then begin + i:=Position; + if Identifiers[i].Kind<>IdCONST then begin + Error(124); + end; + EmitOpcode(OPLdC,Identifiers[i].Value); + end else if CurrentSymbol=TokNumber then begin + EmitOpcode(OPLdC,CurrentNumber); + end else if (CurrentSymbol=TokStrC) and (CurrentStringLength=1) then begin + EmitOpcode(OPLdC,ord(CurrentString[1])); + end else begin + Error(125); + end; + EmitOpcode2(OPNEqI); + if n=MaximalCases then begin + Error(148); + end; + n:=n+1; + L[n]:=CodeLabel; + EmitOpcode(OPJZ,0); + GetSymbol; + until CurrentSymbol<>TokComma; + if CurrentSymbol<>TokColon then begin + Error(126); + end; + j:=CodeLabel; + EmitOpcode(OPJmp,0); + repeat + Code[L[n]+1]:=CodeLabel; + n:=n-1; + until n=m; + GetSymbol; + Statement; + m:=m+1; + L[m]:=CodeLabel; + EmitOpcode(OPJmp,0); + if CurrentSymbol=TokSemi then begin + GetSymbol; + end; + until CurrentSymbol=SymEND; + Code[j+1]:=CodeLabel; + repeat + Code[L[m]+1]:=CodeLabel; + m:=m-1; + until m=0; + EmitOpcode(OPAdjS,4); + GetSymbol; + end else if CurrentSymbol=SymFOR then begin + GetSymbol; + if CurrentSymbol=TokIdent then begin + OldStackPosition:=StackPosition; + + i:=Position; + if Identifiers[i].Kind<>IdVAR then begin + Error(127); + end; + Selector(t,i); + Expect(TokAssign); + Expression(x); + MustBe(t,x); + if i=0 then begin + EmitOpcode2(OPSwap); + end else begin + EmitAddressVar(i); + end; + if Types[t].Kind<>KindSIMPLE then begin + Error(128); + end; + EmitOpcode2(OPStore); + + r:=1; + if CurrentSymbol=SymTO then begin + Expect(SymTO); + end else if CurrentSymbol=SymDOWNTO then begin + Expect(SymDOWNTO); + r:=-1; + end else begin + Error(129); + end; + + j:=CodeLabel; + if i=0 then begin + EmitOpcode2(OPSwap); + end else begin + EmitAddressVar(i); + end; + EmitOpcode2(OPLoad); + Expression(x); + MustBe(t,x); + if r>0 then begin + EmitOpcode2(OPLeqI); + end else begin + EmitOpcode2(OPGeqI); + end; + n:=CodeLabel; + EmitOpcode(OPJZ,0); + + Expect(SymDO); + + Statement; + + if i=0 then begin + EmitOpcode2(OPSwap); + end else begin + EmitAddressVar(i); + end; + EmitOpcode2(OPLoad); + + EmitOpcode(OPAddC,r); + + if i=0 then begin + EmitOpcode2(OPSwap); + end else begin + EmitAddressVar(i); + end; + EmitOpcode2(OPStore); + + EmitOpcode(OPJmp,j); + Code[n+1]:=CodeLabel; + + EmitOpcode(OPAdjS,OldStackPosition-StackPosition); + + end else begin + Expect(TokIdent); + end; + end else if CurrentSymbol=SymWHILE then begin + GetSymbol; + i:=CodeLabel; + Expression(t); + MustBe(TypeBOOL,t); + Expect(SymDO); + j:=CodeLabel; + EmitOpcode(OPJZ,0); + Statement; + EmitOpcode(OPJmp,i); + Code[j+1]:=CodeLabel; + end else if CurrentSymbol=SymREPEAT then begin + i:=CodeLabel; + repeat + GetSymbol; + Statement; + until CurrentSymbol<>TokSemi; + Expect(SymUNTIL); + Expression(t); + MustBe(TypeBOOL,t); + EmitOpcode(OPJZ,i); + end else if CurrentSymbol=SymBEGIN then begin + repeat + GetSymbol; + Statement; + until CurrentSymbol<>TokSemi; + Expect(SymEND); + end else if CurrentSymbol=SymHALT then begin + EmitOpcode2(OPHalt); + GetSymbol; + end; +end; + +procedure Block(L:integer); forward; + +procedure Constant(var c,t:integer); +var i,s:integer; +begin + if (CurrentSymbol=TokStrC) and (CurrentStringLength=1) then begin + c:=ord(CurrentString[1]); + t:=TypeCHAR; + end else begin + if CurrentSymbol=TokPlus then begin + GetSymbol; + s:=1; + end else if CurrentSymbol=TokMinus then begin + GetSymbol; + s:=-1; + end else begin + s:=0; + end; + if CurrentSymbol=TokIdent then begin + i:=Position; + if Identifiers[i].Kind<>IdCONST then begin + Error(130); + end; + c:=Identifiers[i].Value; + t:=Identifiers[i].TypeDefinition; + end else if CurrentSymbol=TokNumber then begin + c:=CurrentNumber; + t:=TypeINT; + end else begin + Error(131); + end; + if s<>0 then begin + MustBe(t,TypeINT); + c:=c*s; + end; + end; + GetSymbol; +end; + +procedure ConstDeclaration; +var a:TAlfa; + t,c:integer; +begin + a:=CurrentIdentifer; + GetSymbol; + Expect(TokEql); + Constant(c,t); + Expect(TokSemi); + EnterSymbol(A,IdCONST,t); + Identifiers[IdentifierPosition].Value:=c; +end; + +procedure TypeDefinition(var t:integer); forward; + +procedure ArrayType(var t:integer); +var x:integer; +begin + Types[t].Kind:=KindARRAY; + GetSymbol; + Constant(Types[t].StartIndex,x); + MustBe(TypeINT,x); + Expect(TokColon); + Constant(Types[t].EndIndex,x); + MustBe(TypeINT,x); + if Types[t].StartIndex>Types[t].EndIndex then begin + Error(132); + end; + if CurrentSymbol=TokComma then begin + ArrayType(Types[t].SubType); + end else begin + Expect(TokRBracket); + Expect(SymOF); + TypeDefinition(Types[t].SubType); + end; + Types[t].Size:=(Types[t].EndIndex-Types[t].StartIndex+1)*Types[Types[t].SubType].Size; +end; + +procedure TypeDefinition(var t:integer); +var i,j,Size,FieldType:integer; +begin + if CurrentSymbol=SymPACKED then begin + GetSymbol; + end; + if CurrentSymbol=TokIdent then begin + i:=Position; + if Identifiers[i].Kind<>IdTYPE then begin + Error(133); + end; + t:=Identifiers[i].TypeDefinition; + GetSymbol; + end else begin + if TypePosition=MaximalTypes then begin + Error(134); + end; + TypePosition:=TypePosition+1; + t:=TypePosition; + if CurrentSymbol=SymARRAY then begin + GetSymbol; + Check(TokLBracket); + ArrayType(t); + end else begin + Expect(SymRECORD); + if CurrentLevel=MaximalList then begin + Error(135); + end; + CurrentLevel:=CurrentLevel+1; + SymbolNameList[CurrentLevel]:=0; + Check(TokIdent); + Size:=0; + repeat + EnterSymbol(CurrentIdentifer,IdFIELD,0); + i:=IdentifierPosition; + GetSymbol; + while CurrentSymbol=TokComma do begin + GetSymbol; + Check(TokIdent); + EnterSymbol(CurrentIdentifer,IdFIELD,0); + GetSymbol; + end; + j:=IdentifierPosition; + Expect(TokColon); + TypeDefinition(FieldType); + repeat + Identifiers[i].TypeDefinition:=FieldType; + Identifiers[i].Offset:=Size; + Size:=Size+Types[FieldType].Size; + i:=i+1; + until i>j; + if CurrentSymbol=TokSemi then begin + GetSymbol; + end else begin + Check(SymEND); + end; + until CurrentSymbol<>TokIdent; + Types[t].Size:=Size; + Types[t].Kind:=KindRECORD; + Types[t].Fields:=SymbolNameList[CurrentLevel]; + CurrentLevel:=CurrentLevel-1; + Expect(SymEND); + end; + end; +end; + +procedure TypeDeclaration; +var a:TAlfa; + t:integer; +begin + a:=CurrentIdentifer; + GetSymbol; + Expect(TokEql); + TypeDefinition(t); + Expect(TokSemi); + EnterSymbol(a,IdTYPE,t); +end; + +procedure VarDeclaration; +var p,q,t:integer; +begin + EnterSymbol(CurrentIdentifer,IdVAR,0); + p:=IdentifierPosition; + GetSymbol; + while CurrentSymbol=TokComma do begin + GetSymbol; + Check(TokIdent); + EnterSymbol(CurrentIdentifer,IdVAR,0); + GetSymbol; + end; + q:=IdentifierPosition; + Expect(TokColon); + TypeDefinition(t); + Expect(TokSemi); + repeat + Identifiers[p].VariableLevel:=CurrentLevel; + StackPosition:=StackPosition-Types[t].Size; + Identifiers[p].TypeDefinition:=t; + Identifiers[p].VariableAddress:=StackPosition; + Identifiers[p].ReferencedParameter:=false; + p:=p+1; + until p>q; +end; + +procedure NewParameter(var p,LocalStackPosition:integer); +var r:boolean; + t:integer; +begin + if CurrentSymbol=SymVAR then begin + r:=true; + GetSymbol; + end else begin + r:=false; + end; + Check(TokIdent); + p:=IdentifierPosition; + EnterSymbol(CurrentIdentifer,IdVAR,0); + GetSymbol; + while CurrentSymbol=TokComma do begin + GetSymbol; + Check(TokIdent); + EnterSymbol(CurrentIdentifer,IdVAR,0); + GetSymbol; + end; + Expect(TokColon); + Check(TokIdent); + TypeDefinition(t); + while pTokSemi; + Expect(TokRParent); + end; + if CurrentLevel>1 then begin + StackPosition:=-4; + end else begin + StackPosition:=0; + end; + Identifiers[f].ReturnAddress:=LocalStackPosition; + p:=f; + while pKindSIMPLE then begin + Error(137); + end; + end; + Expect(TokSemi); + Identifiers[f].LastParameter:=IdentifierPosition; + if CurrentSymbol<>SymFORWARD then begin + if FunctionDeclarationIndex>=0 then begin + P1:=FunctionDeclarationIndex+1; + P2:=f+1; + while P1<=Identifiers[FunctionDeclarationIndex].LastParameter do begin + if P2>Identifiers[f].LastParameter then begin + Error(138); + end; + if not StringCompare(Identifiers[P1].Name,Identifiers[P2].Name) then begin + Error(139); + end; + if Identifiers[P1].TypeDefinition<>Identifiers[P2].TypeDefinition then begin + Error(140); + end; + if Identifiers[P1].ReferencedParameter<>Identifiers[P2].ReferencedParameter then begin + Error(141); + end; + P1:=P1+1; + P2:=P2+1; + end; + if P2<=Identifiers[f].LastParameter then begin + Error(142); + end; + end; + Identifiers[f].Inside:=true; + Block(Identifiers[f].FunctionAddress); + Identifiers[f].Inside:=false; + EmitOpcode(OPExit,Identifiers[f].ReturnAddress-StackPosition); + end else begin + if FunctionDeclarationIndex>=0 then begin + Error(143); + end; + GetSymbol; + end; + CurrentLevel:=CurrentLevel-1; + StackPosition:=OldStackPosition; + Expect(TokSemi); +end; + +procedure Block(L:integer); +var i,d,OldStackPosition,OldIdentPos:integer; +begin + OldStackPosition:=StackPosition; + OldIdentPos:=IdentifierPosition; + while (CurrentSymbol=SymCONST) or (CurrentSymbol=SymTYPE) or (CurrentSymbol=SymVAR) or (CurrentSymbol=SymFUNC) or (CurrentSymbol=SymPROC) do begin + if CurrentSymbol=SymCONST then begin + GetSymbol; + Check(TokIdent); + while CurrentSymbol=TokIdent do begin + ConstDeclaration; + end; + end else if CurrentSymbol=SymTYPE then begin + GetSymbol; + Check(TokIdent); + while CurrentSymbol=TokIdent do begin + TypeDeclaration; + end; + end else if CurrentSymbol=SymVAR then begin + GetSymbol; + Check(TokIdent); + while CurrentSymbol=TokIdent do begin + VarDeclaration; + end; + end else if (CurrentSymbol=SymFUNC) or (CurrentSymbol=SymPROC) then begin + FunctionDeclaration(CurrentSymbol=SymFUNC); + end; + end; + if L+1=CodeLabel then begin + CodePosition:=CodePosition-1; + end else begin + Code[L+1]:=CodeLabel; + end; + if CurrentLevel=0 then begin + EmitOpcode(OPAdjS,StackPosition); + end else begin + d:=StackPosition-OldStackPosition; + StackPosition:=OldStackPosition; + EmitOpcode(OPAdjS,d); + end; + Statement; + if CurrentLevel<>0 then begin + EmitOpcode(OPAdjS,OldStackPosition-StackPosition); + end; + i:=OldIdentPos+1; + while i<=IdentifierPosition do begin + if Identifiers[i].Kind=IdFUNC then begin + if (Code[Identifiers[i].FunctionAddress]=OPJmp) and (Code[Identifiers[i].FunctionAddress+1]=0) then begin + Error(144); + end; + end; + i:=i+1; + end; + IdentifierPosition:=OldIdentPos; +end; + +const OutputCodeDataMaximalSize=262144; + +var OutputCodeData:array[1..OutputCodeDataMaximalSize] of char; + OutputCodeDataSize:integer; + +procedure EmitChar(c:char); +begin + OutputCodeDataSize:=OutputCodeDataSize+1; + if OutputCodeDataSize>OutputCodeDataMaximalSize then begin + Error(146); + end; + OutputCodeData[OutputCodeDataSize]:=c; +end; + +procedure EmitByte(B:integer); +begin + EmitChar(chr(B)); +end; + +procedure EmitInt16(i:integer); +begin + if i>=0 then begin + EmitByte(i mod 256); + EmitByte((i div 256) mod 256); + end else begin + i:=-(i+1); + EmitByte(255-(i mod 256)); + EmitByte(255-((i div 256) mod 256)); + end; +end; + +procedure EmitInt32(i:integer); +begin + if i>=0 then begin + EmitByte(i mod 256); + EmitByte((i div 256) mod 256); + EmitByte((i div 65536) mod 256); + EmitByte(i div 16777216); + end else begin + i:=-(i+1); + EmitByte(255-(i mod 256)); + EmitByte(255-((i div 256) mod 256)); + EmitByte(255-((i div 65536) mod 256)); + EmitByte(255-(i div 16777216)); + end; +end; + +function OutputCodeGetInt32(o:integer):integer; +begin + if ord(OutputCodeData[o+3])<$80 then begin + OutputCodeGetInt32:=ord(OutputCodeData[o])+(ord(OutputCodeData[o+1])*256)+(ord(OutputCodeData[o+2])*65536)+(ord(OutputCodeData[o+3])*16777216); + end else begin + OutputCodeGetInt32:=-(((255-ord(OutputCodeData[o]))+((255-ord(OutputCodeData[o+1]))*256)+((255-ord(OutputCodeData[o+2]))*65536)+((255-ord(OutputCodeData[o+3]))*16777216))+1); + end; +end; + +procedure OutputCodePutInt32(o,i:integer); +begin + if i>=0 then begin + OutputCodeData[o]:=chr(i mod 256); + OutputCodeData[o+1]:=chr((i div 256) mod 256); + OutputCodeData[o+2]:=chr((i div 65536) mod 256); + OutputCodeData[o+3]:=chr(i div 16777216); + end else begin + i:=-(i+1); + OutputCodeData[o]:=chr(255-(i mod 256)); + OutputCodeData[o+1]:=chr(255-((i div 256) mod 256)); + OutputCodeData[o+2]:=chr(255-((i div 65536) mod 256)); + OutputCodeData[o+3]:=chr(255-(i div 16777216)); + end; +end; + +procedure WriteOutputCode; +var i:integer; +begin + for i:=1 to OutputCodeDataSize do begin + write(OutputCodeData[i]); + end; +end; + +type TOutputCodeString=array[1..255] of char; + +procedure OutputCodeString(s:TOutputCodeString); +var i:integer; +begin + for i:=1 to 255 do begin + EmitChar(s[i]); + end; +end; + +procedure EmitStubCode; +begin + OutputCodeDataSize:=0; + OutputCodeString(#77#90#82#195#66#101#82#111#94#102#114#0#80#69#0#0#76#1#1#0#0#0#0#0#0#0#0#0#0#0#0#0#224#0#15#3#11#1#0#0#139#3#0#0#0#0#0#0#0#0#0#0#196#16#0#0#0#16#0#0#12#0#0#0#0#0#64#0#0#16#0#0#0#2#0#0#4#0#0#0#0#0#0#0#4#0#0#0#0#0#0#0#0#32#0#0#0#2#0#0#0#0#0#0#3#0#0#0#0#0#16#0#0#32#0#0#0#0#16#0#0#32#0#0#0#0#0#0#16#0#0#0#0#0#0#0#0#0#0#0#0#16#0#0#196#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0); + OutputCodeString(#0#0#0#0#0#0#0#0#0#0#0#0#0#0#16#0#0#0#16#0#0#139#3#0#0#0#2#0#0#0#0#0#0#0#0#0#0#0#0#0#0#32#0#0#224#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0); + OutputCodeString(#0#0#0#0#0#0#0#0#0#0#255#255#255#255#40#16#0#0#53#16#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#107#101#114#110#101#108#51#50#46#100#108#108#0#87#16#0#0#101#16#0#0#116#16#0#0#133#16#0#0#145#16#0#0#156#16#0#0#173#16#0#0#185#16#0#0#0#0#0#0#69#120#105#116#80#114#111#99#101#115#115#0#0#0#71#101#116#83#116#100#72#97#110#100#108#101#0#0#0#83#101#116#67#111#110#115#111#108#101#77#111#100#101#0#0#0#87#114#105#116#101#70#105#108#101#0#0#0#82#101#97#100#70#105#108#101#0#0#0#71#101#116#80#114#111#99#101#115#115#72#101#97#112#0#0#0#72#101#97#112#65#108#108#111#99#0#0#0#72#101#97#112#70#114#101#101#0#233#98#2#0#0#32#67#111#109#112#105#108#101#100#32#98#121#58#32#66#101#82#111#84#105#110#121#80#97#115#99#97#108#32#45#32#40#67#41#32#67#111#112#121#114#105#103#104#116#32#50#48#48#54#44#32#66); + OutputCodeString(#101#110#106#97#109#105#110#32#39#66#101#82#111#39#32#82#111#115#115#101#97#117#120#32#144#141#64#0#86#141#116#36#8#96#106#0#104#21#17#64#0#106#1#86#255#53#39#19#64#0#255#21#65#16#64#0#97#94#194#4#0#144#141#64#0#144#141#64#0#144#141#64#0#86#139#92#36#8#139#68#36#12#131#248#0#125#10#247#216#75#106#45#232#187#255#255#255#51#201#80#83#133#192#116#12#65#187#10#0#0#0#51#210#247#251#235#240#133#201#15#148#210#10#202#91#88#43#217#131#251#0#126#12#81#106#32#232#143#255#255#255#75#117#246#89#141#185#57#17#64#0#81#190#10#0#0#0#51#210#247#254#141#90#48#136#31#79#226#239#89#106#0#104#21#17#64#0#81#104#58#17#64#0#255#53#39#19#64#0#255#21#65#16#64#0#94#194#8#0#106#13#232#78#255#255#255#106#10#232#71#255#255#255#195#144#144#141#64#0#96#106#0#104#212#17#64#0#106#1#104#211#17#64#0#255#53#35#19#64#0#255#21#69#16#64#0#133#192#15#148#208#8#5#186#18); + OutputCodeString(#64#0#131#61#212#17#64#0#0#15#148#208#8#5#186#18#64#0#97#195#0#128#61#16#18#64#0#0#117#12#232#185#255#255#255#198#5#16#18#64#0#1#195#232#229#255#255#255#15#182#5#211#17#64#0#232#160#255#255#255#195#232#211#255#255#255#96#51#192#141#72#1#128#61#186#18#64#0#0#117#72#128#61#211#17#64#0#0#116#16#128#61#211#17#64#0#32#119#7#232#116#255#255#255#235#222#128#61#211#17#64#0#45#117#7#247#217#232#98#255#255#255#15#182#29#211#17#64#0#128#251#48#114#19#128#251#57#119#14#107#192#10#141#68#24#208#232#69#255#255#255#235#225#247#233#97#195#232#115#255#255#255#128#61#186#18#64#0#0#117#18#138#29#211#17#64#0#128#251#10#116#7#232#33#255#255#255#235#224#195#0#15#182#5#186#18#64#0#195#128#61#211#17#64#0#10#15#148#210#195#144#141#64#0#139#37#206#18#64#0#255#53#31#19#64#0#104#0#0#0#0#255#53#27#19#64#0#255#21#81#16#64#0#106#0#255#21#53#16#64#0#210#18#64#0); + OutputCodeString(#25#17#64#0#70#17#64#0#196#17#64#0#39#18#64#0#57#18#64#0#153#18#64#0#187#18#64#0#195#18#64#0#144#141#64#0#144#141#64#0#144#141#64#0#144#141#64#0#106#246#255#21#57#16#64#0#163#35#19#64#0#106#5#80#255#21#61#16#64#0#106#245#255#21#57#16#64#0#163#39#19#64#0#106#3#80#255#21#61#16#64#0#137#37#206#18#64#0#255#21#73#16#64#0#163#27#19#64#0#104#28#0#64#0#104#12#0#1#0#80#255#21#77#16#64#0#163#31#19#64#0#141#160#0#0#64#0#139#236#190#247#18#64#0#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32); + OutputCodeDataSize:=1419; +end; + +const locNone=0; + locPushEAX=1; + locPopEAX=2; + locPopEBX=3; + locIMulEBX=4; + locXorEDXEDX=5; + locIDivEBX=6; + locPushEDX=7; + locCmpEAXEBX=8; + locMovzxEAXAL=9; + locMovDWordPtrESPEAX=10; + locJNZJNE0x03=11; + locMovDWordPtrEBXEAX=12; + locJmpDWordPtrESIOfs=13; + locCallDWordPtrESIOfs=14; + locXChgEDXESI=15; + locPopESI=16; + locMovECXImm=17; + locCLD=18; + locREPMOVSB=19; + locTestEAXEAX=20; + locNegDWordPtrESP=21; + locMovEAXDWordPtrESP=22; + locMovEBXDWordPtrFORStateCurrentValue=23; + locCmpDWordPtrEBXEAX=24; + locMovEAXDWordPtrFORStateDestValue=25; + +var LastOutputCodeValue,PC:integer; + +procedure OCPushEAX; +begin + if LastOutputCodeValue=locPopEAX then begin + if Code[PC]=OutputCodeDataSize then begin + Code[PC]:=Code[PC]-1; + end; + if OutputCodeDataSize>0 then begin + OutputCodeDataSize:=OutputCodeDataSize-1; + end; + LastOutputCodeValue:=locNone; + end else begin + EmitByte($50); + LastOutputCodeValue:=locPushEAX; + end; +end; + +procedure OCPopEAX; +begin + if LastOutputCodeValue=locPushEAX then begin + if Code[PC]=OutputCodeDataSize then begin + Code[PC]:=Code[PC]-1; + end; + if OutputCodeDataSize>0 then begin + OutputCodeDataSize:=OutputCodeDataSize-1; + end; + LastOutputCodeValue:=locNone; + end else begin + EmitByte($58); + LastOutputCodeValue:=locPopEAX; + end; +end; + +procedure OCPopEBX; +begin + EmitByte($5b); + LastOutputCodeValue:=locPopEBX; +end; + +procedure OCIMulEBX; +begin + EmitByte($f7); + EmitByte($eb); + LastOutputCodeValue:=locIMulEBX; +end; + +procedure OCXorEDXEDX; +begin + EmitByte($33); EmitByte($d2); + LastOutputCodeValue:=locXorEDXEDX; +end; + +procedure OCIDIVEBX; +begin + EmitByte($f7); EmitByte($fb); + LastOutputCodeValue:=locIDivEBX; +end; + +procedure OCPushEDX; +begin + EmitByte($52); + LastOutputCodeValue:=locPushEDX; +end; + +procedure OCCmpEAXEBX; +begin + EmitByte($3b); EmitByte($c3); + LastOutputCodeValue:=locCmpEAXEBX; +end; + +procedure OCMovzxEAXAL; +begin + EmitByte($0f); EmitByte($b6); EmitByte($c0); + LastOutputCodeValue:=locMovzxEAXAL; +end; + +procedure OCJNZJNE0x03; +begin + EmitByte($75); EmitByte($03); + LastOutputCodeValue:=locJNZJNE0x03; +end; + +procedure OCMovDWordPtrESPEAX; +begin + EmitByte($89); EmitByte($04); EmitByte($24); + LastOutputCodeValue:=locMovDWordPtrESPEAX; +end; + +procedure OCMovDWordPtrEBXEAX; +begin + EmitByte($89); EmitByte($03); + LastOutputCodeValue:=locMovDWordPtrEBXEAX; +end; + +procedure OCJmpDWordPtrESIOfs(Ofs:integer); +begin + EmitByte($ff); EmitByte($66); EmitByte(Ofs); + LastOutputCodeValue:=locJmpDWordPtrESIOfs; +end; + +procedure OCCallDWordPtrESIOfs(Ofs:integer); +begin + EmitByte($ff); EmitByte($56); EmitByte(Ofs); + LastOutputCodeValue:=locCallDWordPtrESIOfs; +end; + +procedure OCXChgEDXESI; +begin + EmitByte($87); EmitByte($d6); + LastOutputCodeValue:=locXChgEDXESI; +end; + +procedure OCPopESI; +begin + EmitByte($5e); + LastOutputCodeValue:=locPopESI; +end; + +procedure OCMovECXImm(Value:integer); +begin + EmitByte($b9); EmitInt32(Value); + LastOutputCodeValue:=locMovECXImm; +end; + +procedure OCCLD; +begin + EmitByte($fc); + LastOutputCodeValue:=locCLD; +end; + +procedure OCREPMOVSB; +begin + EmitByte($f3); EmitByte($a4); + LastOutputCodeValue:=locREPMOVSB; +end; + +procedure OCTestEAXEAX; +begin + EmitByte($85); EmitByte($c0); { TEST EAX,EAX } + LastOutputCodeValue:=locTestEAXEAX; +end; + +procedure OCNegDWordPtrESP; +begin + EmitByte($f7); EmitByte($1c); EmitByte($24); { NEG DWORD PTR [ESP] } + LastOutputCodeValue:=locNegDWordPtrESP; +end; + +procedure OCMovEAXDWordPtrESP; +begin + EmitByte($8b); EmitByte($04); EmitByte($24); { MOV EAX,DWORD PTR [ESP] } + LastOutputCodeValue:=locMovEAXDWordPtrESP; +end; + +procedure OCMovEBXDWordPtrFORStateCurrentValue; +begin + EmitByte($8b); EmitByte($5d); EmitByte($04); + LastOutputCodeValue:=locMovEBXDWordPtrFORStateCurrentValue; +end; + +procedure OCCmpDWordPtrEBXEAX; +begin + EmitByte($39); EmitByte($03); + LastOutputCodeValue:=locCmpDWordPtrEBXEAX; +end; + +procedure OCMovEAXDWordPtrFORStateDestValue; +begin + EmitByte($8b); EmitByte($45); EmitByte($08); + LastOutputCodeValue:=locMovEAXDWordPtrFORStateDestValue; +end; + +var JumpTable:array[1..MaximalCodeSize] of integer; + +procedure AssembleAndLink; +var CountJumps,Opcode,Value,Index,PEEXECodeSize,PEEXESectionVirtualSize,PEEXESectionAlignment,PEEXECodeStart:integer; +begin + EmitStubCode; + PEEXECodeStart:=OutputCodeDataSize; + LastOutputCodeValue:=locNone; + PC:=0; + CountJumps:=0; + while PC=-128) and (Value<=127) then begin + EmitByte($6a); EmitByte(Value); { PUSH BYTE Value } + end else begin + EmitByte($68); EmitInt32(Value); { PUSH DWORD Value } + end; + LastOutputCodeValue:=locNone; + PC:=PC+1; + end; + OPLdA:begin + if Value=0 then begin + EmitByte($8b); EmitByte($c5); { MOV EAX,EBP } + end else if (Value>=-128) and (Value<=127) then begin + EmitByte($8d); EmitByte($45); EmitByte(Value); { LEA EAX,[EBP+BYTE Value] } + end else begin + EmitByte($8d); EmitByte($85); EmitInt32(Value); { LEA EAX,[EBP+DWORD Value] } + end; + LastOutputCodeValue:=locNone; + OCPushEAX; + PC:=PC+1; + end; + OPLdLA:begin + if Value=0 then begin + EmitByte($8b); EmitByte($c4); { MOV EAX,ESP } + end else if (Value>=-128) and (Value<=127) then begin + EmitByte($8d); EmitByte($44); EmitByte($24); EmitByte(Value); { LEA EAX,[ESP+BYTE Value] } + end else begin + EmitByte($8d); EmitByte($84); EmitByte($24); EmitInt32(Value); { LEA EAX,[ESP+DWORD Value] } + end; + LastOutputCodeValue:=locNone; + OCPushEAX; + PC:=PC+1; + end; + OPLdL:begin + if Value=0 then begin + OCMovEAXDWordPtrESP; + end else if (Value>=-128) and (Value<=127) then begin + EmitByte($8b); EmitByte($44); EmitByte($24); EmitByte(Value); { MOV EAX,DWORD PTR [ESP+BYTE Value] } + end else begin + EmitByte($8b); EmitByte($84); EmitByte($24); EmitInt32(Value); { MOV EAX,DWORD PTR [ESP+DWORD Value] } + end; + OCPushEAX; + PC:=PC+1; + end; + OPLdG:begin + if (Value>=-128) and (Value<=127) then begin + EmitByte($8b); EmitByte($45); EmitByte(Value); { MOV EAX,DWORD PTR [EBP+BYTE Value] } + end else begin + EmitByte($8b); EmitByte($85); EmitInt32(Value); { MOV EAX,DWORD PTR [EBP+DWORD Value] } + end; + LastOutputCodeValue:=locNone; + OCPushEAX; + PC:=PC+1; + end; + OPStL:begin + OCPopEAX; + Value:=Value-4; + if Value=0 then begin + EmitByte($89); EmitByte($04); EmitByte($24); { MOV DWORD PTR [ESP],EAX } + end else if (Value>=-128) and (Value<=127) then begin + EmitByte($89); EmitByte($44); EmitByte($24); EmitByte(Value); { MOV DWORD PTR [ESP+BYTE Value],EAX } + end else begin + EmitByte($89); EmitByte($84); EmitByte($24); EmitInt32(Value); { MOV EAX,DWORD PTR [ESP+DWORD Value] } + end; + LastOutputCodeValue:=locNone; + PC:=PC+1; + end; + OPStG:begin + OCPopEAX; + if (Value>=-128) and (Value<=127) then begin + EmitByte($89); EmitByte($45); EmitByte(Value); { MOV DWORD PTR [EBP+BYTE Value],EAX } + end else begin + EmitByte($89); EmitByte($85); EmitInt32(Value); { MOV EAX,DWORD PTR [EBP+DWORD Value] } + end; + LastOutputCodeValue:=locNone; + PC:=PC+1; + end; + OPMove:begin + OCXChgEDXESI; + EmitByte($5f); { POP EDI } + LastOutputCodeValue:=locNone; + OCPopESI; + OCMovECXImm(Value); + OCCLD; + OCREPMOVSB; + OCXChgEDXESI; + PC:=PC+1; + end; + OPCopy:begin + OCXChgEDXESI; + OCPopESI; + OCMovECXImm(Value); + EmitByte($2b); EmitByte($e1); { SUB ESP,ECX } + EmitByte($8b); EmitByte($fc); { MOV EDI,ESP } + LastOutputCodeValue:=locNone; + OCCLD; + OCREPMOVSB; + OCXChgEDXESI; + PC:=PC+1; + end; + OPAddC:begin + if (Value>=-128) and (Value<=127) then begin + EmitByte($83); EmitByte($04); EmitByte($24); EmitByte(Value); { ADD DWORD PTR [ESP],BYTE Value } + end else begin + EmitByte($81); EmitByte($04); EmitByte($24); EmitInt32(Value); { ADD DWORD PTR [ESP],DWORD Value } + end; + LastOutputCodeValue:=locNone; + PC:=PC+1; + end; + OPMulC:begin + if Value=(-1) then begin + OCNegDWordPtrESP; + end else if (Value>=-128) and (Value<=127) then begin + OCPopEAX; + EmitByte($6b); EmitByte($c0); EmitByte(Value); { IMUL EAX,BYTE s } + LastOutputCodeValue:=locNone; + OCPushEAX; + end else begin + OCPopEAX; + EmitByte($69); EmitByte($c0); EmitInt32(Value); { IMUL EAX,DWORD s } + LastOutputCodeValue:=locNone; + OCPushEAX; + end; + PC:=PC+1; + end; + OPJmp:begin + if Value<>(PC+2) then begin + CountJumps:=CountJumps+1; + EmitByte($e9); { JMP Value } + JumpTable[CountJumps]:=OutputCodeDataSize+1; + EmitInt32(Value); + end; + PC:=PC+1; + LastOutputCodeValue:=locNone; + end; + OPJZ:begin + CountJumps:=CountJumps+1; + OCPopEAX; + OCTestEAXEAX; + EmitByte($0f); EmitByte($84); { JZ Value } + JumpTable[CountJumps]:=OutputCodeDataSize+1; + EmitInt32(Value); + LastOutputCodeValue:=locNone; + PC:=PC+1; + end; + OPCall:begin + CountJumps:=CountJumps+1; + EmitByte($e8); { CALL Value } + JumpTable[CountJumps]:=OutputCodeDataSize+1; + EmitInt32(Value); + LastOutputCodeValue:=locNone; + PC:=PC+1; + end; + OPAdjS:begin + if Value>0 then begin + if (Value>=-128) and (Value<=127) then begin + EmitByte($83); EmitByte($c4); EmitByte(Value); { ADD ESP,BYTE Value } + end else begin + EmitByte($81); EmitByte($c4); EmitInt32(Value); { ADD ESP,DWORD Value } + end; + end else if Value<0 then begin + Value:=-Value; + if (Value>=-128) and (Value<=127) then begin + EmitByte($83); EmitByte($ec); EmitByte(Value); { SUB ESP,BYTE Value } + end else begin + EmitByte($81); EmitByte($ec); EmitInt32(Value); { SUB ESP,DWORD Value } + end; + end; + LastOutputCodeValue:=locNone; + PC:=PC+1; + end; + OPExit:begin + Value:=Value-4; + if Value>0 then begin + EmitByte($c2); EmitInt16(Value); { RET Value } + end else if Value=0 then begin + EmitByte($c3); { RET } + end else begin + Error(145); + end; + LastOutputCodeValue:=locNone; + PC:=PC+1; + end; + end; + PC:=PC+1; + end; + + { Patch jumps + calls } + for Index:=1 to CountJumps do begin + Value:=JumpTable[Index]; + OutputCodePutInt32(Value,((Code[OutputCodeGetInt32(Value)]-Value)-3)); + end; + + { Size Of Code } + PEEXECodeSize:=OutputCodeGetInt32($29)+(OutputCodeDataSize-PEEXECodeStart); + OutputCodePutInt32($29,PEEXECodeSize); + + { Get section alignment } + PEEXESectionAlignment:=OutputCodeGetInt32($45); + + { Calculate and patch section virtual size } + PEEXESectionVirtualSize:=PEEXECodeSize; + if PEEXESectionAlignment<>0 then begin + Value:=PEEXECodeSize mod PEEXESectionAlignment; + if Value<>0 then begin + PEEXESectionVirtualSize:=PEEXESectionVirtualSize+(PEEXESectionAlignment-Value); + end; + end; + OutputCodePutInt32($10d,PEEXESectionVirtualSize); + + { Calculate and patch image size } + OutputCodePutInt32($5d,PEEXESectionVirtualSize+OutputCodeGetInt32($39)); + + { Patch section raw size } + OutputCodePutInt32($115,OutputCodeGetInt32($115)+(OutputCodeDataSize-PEEXECodeStart)); + + WriteOutputCode; +end; + +begin + StringCopy(Keywords[SymBEGIN],'BEGIN '); + StringCopy(Keywords[SymEND],'END '); + StringCopy(Keywords[SymIF],'IF '); + StringCopy(Keywords[SymTHEN],'THEN '); + StringCopy(Keywords[SymELSE],'ELSE '); + StringCopy(Keywords[SymWHILE],'WHILE '); + StringCopy(Keywords[SymDO],'DO '); + StringCopy(Keywords[SymCASE],'CASE '); + StringCopy(Keywords[SymREPEAT],'REPEAT '); + StringCopy(Keywords[SymUNTIL],'UNTIL '); + StringCopy(Keywords[SymFOR],'FOR '); + StringCopy(Keywords[SymTO],'TO '); + StringCopy(Keywords[SymDOWNTO],'DOWNTO '); + StringCopy(Keywords[SymNOT],'NOT '); + StringCopy(Keywords[SymDIV],'DIV '); + StringCopy(Keywords[SymMOD],'MOD '); + StringCopy(Keywords[SymAND],'AND '); + StringCopy(Keywords[SymOR],'OR '); + StringCopy(Keywords[SymCONST],'CONST '); + StringCopy(Keywords[SymVAR],'VAR '); + StringCopy(Keywords[SymTYPE],'TYPE '); + StringCopy(Keywords[SymARRAY],'ARRAY '); + StringCopy(Keywords[SymOF],'OF '); + StringCopy(Keywords[SymPACKED],'PACKED '); + StringCopy(Keywords[SymRECORD],'RECORD '); + StringCopy(Keywords[SymPROGRAM],'PROGRAM '); + StringCopy(Keywords[SymFORWARD],'FORWARD '); + StringCopy(Keywords[SymHALT],'HALT '); + StringCopy(Keywords[SymFUNC],'FUNCTION '); + StringCopy(Keywords[SymPROC],'PROCEDURE '); + + Types[TypeINT].Size:=4; + Types[TypeINT].Kind:=KindSIMPLE; + Types[TypeCHAR].Size:=4; + Types[TypeCHAR].Kind:=KindSIMPLE; + Types[TypeBOOL].Size:=4; + Types[TypeBOOL].Kind:=KindSIMPLE; + Types[TypeSTR].Size:=0; + Types[TypeSTR].Kind:=KindSIMPLE; + TypePosition:=4; + + SymbolNameList[-1]:=0; + CurrentLevel:=-1; + IdentifierPosition:=0; + + EnterSymbol('FALSE ',IdCONST,TypeBOOL); + Identifiers[IdentifierPosition].Value:=ord(false); + + EnterSymbol('TRUE ',IdCONST,TypeBOOL); + Identifiers[IdentifierPosition].Value:=ord(true); + + EnterSymbol('MAXINT ',IdCONST,TypeINT); + Identifiers[IdentifierPosition].Value:=2147483647; + + EnterSymbol('INTEGER ',IdTYPE,TypeINT); + EnterSymbol('CHAR ',IdTYPE,TypeCHAR); + EnterSymbol('BOOLEAN ',IdTYPE,TypeBOOL); + + EnterSymbol('CHR ',IdFUNC,TypeCHAR); + Identifiers[IdentifierPosition].FunctionLevel:=-1; + Identifiers[IdentifierPosition].FunctionAddress:=FunCHR; + Identifiers[IdentifierPosition].Inside:=false; + + EnterSymbol('ORD ',IdFUNC,TypeINT); + Identifiers[IdentifierPosition].FunctionLevel:=-1; + Identifiers[IdentifierPosition].FunctionAddress:=FunORD; + Identifiers[IdentifierPosition].Inside:=false; + + EnterSymbol('WRITE ',IdFUNC,0); + Identifiers[IdentifierPosition].FunctionLevel:=-1; + Identifiers[IdentifierPosition].FunctionAddress:=FunWRITE; + + EnterSymbol('WRITELN ',IdFUNC,0); + Identifiers[IdentifierPosition].FunctionLevel:=-1; + Identifiers[IdentifierPosition].FunctionAddress:=FunWRITELN; + + EnterSymbol('READ ',IdFUNC,0); + Identifiers[IdentifierPosition].FunctionLevel:=-1; + Identifiers[IdentifierPosition].FunctionAddress:=FunREAD; + + EnterSymbol('READLN ',IdFUNC,0); + Identifiers[IdentifierPosition].FunctionLevel:=-1; + Identifiers[IdentifierPosition].FunctionAddress:=FunREADLN; + + EnterSymbol('EOF ',IdFUNC,TypeBOOL); + Identifiers[IdentifierPosition].FunctionLevel:=-1; + Identifiers[IdentifierPosition].FunctionAddress:=FunEOF; + Identifiers[IdentifierPosition].Inside:=false; + + EnterSymbol('EOLN ',IdFUNC,TypeBOOL); + Identifiers[IdentifierPosition].FunctionLevel:=-1; + Identifiers[IdentifierPosition].FunctionAddress:=FunEOFLN; + Identifiers[IdentifierPosition].Inside:=false; + + SymbolNameList[0]:=0; + CurrentLevel:=0; + + CurrentLine:=1; + CurrentColumn:=0; + + ReadChar; + GetSymbol; + IsLabeled:=true; + CodePosition:=0; + LastOpcode:=-1; + StackPosition:=4; + Expect(SymPROGRAM); + Expect(TokIdent); + Expect(TokSemi); + EmitOpcode(OPJmp,0); + Block(0); + EmitOpcode2(OPHalt); + Check(TokPeriod); + AssembleAndLink; +end. diff --git a/src/makeself.bat b/src/makeself.bat new file mode 100644 index 0000000..6e228b4 --- /dev/null +++ b/src/makeself.bat @@ -0,0 +1,6 @@ +@echo off +btpc < btpc.dpr > btpcnew.exe +del btpc.exe +copy btpcnew.exe btpc.exe +del btpcnew.exe + diff --git a/src/rtl.asm b/src/rtl.asm new file mode 100644 index 0000000..d7d00d3 --- /dev/null +++ b/src/rtl.asm @@ -0,0 +1,211 @@ +.CPU PENTIUM4 +.BITS 32 +.ENTRYPOINT +JMP StubEntryPoint +DSTR " Compiled by: BeRoTinyPascal - (C) Copyright 2006, Benjamin 'BeRo' Rosseaux " +HEAP_NO_SERIALIZE=1 +HEAP_GENERATE_EXCEPTIONS=4 +HEAP_ZERO_MEMORY=8 +HEAP_CREATE_ALIGN_16=0x10000 +RTLWriteCharBytesWritten: DB 0x90,0x8D,0x40,0x00 +RTLWriteChar: +PUSH ESI +LEA ESI,[ESP+8] +PUSHAD +INVOKE WriteFile,DWORD PTR StdHandleOutput,ESI,BYTE 1,OFFSET RTLWriteCharBytesWritten,BYTE 0 +POPAD +POP ESI +RET 4 +RTLWriteIntegerBuffer: TIMES 3 DB 0x90,0x8D,0x40,0x00 +RTLWriteInteger: +PUSH ESI + MOV EBX,DWORD PTR [ESP+8] + MOV EAX,DWORD PTR [ESP+12] + CMP EAX,0 + JNL RTLWriteIntegerNotSigned + NEG EAX + DEC EBX + PUSH BYTE '-' + CALL RTLWriteChar + RTLWriteIntegerNotSigned: + XOR ECX,ECX + PUSH EAX + PUSH EBX + RTLWriteIntegerPreCheckLoop: + TEST EAX,EAX + JZ RTLWriteIntegerPreCheckLoopDone + INC ECX + MOV EBX,10 + XOR EDX,EDX + IDIV EBX + JMP RTLWriteIntegerPreCheckLoop + RTLWriteIntegerPreCheckLoopDone: + TEST ECX,ECX + SETZ DL + OR CL,DL + POP EBX + POP EAX + SUB EBX,ECX + CMP EBX,0 + JLE RTLWriteIntegerNotPadding + PUSH ECX + RTLWriteIntegerPaddingLoop: + PUSH BYTE ' ' + CALL RTLWriteChar + DEC EBX + JNZ RTLWriteIntegerPaddingLoop + POP ECX + RTLWriteIntegerNotPadding: + LEA EDI,[OFFSET RTLWriteIntegerBuffer+ECX-1] + PUSH ECX + RTLWriteIntegerLoop: + MOV ESI,10 + XOR EDX,EDX + IDIV ESI + LEA EBX,[EDX+'0'] + MOV BYTE PTR [EDI],BL + DEC EDI + LOOP RTLWriteIntegerLoop + POP ECX + INVOKE WriteFile,DWORD PTR StdHandleOutput,OFFSET RTLWriteIntegerBuffer,ECX,OFFSET RTLWriteCharBytesWritten,BYTE 0 +POP ESI +RET 8 +RTLWriteLn: +PUSH BYTE 13 +CALL RTLWriteChar +PUSH BYTE 10 +CALL RTLWriteChar +RET +ReadCharBuffer: DB 0x90 +ReadCharBytesRead: DB 0x90,0x8D,0x40,0x00 +ReadCharEx: +PUSHAD +INVOKE ReadFile,DWORD PTR StdHandleInput,OFFSET ReadCharBuffer,1,OFFSET ReadCharBytesRead,BYTE 0 +TEST EAX,EAX +SETZ AL +OR BYTE PTR IsEOF,AL +CMP DWORD PTR [ReadCharBytesRead],0 +SETZ AL +OR BYTE PTR IsEOF,AL +POPAD +RET +ReadCharInited: DB 0 +ReadCharInit: +CMP BYTE PTR ReadCharInited,0 +JNZ ReadInitDone +CALL ReadCharEx +MOV BYTE PTR ReadCharInited,1 +ReadInitDone: +RET +RTLReadChar: +CALL ReadCharInit +MOVZX EAX,BYTE PTR ReadCharBuffer +CALL ReadCharEx +RET +RTLReadInteger: +CALL ReadCharInit +PUSHAD + XOR EAX,EAX + LEA ECX,[EAX+1] + ReadIntegerSkipWhiteSpace: + CMP BYTE PTR IsEOF,0 + JNZ ReadIntegerDone + CMP BYTE PTR ReadCharBuffer,0 + JE ReadIntegerSkipWhiteSpaceDone + CMP BYTE PTR ReadCharBuffer,32 + JA ReadIntegerSkipWhiteSpaceDone + CALL ReadCharEx + JMP ReadIntegerSkipWhiteSpace + ReadIntegerSkipWhiteSpaceDone: + CMP BYTE PTR ReadCharBuffer,'-' + JNE ReadIntegerNotSigned + NEG ECX + CALL ReadCharEx + ReadIntegerNotSigned: + ReadIntegerLoop: + MOVZX EBX,BYTE PTR ReadCharBuffer + CMP BL,'0' + JB ReadIntegerDone + CMP BL,'9' + JA ReadIntegerDone + IMUL EAX,10 + LEA EAX,[EAX+EBX-'0'] + CALL ReadCharEx + JMP ReadIntegerLoop + ReadIntegerDone: + IMUL ECX +POPAD +RET +RTLReadLn: +CALL ReadCharInit +CMP BYTE PTR IsEOF,0 +JNE ReadLnDone +MOV BL,BYTE PTR ReadCharBuffer +CMP BL,10 +JE ReadLnDone +CALL ReadCharEx +JMP RTLReadLn +ReadLnDone: +RET +IsEOF: DB 0 +RTLEOF: +MOVZX EAX,BYTE PTR IsEOF +RET +RTLEOLN: +CMP BYTE PTR ReadCharBuffer,10 +SETE DL +RET +OldStack: DB 0x90,0x8D,0x40,0x00 +RTLHalt: +MOV ESP,DWORD PTR OldStack +INVOKE HeapFree,DWORD PTR HeapHandle,(HEAP_GENERATE_EXCEPTIONS+HEAP_ZERO_MEMORY+HEAP_CREATE_ALIGN_16)&HEAP_NO_SERIALIZE,DWORD PTR HeapMemory +INVOKE ExitProcess,BYTE 0 +RTLCallHalt EQU DWORD PTR [ESI] +RTLCallWriteChar EQU DWORD PTR [ESI+4] +RTLCallWriteInteger EQU DWORD PTR [ESI+8] +RTLCallWriteLn EQU DWORD PTR [ESI+12] +RTLCallReadChar EQU DWORD PTR [ESI+16] +RTLCallReadInteger EQU DWORD PTR [ESI+20] +RTLCallReadLn EQU DWORD PTR [ESI+24] +RTLCallEOF EQU DWORD PTR [ESI+28] +RTLCallEOLN EQU DWORD PTR [ESI+32] +RTLFunctionTable: +DD OFFSET RTLHalt +DD OFFSET RTLWriteChar +DD OFFSET RTLWriteInteger +DD OFFSET RTLWriteLn +DD OFFSET RTLReadChar +DD OFFSET RTLReadInteger +DD OFFSET RTLReadLn +DD OFFSET RTLEOF +DD OFFSET RTLEOLN +HeapHandle: DB 0x90,0x8D,0x40,0x00 +HeapMemory: DB 0x90,0x8D,0x40,0x00 +StdHandleInput: DB 0x90,0x8D,0x40,0x00 +StdHandleOutput: DB 0x90,0x8D,0x40,0x00 +StubEntryPoint: +INVOKE GetStdHandle,BYTE -10 +MOV DWORD PTR StdHandleInput,EAX +INVOKE SetConsoleMode,EAX,1+4 +INVOKE GetStdHandle,BYTE -11 +MOV DWORD PTR StdHandleOutput,EAX +INVOKE SetConsoleMode,EAX,1+2 +MOV DWORD PTR OldStack,ESP +INVOKE GetProcessHeap +MOV DWORD PTR HeapHandle,EAX +INVOKE HeapAlloc,EAX,HEAP_GENERATE_EXCEPTIONS+HEAP_ZERO_MEMORY+HEAP_CREATE_ALIGN_16,4194332 +MOV DWORD PTR HeapMemory,EAX +LEA ESP,[EAX+4194304] +MOV EBP,ESP +MOV ESI,OFFSET RTLFunctionTable +.LIBRARY "kernel32.dll" +IMPORT ExitProcess "ExitProcess" +IMPORT GetStdHandle "GetStdHandle" +IMPORT SetConsoleMode "SetConsoleMode" +IMPORT WriteFile "WriteFile" +IMPORT ReadFile "ReadFile" +IMPORT ReadConsoleInputA "ReadConsoleInputA" +IMPORT GetProcessHeap "GetProcessHeap" +IMPORT HeapAlloc "HeapAlloc" +IMPORT HeapFree "HeapFree" +ProgramEntryPoint: \ No newline at end of file From 87e059368fed777d177f5b7449c330adab55d0e9 Mon Sep 17 00:00:00 2001 From: Benjamin Rosseaux Date: Wed, 22 Jun 2016 00:00:18 +0200 Subject: [PATCH 02/12] Update README.md --- README.md | 35 +++++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+) diff --git a/README.md b/README.md index 889a340..5bc44d6 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,37 @@ # berotinypascal A self-hosting capable tiny pascal compiler for the Win32 x86 platform + +## License + + ****************************************************************************** + * zlib license * + *============================================================================* + * * + * Copyright (C) 2006-2016, Benjamin Rosseaux (benjamin@rosseaux.com) * + * * + * This software is provided 'as-is', without any express or implied * + * warranty. In no event will the authors be held liable for any damages * + * arising from the use of this software. * + * * + * Permission is granted to anyone to use this software for any purpose, * + * including commercial applications, and to alter it and redistribute it * + * freely, subject to the following restrictions: * + * * + * 1. The origin of this software must not be misrepresented; you must not * + * claim that you wrote the original software. If you use this software * + * in a product, an acknowledgement in the product documentation would be * + * appreciated but is not required. * + * 2. Altered source versions must be plainly marked as such, and must not be * + * misrepresented as being the original software. * + * 3. This notice may not be removed or altered from any source distribution. * + * * + ****************************************************************************** + +## General guidelines for code contributors + +1. Make sure you are legally allowed to make a contribution under the zlib license. +2. The zlib license header goes at the top of each source file, with appropriate copyright notice. +3. After a pull request, check the status of your pull request on http://github.com/BeRo1985/berotinypascal +4. Write code, which is compatible with Delphi 7-XE7 and FreePascal >= 3.0 and even with BeRoTinyPascal itself, so don't use generics/templates, operator overloading and another newer syntax features than Delphi 7 and BeRoTinyPascal have support for that +5. Don't use any libraries/units except the RTL system unit functions. +6. Make sure the code compiles with Delphi 7, FreePascal >= 3.0 and with BeRoTinyPascal itself. From b2ae8b806b26cb860b1b9703883ce4c2670b9e5b Mon Sep 17 00:00:00 2001 From: Benjamin Rosseaux Date: Wed, 22 Jun 2016 00:01:58 +0200 Subject: [PATCH 03/12] - Typo fixes --- README.md | 2 +- src/btpc.dpr | 10 +++++----- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index 5bc44d6..ed26deb 100644 --- a/README.md +++ b/README.md @@ -31,7 +31,7 @@ A self-hosting capable tiny pascal compiler for the Win32 x86 platform 1. Make sure you are legally allowed to make a contribution under the zlib license. 2. The zlib license header goes at the top of each source file, with appropriate copyright notice. -3. After a pull request, check the status of your pull request on http://github.com/BeRo1985/berotinypascal +3. After a pull request, check the status of your pull request on http://github.com/BeRo1985/berotinypascal . 4. Write code, which is compatible with Delphi 7-XE7 and FreePascal >= 3.0 and even with BeRoTinyPascal itself, so don't use generics/templates, operator overloading and another newer syntax features than Delphi 7 and BeRoTinyPascal have support for that 5. Don't use any libraries/units except the RTL system unit functions. 6. Make sure the code compiles with Delphi 7, FreePascal >= 3.0 and with BeRoTinyPascal itself. diff --git a/src/btpc.dpr b/src/btpc.dpr index c09521d..1c1d4b4 100644 --- a/src/btpc.dpr +++ b/src/btpc.dpr @@ -3,7 +3,7 @@ ****************************************************************************** * A self-hosting capable tiny pascal compiler for the Win32 x86 platform * ****************************************************************************** - * Version 2016-06-21-23-44-0000 * + * Version 2016-06-21-00-00-0000 * ****************************************************************************** * zlib license * *============================================================================* @@ -35,14 +35,14 @@ * 2. The zlib license header goes at the top of each source file, with * * appropriate copyright notice. * * 3. After a pull request, check the status of your pull request on * - http://github.com/BeRo1985/berotinypacal * + http://github.com/BeRo1985/berotinypascal . * * 4. Write code, which is compatible with Delphi 7-XE7 and FreePascal >= 3.0 * * and even with BeRoTinyPascal itself, so don't use generics/templates, * * operator overloading and another newer syntax features than Delphi 7 * - * and BeRoTinyPascal have support for that * + * and BeRoTinyPascal have support for that. * * 5. Don't use any libraries/units except the RTL system unit functions * - * 7. Make sure the code compiles with Delphi 7, FreePascal >= 3.0 and with * - * BeRoTinyPascal itself * + * +. Make sure the code compiles with Delphi 7, FreePascal >= 3.0 and with * + * BeRoTinyPascal itself. * * * ******************************************************************************) program BTPC; { BeRoTinyPascalCompiler } From 81ef9220c7a9c2d625cea0cd3dc8087fb62c4cae Mon Sep 17 00:00:00 2001 From: Benjamin Rosseaux Date: Wed, 22 Jun 2016 00:02:26 +0200 Subject: [PATCH 04/12] - Typo fixes --- src/btpc.dpr | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/btpc.dpr b/src/btpc.dpr index 1c1d4b4..fc02d7a 100644 --- a/src/btpc.dpr +++ b/src/btpc.dpr @@ -3,7 +3,7 @@ ****************************************************************************** * A self-hosting capable tiny pascal compiler for the Win32 x86 platform * ****************************************************************************** - * Version 2016-06-21-00-00-0000 * + * Version 2016-06-22-00-00-0000 * ****************************************************************************** * zlib license * *============================================================================* From ab625bd2b9deda040512adc9ea3c6eeca8192513 Mon Sep 17 00:00:00 2001 From: Benjamin Rosseaux Date: Wed, 22 Jun 2016 00:06:09 +0200 Subject: [PATCH 05/12] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index ed26deb..2e5f078 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -# berotinypascal +# BeRoTinyPascal A self-hosting capable tiny pascal compiler for the Win32 x86 platform ## License From 9f42a5e950d28c64e974dabf1560b0b584dc938a Mon Sep 17 00:00:00 2001 From: Benjamin Rosseaux Date: Wed, 22 Jun 2016 18:01:10 +0200 Subject: [PATCH 06/12] - Fixed a error message typo from ">)" to ">=" - Added (yet untested) support for // line comments --- src/btpc.dpr | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/src/btpc.dpr b/src/btpc.dpr index fc02d7a..2da44eb 100644 --- a/src/btpc.dpr +++ b/src/btpc.dpr @@ -3,7 +3,7 @@ ****************************************************************************** * A self-hosting capable tiny pascal compiler for the Win32 x86 platform * ****************************************************************************** - * Version 2016-06-22-00-00-0000 * + * Version 2016-06-22-17-59-0000 * ****************************************************************************** * zlib license * *============================================================================* @@ -307,7 +307,7 @@ begin Write('">" expected'); end; TokGEq:begin - Write('">)" expected'); + Write('">=" expected'); end; TokLParent:begin Write('"(" expected'); @@ -782,6 +782,16 @@ begin end; ReadChar; GetSymbol; + end else if CurrentChar='/' then begin + ReadChar; + if CurrentChar='/' then begin + repeat + ReadChar; + until CurrentChar=#10; + GetSymbol; + end else begin + Error(102); + end; end else begin Error(102); end; From 0535a9f5edef2a9ddd3ddafbb35a298b5d06d363 Mon Sep 17 00:00:00 2001 From: Benjamin Rosseaux Date: Wed, 22 Jun 2016 18:08:45 +0200 Subject: [PATCH 07/12] - Added quick&dirty EOF-null-char-checking at parsing of comments --- src/btpc.dpr | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/btpc.dpr b/src/btpc.dpr index 2da44eb..dae38ae 100644 --- a/src/btpc.dpr +++ b/src/btpc.dpr @@ -3,7 +3,7 @@ ****************************************************************************** * A self-hosting capable tiny pascal compiler for the Win32 x86 platform * ****************************************************************************** - * Version 2016-06-22-17-59-0000 * + * Version 2016-06-22-18-07-0000 * ****************************************************************************** * zlib license * *============================================================================* @@ -749,7 +749,7 @@ begin if CurrentChar='*' then begin ReadChar; LastChar:='-'; - while not ((CurrentChar=')') and (LastChar='*')) do begin + while (CurrentChar<>#0) and not ((CurrentChar=')') and (LastChar='*')) do begin LastChar:=CurrentChar; ReadChar; end; @@ -777,7 +777,7 @@ begin ReadChar; CurrentSymbol:=TokSemi; end else if CurrentChar='{' then begin - while CurrentChar<>'}' do begin + while (CurrentChar<>'}') and (CurrentChar<>#0) do begin ReadChar; end; ReadChar; @@ -787,7 +787,7 @@ begin if CurrentChar='/' then begin repeat ReadChar; - until CurrentChar=#10; + until (CurrentChar=#10) or (CurrentChar=#0); GetSymbol; end else begin Error(102); From 26ebb6d934272bf93363cad76cf8fc684bb0fa68 Mon Sep 17 00:00:00 2001 From: Benjamin Rosseaux Date: Wed, 22 Jun 2016 19:03:14 +0200 Subject: [PATCH 08/12] - Updated self-compiled binary --- bin/btpc.exe | Bin 53387 -> 53567 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/bin/btpc.exe b/bin/btpc.exe index 86acfb212c9e4d5852d6213b71d8c4d8978d1da1..6e2d963d8cdac5d87e4d39fb75d80f9c32869652 100644 GIT binary patch delta 1931 zcmZ8h2~?C-6rOjPX22lC1;jxGlSJG%qy+xK0b~nF^BfdN$x!$K36Xsj0of1u+40!M zu_#;h$X_C&APgv$3+7TDO)Xpg%wv+6o-C*L|7Kuk&dj^-e&4^-m$9p zAmLPl=XL%oIkHSG`5u(&o=DX(Uv%1dN%L%nEuca@jHXzcphu%Af}O%m(-JDuK?uks zy$&q_5v)bh1@0oUx5A#q&#<3ye(_}1fd`8xJ8vhAraDj)DSAXlEi~J2>$Bf?xa_cf zX%qZ{UFPR&G#dHcI~I#LJ*rYWNhNAj;%f>qQguujjEt-fm}HH@;PLY_tT;bP$uykj z;5@#SjXcvYZ(A%D*^689nY(8<68eK(>@E#(hfZ}= zGmH%}*ng&Y^r~kK(`e9ca<;2cd^W0YA%hrV2!BQKIH;bHoTX}AIH>iJHrYqvjZk^N zKGYg1<~_~}#p#fdMGwmzQh(Xu!7_&_t-5xbSJa~vc!67T<{x}p`6%bi$8(BGKr^SQ z!u|*PE8uI7z+q~ntvZ~4Mc`GF(}ZKnNgCx4J?D#S<*K$pyRZ$zLMM+}&Rtzv4Ihj) zQa-5!e0m3gp;Ooxq=x3v%~sq9EoNhp5>}(FZM9h7ux^y(5Z=sabPI>(;O_HrYz9_D z%%S`Hq}qrRwrm=rqrJ4Ne&FP9qi4Vz{f^%4L!P+&8j@qu=>9HTiCLz5@dMsgces@} zVM*)^O8*{3u`6`DcX8rK>2mBuqFYx$tMe%R3W`>Hv4z;jH_Mxl`jR6;;@)IW;-|Qk zEC~KDH?raQ?&Slt{1V<;vw)g+;{2M6>>MKF=i*STvsJoWuG;hB4Qv6owpuqe@6>n@6Pcb+2iC%R5EUc5}lXMmWU-Hi)GwFFY9orS$~}L{@ZvD-am=(v_2An@f)6|Jttt=u#}=tVEcwT z`tmp?r#CQfw5G4tr8Mw9y1=c<30@oP>2N)IH%=wgJI@2BDnH9zykeRiEvTEUw9nXeKS=l=nUG2e$+?_gKer@H8 zaLaSSx!fQ+*Nt&`VN}r#F|Us9nek`dGt_6s#QbEsSAqKcDoU<^YnUVE6mT_NSXJ;e zt?xoZOC6;@3&%0K(4p#>SsX|s$}pj1Eb5ExXjumui#@2L z6vv8v>3Tb?HyO#V6n}5=M#&~G@^0rD3^s;#-UW?3s~4{2W1b{#hWB#8{fEFx&hhK} zb;%878k>`-vrP%0rZz;BdQfhglwIn>m=8WL3#30Wdu)as2b^&|%QXt?~kHBX#>xj|rzTcoUPgTGQe)v-U@s|$_!KVHv zJ4jq2=L|unDbkz+xa=^|#A736?;+@PRd~d49o8S!(Oq9;9u;VxFIxDL;fs4m1vU@f ey+*q2gWO($nti0U-UPjVY6_oCZz??d;{E|zAz*+2 delta 1776 zcmYjQYgAQ57`^j(y;ojc2@w%7%m)vJ0u|Jda}Wp(1AJ73V1NR8kbHt9577XM=NjpsGjsOd-=00+%pBb_pnUg$ zcYLV4quTFh{*{NaTs@h;mMaG?H!xouvkR6dIogNNDFeiaWXdvNS41rHz@3OVIz13V zWG>Ach{niRHb6E+eL}Q=&=5V&ej@2~|c^^i%0U*><8PJVX&Vy!nN-{2Mjjg z?jzH9DOr=6&T5R&#om;HhSm0~CunM?LXB~@F?l-do#m1IiiSLGL*o0j z`H#1w?K`j^FSOzB_V>e{t`0w?9%M(c zBQ23VL|@u2ed~3;Zim?o4U1~Y?mFfy4xx-a*s}O4nRg>I{bib_4M9-SJ=ibENS}yl z#SWN}F@I1(Ee|o4ACQ33k{3B%MywRbuAo>7qR^fALh5AQD9H+@54+KvHJLKI@jD-$?}p#9 zm)ZBoTQ-I2FXG^`bDA!j>n@-;ry!6w5S6QR?Q_-2Vz!N()zQwy1JV6B702=jjBQCn!U898U;DyDY_b; z=7iD8)9A^W%)0PQZUOrSJ9CpLy)=tB@j90;C6K)?O!8{HO>BX??qG}_LMzZ`WUmo`MBt`F;Z2xmWJL_ z)p*Gbqbz>CwBk< From e34bd4164f4b7c27e7cf667dffd9274d33d6dfbe Mon Sep 17 00:00:00 2001 From: Benjamin Rosseaux Date: Tue, 17 Jan 2017 03:50:08 +0100 Subject: [PATCH 09/12] . Fixed issue https://github.com/BeRo1985/berotinypascal/issues/1 - Added my own own x86 assembler binary for to assembly the rtl.asm and my old rtl2pas tool --- src/btpc.dpr | 14 ++--- src/egasm.exe | Bin 0 -> 445440 bytes src/makertl.bat | 5 ++ src/rtl.asm | 1 + src/rtl2pas.cfg | 38 ++++++++++++++ src/rtl2pas.dof | 136 ++++++++++++++++++++++++++++++++++++++++++++++++ src/rtl2pas.dpr | 51 ++++++++++++++++++ 7 files changed, 238 insertions(+), 7 deletions(-) create mode 100644 src/egasm.exe create mode 100644 src/makertl.bat create mode 100644 src/rtl2pas.cfg create mode 100644 src/rtl2pas.dof create mode 100644 src/rtl2pas.dpr diff --git a/src/btpc.dpr b/src/btpc.dpr index dae38ae..849d536 100644 --- a/src/btpc.dpr +++ b/src/btpc.dpr @@ -2047,13 +2047,13 @@ end; procedure EmitStubCode; begin OutputCodeDataSize:=0; - OutputCodeString(#77#90#82#195#66#101#82#111#94#102#114#0#80#69#0#0#76#1#1#0#0#0#0#0#0#0#0#0#0#0#0#0#224#0#15#3#11#1#0#0#139#3#0#0#0#0#0#0#0#0#0#0#196#16#0#0#0#16#0#0#12#0#0#0#0#0#64#0#0#16#0#0#0#2#0#0#4#0#0#0#0#0#0#0#4#0#0#0#0#0#0#0#0#32#0#0#0#2#0#0#0#0#0#0#3#0#0#0#0#0#16#0#0#32#0#0#0#0#16#0#0#32#0#0#0#0#0#0#16#0#0#0#0#0#0#0#0#0#0#0#0#16#0#0#196#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0); - OutputCodeString(#0#0#0#0#0#0#0#0#0#0#0#0#0#0#16#0#0#0#16#0#0#139#3#0#0#0#2#0#0#0#0#0#0#0#0#0#0#0#0#0#0#32#0#0#224#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0); - OutputCodeString(#0#0#0#0#0#0#0#0#0#0#255#255#255#255#40#16#0#0#53#16#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#107#101#114#110#101#108#51#50#46#100#108#108#0#87#16#0#0#101#16#0#0#116#16#0#0#133#16#0#0#145#16#0#0#156#16#0#0#173#16#0#0#185#16#0#0#0#0#0#0#69#120#105#116#80#114#111#99#101#115#115#0#0#0#71#101#116#83#116#100#72#97#110#100#108#101#0#0#0#83#101#116#67#111#110#115#111#108#101#77#111#100#101#0#0#0#87#114#105#116#101#70#105#108#101#0#0#0#82#101#97#100#70#105#108#101#0#0#0#71#101#116#80#114#111#99#101#115#115#72#101#97#112#0#0#0#72#101#97#112#65#108#108#111#99#0#0#0#72#101#97#112#70#114#101#101#0#233#98#2#0#0#32#67#111#109#112#105#108#101#100#32#98#121#58#32#66#101#82#111#84#105#110#121#80#97#115#99#97#108#32#45#32#40#67#41#32#67#111#112#121#114#105#103#104#116#32#50#48#48#54#44#32#66); - OutputCodeString(#101#110#106#97#109#105#110#32#39#66#101#82#111#39#32#82#111#115#115#101#97#117#120#32#144#141#64#0#86#141#116#36#8#96#106#0#104#21#17#64#0#106#1#86#255#53#39#19#64#0#255#21#65#16#64#0#97#94#194#4#0#144#141#64#0#144#141#64#0#144#141#64#0#86#139#92#36#8#139#68#36#12#131#248#0#125#10#247#216#75#106#45#232#187#255#255#255#51#201#80#83#133#192#116#12#65#187#10#0#0#0#51#210#247#251#235#240#133#201#15#148#210#10#202#91#88#43#217#131#251#0#126#12#81#106#32#232#143#255#255#255#75#117#246#89#141#185#57#17#64#0#81#190#10#0#0#0#51#210#247#254#141#90#48#136#31#79#226#239#89#106#0#104#21#17#64#0#81#104#58#17#64#0#255#53#39#19#64#0#255#21#65#16#64#0#94#194#8#0#106#13#232#78#255#255#255#106#10#232#71#255#255#255#195#144#144#141#64#0#96#106#0#104#212#17#64#0#106#1#104#211#17#64#0#255#53#35#19#64#0#255#21#69#16#64#0#133#192#15#148#208#8#5#186#18); - OutputCodeString(#64#0#131#61#212#17#64#0#0#15#148#208#8#5#186#18#64#0#97#195#0#128#61#16#18#64#0#0#117#12#232#185#255#255#255#198#5#16#18#64#0#1#195#232#229#255#255#255#15#182#5#211#17#64#0#232#160#255#255#255#195#232#211#255#255#255#96#51#192#141#72#1#128#61#186#18#64#0#0#117#72#128#61#211#17#64#0#0#116#16#128#61#211#17#64#0#32#119#7#232#116#255#255#255#235#222#128#61#211#17#64#0#45#117#7#247#217#232#98#255#255#255#15#182#29#211#17#64#0#128#251#48#114#19#128#251#57#119#14#107#192#10#141#68#24#208#232#69#255#255#255#235#225#247#233#97#195#232#115#255#255#255#128#61#186#18#64#0#0#117#18#138#29#211#17#64#0#128#251#10#116#7#232#33#255#255#255#235#224#195#0#15#182#5#186#18#64#0#195#128#61#211#17#64#0#10#15#148#210#195#144#141#64#0#139#37#206#18#64#0#255#53#31#19#64#0#104#0#0#0#0#255#53#27#19#64#0#255#21#81#16#64#0#106#0#255#21#53#16#64#0#210#18#64#0); - OutputCodeString(#25#17#64#0#70#17#64#0#196#17#64#0#39#18#64#0#57#18#64#0#153#18#64#0#187#18#64#0#195#18#64#0#144#141#64#0#144#141#64#0#144#141#64#0#144#141#64#0#106#246#255#21#57#16#64#0#163#35#19#64#0#106#5#80#255#21#61#16#64#0#106#245#255#21#57#16#64#0#163#39#19#64#0#106#3#80#255#21#61#16#64#0#137#37#206#18#64#0#255#21#73#16#64#0#163#27#19#64#0#104#28#0#64#0#104#12#0#1#0#80#255#21#77#16#64#0#163#31#19#64#0#141#160#0#0#64#0#139#236#190#247#18#64#0#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32#32); - OutputCodeDataSize:=1419; + OutputCodeString(#77#90#82#195#66#101#82#111#94#102#114#0#80#69#0#0#76#1#1#0#0#0#0#0#0#0#0#0#0#0#0#0#224#0#15#3#11#1#0#0#143#3#0#0#0#0#0#0#0#0#0#0#196#16#0#0#0#16#0#0#12#0#0#0#0#0#64#0#0#16#0#0#0#2#0#0#4#0#0#0#0#0#0#0#4#0#0#0#0#0#0#0#0#32#0#0#0#2#0#0#0#0#0#0#3#0#0#0#0#0#16#0#0#32#0#0#0#0#16#0#0#32#0#0#0#0#0#0#16#0#0#0#0#0#0#0#0#0#0#0#0#16#0#0#196#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0); + OutputCodeString(#0#0#0#0#0#0#0#0#0#0#0#0#0#0#16#0#0#0#16#0#0#143#3#0#0#0#2#0#0#0#0#0#0#0#0#0#0#0#0#0#0#32#0#0#224#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0); + OutputCodeString(#0#0#0#0#0#0#0#0#0#0#255#255#255#255#40#16#0#0#53#16#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#107#101#114#110#101#108#51#50#46#100#108#108#0#87#16#0#0#101#16#0#0#116#16#0#0#133#16#0#0#145#16#0#0#156#16#0#0#173#16#0#0#185#16#0#0#0#0#0#0#69#120#105#116#80#114#111#99#101#115#115#0#0#0#71#101#116#83#116#100#72#97#110#100#108#101#0#0#0#83#101#116#67#111#110#115#111#108#101#77#111#100#101#0#0#0#87#114#105#116#101#70#105#108#101#0#0#0#82#101#97#100#70#105#108#101#0#0#0#71#101#116#80#114#111#99#101#115#115#72#101#97#112#0#0#0#72#101#97#112#65#108#108#111#99#0#0#0#72#101#97#112#70#114#101#101#0#233#102#2#0#0#32#67#111#109#112#105#108#101#100#32#98#121#58#32#66#101#82#111#84#105#110#121#80#97#115#99#97#108#32#45#32#40#67#41#32#67#111#112#121#114#105#103#104#116#32#50#48#48#54#44#32#66); + OutputCodeString(#101#110#106#97#109#105#110#32#39#66#101#82#111#39#32#82#111#115#115#101#97#117#120#32#144#141#64#0#86#141#116#36#8#96#106#0#104#21#17#64#0#106#1#86#255#53#43#19#64#0#255#21#65#16#64#0#97#94#194#4#0#144#141#64#0#144#141#64#0#144#141#64#0#86#139#92#36#8#139#68#36#12#131#248#0#125#10#247#216#75#106#45#232#187#255#255#255#51#201#80#83#133#192#116#12#65#187#10#0#0#0#51#210#247#251#235#240#133#201#15#148#210#10#202#91#88#43#217#131#251#0#126#12#81#106#32#232#143#255#255#255#75#117#246#89#141#185#57#17#64#0#81#190#10#0#0#0#51#210#247#254#141#90#48#136#31#79#226#239#89#106#0#104#21#17#64#0#81#104#58#17#64#0#255#53#43#19#64#0#255#21#65#16#64#0#94#194#8#0#106#13#232#78#255#255#255#106#10#232#71#255#255#255#195#144#144#141#64#0#96#106#0#104#212#17#64#0#106#1#104#211#17#64#0#255#53#39#19#64#0#255#21#69#16#64#0#133#192#15#148#208#8#5#190#18); + OutputCodeString(#64#0#131#61#212#17#64#0#0#15#148#208#8#5#190#18#64#0#97#195#0#128#61#16#18#64#0#0#117#12#232#185#255#255#255#198#5#16#18#64#0#1#195#232#229#255#255#255#15#182#5#211#17#64#0#232#160#255#255#255#195#232#211#255#255#255#96#51#192#141#72#1#128#61#190#18#64#0#0#117#72#128#61#211#17#64#0#0#116#16#128#61#211#17#64#0#32#119#7#232#116#255#255#255#235#222#128#61#211#17#64#0#45#117#7#247#217#232#98#255#255#255#15#182#29#211#17#64#0#128#251#48#114#19#128#251#57#119#14#107#192#10#141#68#24#208#232#69#255#255#255#235#225#247#233#137#68#36#28#97#195#232#111#255#255#255#128#61#190#18#64#0#0#117#18#138#29#211#17#64#0#128#251#10#116#7#232#29#255#255#255#235#224#195#0#15#182#5#190#18#64#0#195#128#61#211#17#64#0#10#15#148#210#195#144#141#64#0#139#37#210#18#64#0#255#53#35#19#64#0#104#0#0#0#0#255#53#31#19#64#0#255#21#81#16#64#0#106#0#255#21#53#16#64#0); + OutputCodeString(#214#18#64#0#25#17#64#0#70#17#64#0#196#17#64#0#39#18#64#0#57#18#64#0#157#18#64#0#191#18#64#0#199#18#64#0#144#141#64#0#144#141#64#0#144#141#64#0#144#141#64#0#106#246#255#21#57#16#64#0#163#39#19#64#0#106#5#80#255#21#61#16#64#0#106#245#255#21#57#16#64#0#163#43#19#64#0#106#3#80#255#21#61#16#64#0#137#37#210#18#64#0#255#21#73#16#64#0#163#31#19#64#0#104#28#0#64#0#104#12#0#1#0#80#255#21#77#16#64#0#163#35#19#64#0#141#160#0#0#64#0#139#236#190#251#18#64#0#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90); + OutputCodeDataSize:=1423; end; const locNone=0; diff --git a/src/egasm.exe b/src/egasm.exe new file mode 100644 index 0000000000000000000000000000000000000000..4c86047d46fdacc8c302810b7a409173b3e20659 GIT binary patch literal 445440 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 then begin + inc(k,255-(k mod 255)); + end; + for i:=0 to k-1 do begin + if length(l)=0 then begin + l:=' OutputCodeString('; + end; + if i=255 then begin + j:=0; + if length(l)>0 then begin + StringList.Add(l+');'); + end; + l:=''; + end; + end; + if length(l)>0 then begin + StringList.Add(l+');'); + end; + StringList.Add(' OutputCodeDataSize:='+IntToStr(Stream.Size)+';'); + StringList.SaveToFile('rtl.pas'); + finally + StringList.Free; + end; + finally + Stream.Free; + end; +end. From d9d6d46d83a958a27c6da3764c13a05802f8c35d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B0=D0=B7=D0=B4=D0=B0=D0=B9=D1=89=D0=B8=D0=BA?= Date: Tue, 7 Feb 2017 12:14:31 +0300 Subject: [PATCH 10/12] RTL generator written on BTPC --- src/makertl.bat | 9 ++-- src/rtl2pas.cfg | 38 -------------- src/rtl2pas.dof | 136 ------------------------------------------------ src/rtl2pas.dpr | 93 +++++++++++++++------------------ 4 files changed, 46 insertions(+), 230 deletions(-) delete mode 100644 src/rtl2pas.cfg delete mode 100644 src/rtl2pas.dof diff --git a/src/makertl.bat b/src/makertl.bat index 976c9c6..52ed07e 100644 --- a/src/makertl.bat +++ b/src/makertl.bat @@ -1,5 +1,4 @@ -@echo off -egasm +peexe +optimizejumps -gui rtl.asm -dcc32 -B rtl2pas.dpr -rtl2pas - +@echo off +egasm +peexe +optimizejumps -gui rtl.asm +..\bin\btpc.exe < rtl2pas.dpr > rtl2pas.exe +rtl2pas.exe < rtl.exe > rtl.pas diff --git a/src/rtl2pas.cfg b/src/rtl2pas.cfg deleted file mode 100644 index 4c2816a..0000000 --- a/src/rtl2pas.cfg +++ /dev/null @@ -1,38 +0,0 @@ --$A8 --$B- --$C+ --$D+ --$E- --$F- --$G+ --$H+ --$I+ --$J- --$K- --$L+ --$M- --$N+ --$O+ --$P+ --$Q- --$R- --$S- --$T- --$U- --$V+ --$W- --$X+ --$YD --$Z1 --cg --AWinTypes=Windows;WinProcs=Windows;DbiTypes=BDE;DbiProcs=BDE;DbiErrs=BDE; --H+ --W+ --M --$M16384,1048576 --K$00400000 --LE"c:\program files (x86)\borland\delphi7\Projects\Bpl" --LN"c:\program files (x86)\borland\delphi7\Projects\Bpl" --w-UNSAFE_TYPE --w-UNSAFE_CODE --w-UNSAFE_CAST diff --git a/src/rtl2pas.dof b/src/rtl2pas.dof deleted file mode 100644 index ba497dc..0000000 --- a/src/rtl2pas.dof +++ /dev/null @@ -1,136 +0,0 @@ -[FileVersion] -Version=7.0 -[Compiler] -A=8 -B=0 -C=1 -D=1 -E=0 -F=0 -G=1 -H=1 -I=1 -J=0 -K=0 -L=1 -M=0 -N=1 -O=1 -P=1 -Q=0 -R=0 -S=0 -T=0 -U=0 -V=1 -W=0 -X=1 -Y=1 -Z=1 -ShowHints=1 -ShowWarnings=1 -UnitAliases=WinTypes=Windows;WinProcs=Windows;DbiTypes=BDE;DbiProcs=BDE;DbiErrs=BDE; -NamespacePrefix= -SymbolDeprecated=1 -SymbolLibrary=1 -SymbolPlatform=1 -UnitLibrary=1 -UnitPlatform=1 -UnitDeprecated=1 -HResultCompat=1 -HidingMember=1 -HiddenVirtual=1 -Garbage=1 -BoundsError=1 -ZeroNilCompat=1 -StringConstTruncated=1 -ForLoopVarVarPar=1 -TypedConstVarPar=1 -AsgToTypedConst=1 -CaseLabelRange=1 -ForVariable=1 -ConstructingAbstract=1 -ComparisonFalse=1 -ComparisonTrue=1 -ComparingSignedUnsigned=1 -CombiningSignedUnsigned=1 -UnsupportedConstruct=1 -FileOpen=1 -FileOpenUnitSrc=1 -BadGlobalSymbol=1 -DuplicateConstructorDestructor=1 -InvalidDirective=1 -PackageNoLink=1 -PackageThreadVar=1 -ImplicitImport=1 -HPPEMITIgnored=1 -NoRetVal=1 -UseBeforeDef=1 -ForLoopVarUndef=1 -UnitNameMismatch=1 -NoCFGFileFound=1 -MessageDirective=1 -ImplicitVariants=1 -UnicodeToLocale=1 -LocaleToUnicode=1 -ImagebaseMultiple=1 -SuspiciousTypecast=1 -PrivatePropAccessor=1 -UnsafeType=0 -UnsafeCode=0 -UnsafeCast=0 -[Linker] -MapFile=0 -OutputObjs=0 -ConsoleApp=1 -DebugInfo=0 -RemoteSymbols=0 -MinStackSize=16384 -MaxStackSize=1048576 -ImageBase=4194304 -ExeDescription= -[Directories] -OutputDir= -UnitOutputDir= -PackageDLLOutputDir= -PackageDCPOutputDir= -SearchPath= -Packages= -Conditionals= -DebugSourceDirs= -UsePackages=0 -[Parameters] -RunParams= -HostApplication= -Launcher= -UseLauncher=0 -DebugCWD= -[Language] -ActiveLang= -ProjectLang= -RootDir= -[Version Info] -IncludeVerInfo=0 -AutoIncBuild=0 -MajorVer=1 -MinorVer=0 -Release=0 -Build=0 -Debug=0 -PreRelease=0 -Special=0 -Private=0 -DLL=0 -Locale=1031 -CodePage=1252 -[Version Info Keys] -CompanyName= -FileDescription= -FileVersion=1.0.0.0 -InternalName= -LegalCopyright= -LegalTrademarks= -OriginalFilename= -ProductName= -ProductVersion=1.0.0.0 -Comments= diff --git a/src/rtl2pas.dpr b/src/rtl2pas.dpr index 9c8a42e..4a11a3e 100644 --- a/src/rtl2pas.dpr +++ b/src/rtl2pas.dpr @@ -1,51 +1,42 @@ -program rtl2pas; -uses SysUtils,Classes; -const Signature:array[0..7] of ansichar='BeRo^fr'; -var Stream:TMemoryStream; - StringList:TStringList; - i,j,k:longint; - l:ansistring; -begin - Stream:=TMemoryStream.Create; - try - Stream.LoadFromFile('rtl.exe'); - Move(Signature[0],PAnsiChar(Stream.Memory)[4],SizeOf(Signature)); - StringList:=TStringList.Create; - try - StringList.Add(' OutputCodeDataSize:=0;'); - l:=''; - j:=0; - k:=Stream.Size; - if (k mod 255)<>0 then begin - inc(k,255-(k mod 255)); - end; - for i:=0 to k-1 do begin - if length(l)=0 then begin - l:=' OutputCodeString('; - end; - if i=255 then begin - j:=0; - if length(l)>0 then begin - StringList.Add(l+');'); - end; - l:=''; - end; - end; - if length(l)>0 then begin - StringList.Add(l+');'); - end; - StringList.Add(' OutputCodeDataSize:='+IntToStr(Stream.Size)+';'); - StringList.SaveToFile('rtl.pas'); - finally - StringList.Free; - end; - finally - Stream.Free; - end; -end. +program rtl2pas; + +const LineLen=255; + SigStart=4; + SigLen=7; + +type TSignature = array[1..SigLen] of char; + +procedure MakeRtl(sig: TSignature); +var CurChar: char; + j, datasize: integer; +begin + writeln(' OutputCodeDataSize:=0;'); + j:=0; + while not EOF do begin + if (j mod LineLen) = 0 then begin + write(' OutputCodeString('); + end; + read(CurChar); + if (SigStart <= j) and (j < SigStart + SigLen) then begin + write('#', ord(sig[j - SigStart + 1])); + end else begin + write('#', ord(CurChar)); + end; + j:=j+1; + if (j mod LineLen) = 0 then begin + writeln(');'); + end; + end; + + datasize:=j; + while (j mod LineLen) <> 0 do begin + write('#$90'); + j:=j+1; + end; + writeln(');'); + writeln(' OutputCodeDataSize:=', datasize, ';'); +end; + +begin + MakeRtl('BeRo^fr'); +end. From 48e34f7fb444114e3de2865e51709d608c3052da Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B0=D0=B7=D0=B4=D0=B0=D0=B9=D1=89=D0=B8=D0=BA?= Date: Tue, 7 Feb 2017 12:34:02 +0300 Subject: [PATCH 11/12] Split very long lines in source (>120 columns) --- src/btpc.dpr | 96 +++++++++++++++++++++++++++++++++++++++++-------- src/rtl2pas.dpr | 2 +- 2 files changed, 82 insertions(+), 16 deletions(-) diff --git a/src/btpc.dpr b/src/btpc.dpr index 849d536..6525b4a 100644 --- a/src/btpc.dpr +++ b/src/btpc.dpr @@ -626,7 +626,10 @@ begin end; if (('a'<=CurrentChar) and (CurrentChar<='z')) or (('A'<=CurrentChar) and (CurrentChar<='Z')) then begin k:=0; - while ((('a'<=CurrentChar) and (CurrentChar<='z')) or (('A'<=CurrentChar) and (CurrentChar<='Z')) or (('0'<=CurrentChar) and (CurrentChar<='9'))) or (CurrentChar='_') do begin + while ((('a'<=CurrentChar) and (CurrentChar<='z')) or + (('A'<=CurrentChar) and (CurrentChar<='Z')) or + (('0'<=CurrentChar) and (CurrentChar<='9'))) or + (CurrentChar='_') do begin if k<>MaximalAlfa then begin k:=k+1; if ('a'<=CurrentChar) and (CurrentChar<='z') then begin @@ -968,7 +971,10 @@ end; procedure MustBe(x,y:integer); begin if x<>y then begin - if (Types[x].Kind=KindARRAY) and (Types[y].Kind=KindARRAY) and (Types[x].StartIndex=Types[y].StartIndex) and (Types[x].EndIndex=Types[y].EndIndex) then begin + if (Types[x].Kind=KindARRAY) and + (Types[y].Kind=KindARRAY) and + (Types[x].StartIndex=Types[y].StartIndex) and + (Types[x].EndIndex=Types[y].EndIndex) then begin MustBe(Types[x].SubType,Types[y].SubType); end else begin Error(107); @@ -1162,7 +1168,9 @@ begin if Types[Identifiers[p].TypeDefinition].SubType<>TypeCHAR then begin Error(116); end; - if ((Types[Identifiers[p].TypeDefinition].EndIndex-Types[Identifiers[p].TypeDefinition].StartIndex)+1)<>CurrentStringLength then begin + if ((Types[Identifiers[p].TypeDefinition].EndIndex + -Types[Identifiers[p].TypeDefinition].StartIndex)+1) + <>CurrentStringLength then begin Error(117); end; end else begin @@ -1326,7 +1334,9 @@ procedure Expression(var x:integer); var o,y:integer; begin SimpleExpression(x); - if (CurrentSymbol=TokEql) or (CurrentSymbol=TokNEq) or (CurrentSymbol=TokLss) or (CurrentSymbol=TokLEq) or (CurrentSymbol=TokGtr) or (CurrentSymbol=TokGEq) then begin + if (CurrentSymbol=TokEql) or (CurrentSymbol=TokNEq) or + (CurrentSymbol=TokLss) or (CurrentSymbol=TokLEq) or + (CurrentSymbol=TokGtr) or (CurrentSymbol=TokGEq) then begin if (x=TypeSTR) or (Types[x].Kind<>KindSIMPLE) then begin Error(150); end; @@ -1903,7 +1913,8 @@ var i,d,OldStackPosition,OldIdentPos:integer; begin OldStackPosition:=StackPosition; OldIdentPos:=IdentifierPosition; - while (CurrentSymbol=SymCONST) or (CurrentSymbol=SymTYPE) or (CurrentSymbol=SymVAR) or (CurrentSymbol=SymFUNC) or (CurrentSymbol=SymPROC) do begin + while (CurrentSymbol=SymCONST) or (CurrentSymbol=SymTYPE) or + (CurrentSymbol=SymVAR) or (CurrentSymbol=SymFUNC) or (CurrentSymbol=SymPROC) do begin if CurrentSymbol=SymCONST then begin GetSymbol; Check(TokIdent); @@ -2004,9 +2015,13 @@ end; function OutputCodeGetInt32(o:integer):integer; begin if ord(OutputCodeData[o+3])<$80 then begin - OutputCodeGetInt32:=ord(OutputCodeData[o])+(ord(OutputCodeData[o+1])*256)+(ord(OutputCodeData[o+2])*65536)+(ord(OutputCodeData[o+3])*16777216); + OutputCodeGetInt32:= ord(OutputCodeData[o])+(ord(OutputCodeData[o+1])*256) + +(ord(OutputCodeData[o+2])*65536)+(ord(OutputCodeData[o+3])*16777216); end else begin - OutputCodeGetInt32:=-(((255-ord(OutputCodeData[o]))+((255-ord(OutputCodeData[o+1]))*256)+((255-ord(OutputCodeData[o+2]))*65536)+((255-ord(OutputCodeData[o+3]))*16777216))+1); + OutputCodeGetInt32:=-(((255-ord(OutputCodeData[o])) + +((255-ord(OutputCodeData[o+1]))*256) + +((255-ord(OutputCodeData[o+2]))*65536) + +((255-ord(OutputCodeData[o+3]))*16777216))+1); end; end; @@ -2034,12 +2049,12 @@ begin end; end; -type TOutputCodeString=array[1..255] of char; +type TOutputCodeString=array[1..25] of char; procedure OutputCodeString(s:TOutputCodeString); var i:integer; begin - for i:=1 to 255 do begin + for i:=1 to 25 do begin EmitChar(s[i]); end; end; @@ -2047,12 +2062,63 @@ end; procedure EmitStubCode; begin OutputCodeDataSize:=0; - OutputCodeString(#77#90#82#195#66#101#82#111#94#102#114#0#80#69#0#0#76#1#1#0#0#0#0#0#0#0#0#0#0#0#0#0#224#0#15#3#11#1#0#0#143#3#0#0#0#0#0#0#0#0#0#0#196#16#0#0#0#16#0#0#12#0#0#0#0#0#64#0#0#16#0#0#0#2#0#0#4#0#0#0#0#0#0#0#4#0#0#0#0#0#0#0#0#32#0#0#0#2#0#0#0#0#0#0#3#0#0#0#0#0#16#0#0#32#0#0#0#0#16#0#0#32#0#0#0#0#0#0#16#0#0#0#0#0#0#0#0#0#0#0#0#16#0#0#196#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0); - OutputCodeString(#0#0#0#0#0#0#0#0#0#0#0#0#0#0#16#0#0#0#16#0#0#143#3#0#0#0#2#0#0#0#0#0#0#0#0#0#0#0#0#0#0#32#0#0#224#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0); - OutputCodeString(#0#0#0#0#0#0#0#0#0#0#255#255#255#255#40#16#0#0#53#16#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#107#101#114#110#101#108#51#50#46#100#108#108#0#87#16#0#0#101#16#0#0#116#16#0#0#133#16#0#0#145#16#0#0#156#16#0#0#173#16#0#0#185#16#0#0#0#0#0#0#69#120#105#116#80#114#111#99#101#115#115#0#0#0#71#101#116#83#116#100#72#97#110#100#108#101#0#0#0#83#101#116#67#111#110#115#111#108#101#77#111#100#101#0#0#0#87#114#105#116#101#70#105#108#101#0#0#0#82#101#97#100#70#105#108#101#0#0#0#71#101#116#80#114#111#99#101#115#115#72#101#97#112#0#0#0#72#101#97#112#65#108#108#111#99#0#0#0#72#101#97#112#70#114#101#101#0#233#102#2#0#0#32#67#111#109#112#105#108#101#100#32#98#121#58#32#66#101#82#111#84#105#110#121#80#97#115#99#97#108#32#45#32#40#67#41#32#67#111#112#121#114#105#103#104#116#32#50#48#48#54#44#32#66); - OutputCodeString(#101#110#106#97#109#105#110#32#39#66#101#82#111#39#32#82#111#115#115#101#97#117#120#32#144#141#64#0#86#141#116#36#8#96#106#0#104#21#17#64#0#106#1#86#255#53#43#19#64#0#255#21#65#16#64#0#97#94#194#4#0#144#141#64#0#144#141#64#0#144#141#64#0#86#139#92#36#8#139#68#36#12#131#248#0#125#10#247#216#75#106#45#232#187#255#255#255#51#201#80#83#133#192#116#12#65#187#10#0#0#0#51#210#247#251#235#240#133#201#15#148#210#10#202#91#88#43#217#131#251#0#126#12#81#106#32#232#143#255#255#255#75#117#246#89#141#185#57#17#64#0#81#190#10#0#0#0#51#210#247#254#141#90#48#136#31#79#226#239#89#106#0#104#21#17#64#0#81#104#58#17#64#0#255#53#43#19#64#0#255#21#65#16#64#0#94#194#8#0#106#13#232#78#255#255#255#106#10#232#71#255#255#255#195#144#144#141#64#0#96#106#0#104#212#17#64#0#106#1#104#211#17#64#0#255#53#39#19#64#0#255#21#69#16#64#0#133#192#15#148#208#8#5#190#18); - OutputCodeString(#64#0#131#61#212#17#64#0#0#15#148#208#8#5#190#18#64#0#97#195#0#128#61#16#18#64#0#0#117#12#232#185#255#255#255#198#5#16#18#64#0#1#195#232#229#255#255#255#15#182#5#211#17#64#0#232#160#255#255#255#195#232#211#255#255#255#96#51#192#141#72#1#128#61#190#18#64#0#0#117#72#128#61#211#17#64#0#0#116#16#128#61#211#17#64#0#32#119#7#232#116#255#255#255#235#222#128#61#211#17#64#0#45#117#7#247#217#232#98#255#255#255#15#182#29#211#17#64#0#128#251#48#114#19#128#251#57#119#14#107#192#10#141#68#24#208#232#69#255#255#255#235#225#247#233#137#68#36#28#97#195#232#111#255#255#255#128#61#190#18#64#0#0#117#18#138#29#211#17#64#0#128#251#10#116#7#232#29#255#255#255#235#224#195#0#15#182#5#190#18#64#0#195#128#61#211#17#64#0#10#15#148#210#195#144#141#64#0#139#37#210#18#64#0#255#53#35#19#64#0#104#0#0#0#0#255#53#31#19#64#0#255#21#81#16#64#0#106#0#255#21#53#16#64#0); - OutputCodeString(#214#18#64#0#25#17#64#0#70#17#64#0#196#17#64#0#39#18#64#0#57#18#64#0#157#18#64#0#191#18#64#0#199#18#64#0#144#141#64#0#144#141#64#0#144#141#64#0#144#141#64#0#106#246#255#21#57#16#64#0#163#39#19#64#0#106#5#80#255#21#61#16#64#0#106#245#255#21#57#16#64#0#163#43#19#64#0#106#3#80#255#21#61#16#64#0#137#37#210#18#64#0#255#21#73#16#64#0#163#31#19#64#0#104#28#0#64#0#104#12#0#1#0#80#255#21#77#16#64#0#163#35#19#64#0#141#160#0#0#64#0#139#236#190#251#18#64#0#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90#$90); + OutputCodeString(#77#90#82#195#66#101#82#111#94#102#114#0#80#69#0#0#76#1#1#0#0#0#0#0#0); + OutputCodeString(#0#0#0#0#0#0#0#224#0#15#3#11#1#0#0#143#3#0#0#0#0#0#0#0#0); + OutputCodeString(#0#0#196#16#0#0#0#16#0#0#12#0#0#0#0#0#64#0#0#16#0#0#0#2#0); + OutputCodeString(#0#4#0#0#0#0#0#0#0#4#0#0#0#0#0#0#0#0#32#0#0#0#2#0#0); + OutputCodeString(#0#0#0#0#3#0#0#0#0#0#16#0#0#32#0#0#0#0#16#0#0#32#0#0#0); + OutputCodeString(#0#0#0#16#0#0#0#0#0#0#0#0#0#0#0#0#16#0#0#196#0#0#0#0#0); + OutputCodeString(#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0); + OutputCodeString(#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0); + OutputCodeString(#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0); + OutputCodeString(#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0); + OutputCodeString(#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#16#0#0#0#16#0); + OutputCodeString(#0#143#3#0#0#0#2#0#0#0#0#0#0#0#0#0#0#0#0#0#0#32#0#0#224); + OutputCodeString(#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0); + OutputCodeString(#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0); + OutputCodeString(#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0); + OutputCodeString(#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0); + OutputCodeString(#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0); + OutputCodeString(#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0); + OutputCodeString(#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0); + OutputCodeString(#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0); + OutputCodeString(#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#255#255#255#255#40); + OutputCodeString(#16#0#0#53#16#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0); + OutputCodeString(#0#0#107#101#114#110#101#108#51#50#46#100#108#108#0#87#16#0#0#101#16#0#0#116#16); + OutputCodeString(#0#0#133#16#0#0#145#16#0#0#156#16#0#0#173#16#0#0#185#16#0#0#0#0#0); + OutputCodeString(#0#69#120#105#116#80#114#111#99#101#115#115#0#0#0#71#101#116#83#116#100#72#97#110#100); + OutputCodeString(#108#101#0#0#0#83#101#116#67#111#110#115#111#108#101#77#111#100#101#0#0#0#87#114#105); + OutputCodeString(#116#101#70#105#108#101#0#0#0#82#101#97#100#70#105#108#101#0#0#0#71#101#116#80#114); + OutputCodeString(#111#99#101#115#115#72#101#97#112#0#0#0#72#101#97#112#65#108#108#111#99#0#0#0#72); + OutputCodeString(#101#97#112#70#114#101#101#0#233#102#2#0#0#32#67#111#109#112#105#108#101#100#32#98#121); + OutputCodeString(#58#32#66#101#82#111#84#105#110#121#80#97#115#99#97#108#32#45#32#40#67#41#32#67#111); + OutputCodeString(#112#121#114#105#103#104#116#32#50#48#48#54#44#32#66#101#110#106#97#109#105#110#32#39#66); + OutputCodeString(#101#82#111#39#32#82#111#115#115#101#97#117#120#32#144#141#64#0#86#141#116#36#8#96#106); + OutputCodeString(#0#104#21#17#64#0#106#1#86#255#53#43#19#64#0#255#21#65#16#64#0#97#94#194#4); + OutputCodeString(#0#144#141#64#0#144#141#64#0#144#141#64#0#86#139#92#36#8#139#68#36#12#131#248#0); + OutputCodeString(#125#10#247#216#75#106#45#232#187#255#255#255#51#201#80#83#133#192#116#12#65#187#10#0#0); + OutputCodeString(#0#51#210#247#251#235#240#133#201#15#148#210#10#202#91#88#43#217#131#251#0#126#12#81#106); + OutputCodeString(#32#232#143#255#255#255#75#117#246#89#141#185#57#17#64#0#81#190#10#0#0#0#51#210#247); + OutputCodeString(#254#141#90#48#136#31#79#226#239#89#106#0#104#21#17#64#0#81#104#58#17#64#0#255#53); + OutputCodeString(#43#19#64#0#255#21#65#16#64#0#94#194#8#0#106#13#232#78#255#255#255#106#10#232#71); + OutputCodeString(#255#255#255#195#144#144#141#64#0#96#106#0#104#212#17#64#0#106#1#104#211#17#64#0#255); + OutputCodeString(#53#39#19#64#0#255#21#69#16#64#0#133#192#15#148#208#8#5#190#18#64#0#131#61#212); + OutputCodeString(#17#64#0#0#15#148#208#8#5#190#18#64#0#97#195#0#128#61#16#18#64#0#0#117#12); + OutputCodeString(#232#185#255#255#255#198#5#16#18#64#0#1#195#232#229#255#255#255#15#182#5#211#17#64#0); + OutputCodeString(#232#160#255#255#255#195#232#211#255#255#255#96#51#192#141#72#1#128#61#190#18#64#0#0#117); + OutputCodeString(#72#128#61#211#17#64#0#0#116#16#128#61#211#17#64#0#32#119#7#232#116#255#255#255#235); + OutputCodeString(#222#128#61#211#17#64#0#45#117#7#247#217#232#98#255#255#255#15#182#29#211#17#64#0#128); + OutputCodeString(#251#48#114#19#128#251#57#119#14#107#192#10#141#68#24#208#232#69#255#255#255#235#225#247#233); + OutputCodeString(#137#68#36#28#97#195#232#111#255#255#255#128#61#190#18#64#0#0#117#18#138#29#211#17#64); + OutputCodeString(#0#128#251#10#116#7#232#29#255#255#255#235#224#195#0#15#182#5#190#18#64#0#195#128#61); + OutputCodeString(#211#17#64#0#10#15#148#210#195#144#141#64#0#139#37#210#18#64#0#255#53#35#19#64#0); + OutputCodeString(#104#0#0#0#0#255#53#31#19#64#0#255#21#81#16#64#0#106#0#255#21#53#16#64#0); + OutputCodeString(#214#18#64#0#25#17#64#0#70#17#64#0#196#17#64#0#39#18#64#0#57#18#64#0#157); + OutputCodeString(#18#64#0#191#18#64#0#199#18#64#0#144#141#64#0#144#141#64#0#144#141#64#0#144#141); + OutputCodeString(#64#0#106#246#255#21#57#16#64#0#163#39#19#64#0#106#5#80#255#21#61#16#64#0#106); + OutputCodeString(#245#255#21#57#16#64#0#163#43#19#64#0#106#3#80#255#21#61#16#64#0#137#37#210#18); + OutputCodeString(#64#0#255#21#73#16#64#0#163#31#19#64#0#104#28#0#64#0#104#12#0#1#0#80#255); + OutputCodeString(#21#77#16#64#0#163#35#19#64#0#141#160#0#0#64#0#139#236#190#251#18#64#0#$90#$90); OutputCodeDataSize:=1423; end; diff --git a/src/rtl2pas.dpr b/src/rtl2pas.dpr index 4a11a3e..89f1e92 100644 --- a/src/rtl2pas.dpr +++ b/src/rtl2pas.dpr @@ -1,6 +1,6 @@ program rtl2pas; -const LineLen=255; +const LineLen=25; SigStart=4; SigLen=7; From 61ca8483d6f5153a30b0903dfd9dbbb5d43569b1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B0=D0=B7=D0=B4=D0=B0=D0=B9=D1=89=D0=B8=D0=BA?= Date: Tue, 7 Feb 2017 12:46:20 +0300 Subject: [PATCH 12/12] Update main executable --- bin/btpc.exe | Bin 53567 -> 53622 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/bin/btpc.exe b/bin/btpc.exe index 6e2d963d8cdac5d87e4d39fb75d80f9c32869652..9da1bd2d5f5de6efddb4ff4900e621c15d57849f 100644 GIT binary patch delta 3962 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 aGgirPP#qd?KJ*jW6e7#p@I59i(EJDfL{^yq