belka/elna
1
0
Fork 0
Code Issues 5 Pull Requests Releases Activity

Make procedure name after the end

Browse Source
This commit is contained in:
Eugen Wissner
2025-05-29 14:59:56 +02:00
parent 192e7e40c8
commit 4c47a5f466
4 changed files with 89 additions and 57 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
Rakefile
View File

@ -98,8 +98,10 @@ task :backport do
FileList['source/*.elna'].each do |file| FileList['source/*.elna'].each do |file|
source_path = Pathname.new file source_path = Pathname.new file
source = File.read source_path source = File.read source_path
current_procedure = nil
target = ''
target = source source
.gsub(/^(var|type|const|begin)/) { |match| match.upcase } .gsub(/^(var|type|const|begin)/) { |match| match.upcase }
.gsub(/^[[:alnum:]]* ?module/) { |match| match.upcase } .gsub(/^[[:alnum:]]* ?module/) { |match| match.upcase }
.gsub(/\brecord\b/) { |match| match.upcase } .gsub(/\brecord\b/) { |match| match.upcase }
@ -109,8 +111,20 @@ task :backport do
.gsub(/^from ([[:alnum:]]+) import/, 'FROM \1 IMPORT') .gsub(/^from ([[:alnum:]]+) import/, 'FROM \1 IMPORT')
.gsub(/ \^([[:alnum:]])/, ' POINTER TO \1') .gsub(/ \^([[:alnum:]])/, ' POINTER TO \1')
.gsub(/(then|do)$/) { |match| match.upcase } .gsub(/(then|do)$/) { |match| match.upcase }
.each_line do |line|
if line.start_with? 'PROCEDURE'
current_procedure = line[10...line.index('(')]
elsif line.start_with?('END;') && !current_procedure.nil?
line = "END #{current_procedure};"
current_proceure = nil
end
target += line
end
target_path = Pathname.new('boot/stage1/source') + source_path.basename target_path = Pathname.new('boot/stage1/source') + source_path.basename
File.write target_path, target File.write target_path, target
end end
FileList['source/*.def'].each do |file|
cp file, File.join('boot/stage1/source', Pathname.new(file).basename)
end
end end

3
source/Lexer.def
View File

@ -80,7 +80,8 @@ TYPE
); );
LexerToken = RECORD LexerToken = RECORD
CASE Kind: LexerKind OF CASE Kind: LexerKind OF
lexerKindBoolean: booleanKind: BOOLEAN lexerKindBoolean: booleanKind: BOOLEAN |
lexerKindIdentifier: identifierKind: ARRAY[1..256] OF CHAR
END END
END; END;
PLexerToken = POINTER TO LexerToken; PLexerToken = POINTER TO LexerToken;

39
source/Lexer.elna
View File

@ -5,7 +5,7 @@ from SYSTEM import ADR;
from Storage import DEALLOCATE, ALLOCATE; from Storage import DEALLOCATE, ALLOCATE;
from Strings import Length; from Strings import Length;
from MemUtils import MemZero; from MemUtils import MemCopy, MemZero;
from StrCase import Lower; from StrCase import Lower;
const const
@ -200,7 +200,7 @@ begin
Classification[126] := transitionClassOther; (* } *) Classification[126] := transitionClassOther; (* } *)
Classification[127] := transitionClassSingle; (* ~ *) Classification[127] := transitionClassSingle; (* ~ *)
Classification[128] := transitionClassInvalid (* DEL *) Classification[128] := transitionClassInvalid (* DEL *)
END InitializeClassification; end;
proc CompareKeyword(Keyword: ARRAY OF CHAR; TokenStart: PLexerBuffer; TokenEnd: PLexerBuffer): BOOLEAN; proc CompareKeyword(Keyword: ARRAY OF CHAR; TokenStart: PLexerBuffer; TokenEnd: PLexerBuffer): BOOLEAN;
var var
@ -217,19 +217,19 @@ begin
end; end;
Result := (Index = Length(Keyword)) AND (TokenStart = TokenEnd) AND Result; Result := (Index = Length(Keyword)) AND (TokenStart = TokenEnd) AND Result;
return Result return Result
END CompareKeyword; end;
(* Reached the end of file. *) (* Reached the end of file. *)
proc TransitionActionEof(ALexer: PLexer; AToken: PLexerToken); proc TransitionActionEof(ALexer: PLexer; AToken: PLexerToken);
begin begin
AToken^.Kind := lexerKindEof AToken^.Kind := lexerKindEof
END TransitionActionEof; end;
(* Add the character to the token currently read and advance to the next character. *) (* Add the character to the token currently read and advance to the next character. *)
proc TransitionActionAccumulate(ALexer: PLexer; AToken: PLexerToken); proc TransitionActionAccumulate(ALexer: PLexer; AToken: PLexerToken);
begin begin
INC(ALexer^.Current) INC(ALexer^.Current)
END TransitionActionAccumulate; end;
(* The current character is not a part of the token. Finish the token already (* The current character is not a part of the token. Finish the token already
* read. Don't advance to the next character. *) * read. Don't advance to the next character. *)
@ -253,7 +253,7 @@ begin
if ALexer^.Start^ = '.' then if ALexer^.Start^ = '.' then
AToken^.Kind := lexerKindDot AToken^.Kind := lexerKindDot
end end
END TransitionActionFinalize; end;
(* An action for tokens containing multiple characters. *) (* An action for tokens containing multiple characters. *)
proc TransitionActionComposite(ALexer: PLexer; AToken: PLexerToken); proc TransitionActionComposite(ALexer: PLexer; AToken: PLexerToken);
@ -276,14 +276,14 @@ begin
AToken^.Kind := lexerKindAssignment AToken^.Kind := lexerKindAssignment
end; end;
INC(ALexer^.Current) INC(ALexer^.Current)
END TransitionActionComposite; end;
(* Skip a space. *) (* Skip a space. *)
proc TransitionActionSkip(ALexer: PLexer; AToken: PLexerToken); proc TransitionActionSkip(ALexer: PLexer; AToken: PLexerToken);
begin begin
INC(ALexer^.Current); INC(ALexer^.Current);
INC(ALexer^.Start) INC(ALexer^.Start)
END TransitionActionSkip; end;
(* Delimited string action. *) (* Delimited string action. *)
proc TransitionActionDelimited(ALexer: PLexer; AToken: PLexerToken); proc TransitionActionDelimited(ALexer: PLexer; AToken: PLexerToken);
@ -298,13 +298,16 @@ begin
AToken^.Kind := lexerKindString AToken^.Kind := lexerKindString
end; end;
INC(ALexer^.Current) INC(ALexer^.Current)
END TransitionActionDelimited; end;
(* Finalize keyword or identifier. *) (* Finalize keyword or identifier. *)
proc TransitionActionKeyId(ALexer: PLexer; AToken: PLexerToken); proc TransitionActionKeyId(ALexer: PLexer; AToken: PLexerToken);
begin begin
AToken^.Kind := lexerKindIdentifier; AToken^.Kind := lexerKindIdentifier;
AToken^.identifierKind[1] := ALexer^.Current - ALexer^.Start;
MemCopy(ALexer^.Start, ORD(AToken^.identifierKind[1]), ADR(AToken^.identifierKind[2]));
if CompareKeyword('PROGRAM', ALexer^.Start, ALexer^.Current) then if CompareKeyword('PROGRAM', ALexer^.Start, ALexer^.Current) then
AToken^.Kind := lexerKindProgram AToken^.Kind := lexerKindProgram
end; end;
@ -400,7 +403,7 @@ begin
AToken^.Kind := lexerKindBoolean; AToken^.Kind := lexerKindBoolean;
AToken^.booleanKind := FALSE AToken^.booleanKind := FALSE
end end
END TransitionActionKeyId; end;
(* Action for tokens containing only one character. The character cannot be (* Action for tokens containing only one character. The character cannot be
* followed by other characters forming a composite token. *) * followed by other characters forming a composite token. *)
@ -449,13 +452,13 @@ begin
AToken^.Kind := lexerKindPipe AToken^.Kind := lexerKindPipe
end; end;
INC(ALexer^.Current) INC(ALexer^.Current)
END TransitionActionSingle; end;
(* Handle an integer literal. *) (* Handle an integer literal. *)
proc TransitionActionInteger(ALexer: PLexer; AToken: PLexerToken); proc TransitionActionInteger(ALexer: PLexer; AToken: PLexerToken);
begin begin
AToken^.Kind := lexerKindInteger AToken^.Kind := lexerKindInteger
END TransitionActionInteger; end;
proc SetDefaultTransition(CurrentState: TransitionState; DefaultAction: TransitionAction; NextState: TransitionState); proc SetDefaultTransition(CurrentState: TransitionState; DefaultAction: TransitionAction; NextState: TransitionState);
var var
@ -486,7 +489,7 @@ begin
Transitions[ORD(CurrentState)][ORD(transitionClassGreater)] := DefaultTransition; Transitions[ORD(CurrentState)][ORD(transitionClassGreater)] := DefaultTransition;
Transitions[ORD(CurrentState)][ORD(transitionClassLess)] := DefaultTransition; Transitions[ORD(CurrentState)][ORD(transitionClassLess)] := DefaultTransition;
Transitions[ORD(CurrentState)][ORD(transitionClassOther)] := DefaultTransition Transitions[ORD(CurrentState)][ORD(transitionClassOther)] := DefaultTransition
END SetDefaultTransition; end;
(* (*
* The transition table describes transitions from one state to another, given * The transition table describes transitions from one state to another, given
@ -740,7 +743,7 @@ begin
Transitions[ORD(transitionStateDecimalSuffix)][ORD(transitionClassX)].Action := NIL; Transitions[ORD(transitionStateDecimalSuffix)][ORD(transitionClassX)].Action := NIL;
Transitions[ORD(transitionStateDecimalSuffix)][ORD(transitionClassX)].NextState := transitionStateEnd Transitions[ORD(transitionStateDecimalSuffix)][ORD(transitionClassX)].NextState := transitionStateEnd
END InitializeTransitions; end;
proc LexerInitialize(ALexer: PLexer; Input: File); proc LexerInitialize(ALexer: PLexer; Input: File);
begin begin
@ -750,7 +753,7 @@ begin
ALLOCATE(ALexer^.Buffer, ChunkSize); ALLOCATE(ALexer^.Buffer, ChunkSize);
MemZero(ALexer^.Buffer, ChunkSize); MemZero(ALexer^.Buffer, ChunkSize);
ALexer^.Size := ChunkSize ALexer^.Size := ChunkSize
END LexerInitialize; end;
proc LexerCurrent(ALexer: PLexer): LexerToken; proc LexerCurrent(ALexer: PLexer): LexerToken;
var var
@ -772,7 +775,7 @@ begin
CurrentState := CurrentTransition.NextState CurrentState := CurrentTransition.NextState
end; end;
return Result return Result
END LexerCurrent; end;
proc LexerLex(ALexer: PLexer): LexerToken; proc LexerLex(ALexer: PLexer): LexerToken;
var var
@ -786,12 +789,12 @@ begin
Result := LexerCurrent(ALexer); Result := LexerCurrent(ALexer);
return Result return Result
END LexerLex; end;
proc LexerDestroy(ALexer: PLexer); proc LexerDestroy(ALexer: PLexer);
begin begin
DEALLOCATE(ALexer^.Buffer, ALexer^.Size) DEALLOCATE(ALexer^.Buffer, ALexer^.Size)
END LexerDestroy; end;
BEGIN BEGIN
InitializeClassification(); InitializeClassification();

88
source/Transpiler.elna
View File

@ -24,14 +24,14 @@ begin
end; end;
return Result return Result
END TranspilerLex; end;
(* Write a semicolon followed by a newline. *) (* Write a semicolon followed by a newline. *)
proc WriteSemicolon(); proc WriteSemicolon();
begin begin
WriteString(';'); WriteString(';');
WriteLn() WriteLn()
END WriteSemicolon; end;
proc TranspileImport(AContext: PTranspilerContext; ALexer: PLexer); proc TranspileImport(AContext: PTranspilerContext; ALexer: PLexer);
var var
@ -58,7 +58,7 @@ begin
end; end;
WriteSemicolon(); WriteSemicolon();
Token := TranspilerLex(ALexer) Token := TranspilerLex(ALexer)
END TranspileImport; end;
proc TranspileImportPart(AContext: PTranspilerContext; ALexer: PLexer); proc TranspileImportPart(AContext: PTranspilerContext; ALexer: PLexer);
var var
@ -71,7 +71,7 @@ begin
Token := LexerCurrent(ALexer) Token := LexerCurrent(ALexer)
end; end;
WriteLn() WriteLn()
END TranspileImportPart; end;
proc TranspileConstant(AContext: PTranspilerContext; ALexer: PLexer); proc TranspileConstant(AContext: PTranspilerContext; ALexer: PLexer);
var var
@ -90,7 +90,7 @@ begin
Token := TranspilerLex(ALexer); Token := TranspilerLex(ALexer);
WriteSemicolon() WriteSemicolon()
END TranspileConstant; end;
proc TranspileConstantPart(AContext: PTranspilerContext; ALexer: PLexer): BOOLEAN; proc TranspileConstantPart(AContext: PTranspilerContext; ALexer: PLexer): BOOLEAN;
var var
@ -111,7 +111,7 @@ begin
end end
end; end;
return Result return Result
END TranspileConstantPart; end;
proc TranspileModule(AContext: PTranspilerContext; ALexer: PLexer); proc TranspileModule(AContext: PTranspilerContext; ALexer: PLexer);
var var
@ -157,7 +157,7 @@ begin
Token := TranspilerLex(ALexer) Token := TranspilerLex(ALexer)
end end
END TranspileModule; end;
proc TranspileTypeFields(AContext: PTranspilerContext; ALexer: PLexer); proc TranspileTypeFields(AContext: PTranspilerContext; ALexer: PLexer);
var var
@ -180,7 +180,7 @@ begin
end; end;
WriteLn() WriteLn()
end end
END TranspileTypeFields; end;
proc TranspileRecordType(AContext: PTranspilerContext; ALexer: PLexer); proc TranspileRecordType(AContext: PTranspilerContext; ALexer: PLexer);
var var
@ -190,7 +190,7 @@ begin
WriteLn(); WriteLn();
TranspileTypeFields(AContext, ALexer); TranspileTypeFields(AContext, ALexer);
WriteString(' END') WriteString(' END')
END TranspileRecordType; end;
proc TranspilePointerType(AContext: PTranspilerContext; ALexer: PLexer); proc TranspilePointerType(AContext: PTranspilerContext; ALexer: PLexer);
var var
@ -203,7 +203,7 @@ begin
Token := TranspilerLex(ALexer) Token := TranspilerLex(ALexer)
end; end;
TranspileTypeExpression(AContext, ALexer) TranspileTypeExpression(AContext, ALexer)
END TranspilePointerType; end;
proc TranspileArrayType(AContext: PTranspilerContext; ALexer: PLexer); proc TranspileArrayType(AContext: PTranspilerContext; ALexer: PLexer);
var var
@ -227,7 +227,7 @@ begin
end; end;
WriteString(' OF '); WriteString(' OF ');
TranspileTypeExpression(AContext, ALexer) TranspileTypeExpression(AContext, ALexer)
END TranspileArrayType; end;
proc TranspileEnumerationType(AContext: PTranspilerContext; ALexer: PLexer); proc TranspileEnumerationType(AContext: PTranspilerContext; ALexer: PLexer);
var var
@ -254,12 +254,12 @@ begin
end; end;
WriteLn(); WriteLn();
WriteString(' )') WriteString(' )')
END TranspileEnumerationType; end;
proc TranspileUnionType(AContext: PTranspilerContext; ALexer: PLexer); proc TranspileUnionType(AContext: PTranspilerContext; ALexer: PLexer);
var var
Token: LexerToken; Token: LexerToken;
END TranspileUnionType; end;
proc TranspileProcedureType(AContext: PTranspilerContext; ALexer: PLexer); proc TranspileProcedureType(AContext: PTranspilerContext; ALexer: PLexer);
var var
@ -281,7 +281,7 @@ begin
end end
end; end;
Write(')') Write(')')
END TranspileProcedureType; end;
proc TranspileTypeExpression(AContext: PTranspilerContext; ALexer: PLexer); proc TranspileTypeExpression(AContext: PTranspilerContext; ALexer: PLexer);
var var
@ -307,7 +307,7 @@ begin
if Token.Kind = lexerKindIdentifier then if Token.Kind = lexerKindIdentifier then
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start) WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start)
end end
END TranspileTypeExpression; end;
proc TranspileTypeDeclaration(AContext: PTranspilerContext; ALexer: PLexer); proc TranspileTypeDeclaration(AContext: PTranspilerContext; ALexer: PLexer);
var var
@ -323,7 +323,7 @@ begin
TranspileTypeExpression(AContext, ALexer); TranspileTypeExpression(AContext, ALexer);
Token := TranspilerLex(ALexer); Token := TranspilerLex(ALexer);
WriteSemicolon(); WriteSemicolon();
END TranspileTypeDeclaration; end;
proc TranspileTypePart(AContext: PTranspilerContext; ALexer: PLexer); proc TranspileTypePart(AContext: PTranspilerContext; ALexer: PLexer);
var var
@ -342,7 +342,7 @@ begin
end; end;
WriteLn() WriteLn()
end end
END TranspileTypePart; end;
proc TranspileVariableDeclaration(AContext: PTranspilerContext; ALexer: PLexer); proc TranspileVariableDeclaration(AContext: PTranspilerContext; ALexer: PLexer);
var var
@ -358,7 +358,7 @@ begin
TranspileTypeExpression(AContext, ALexer); TranspileTypeExpression(AContext, ALexer);
Token := TranspilerLex(ALexer); Token := TranspilerLex(ALexer);
WriteSemicolon() WriteSemicolon()
END TranspileVariableDeclaration; end;
proc TranspileVariablePart(AContext: PTranspilerContext; ALexer: PLexer): BOOLEAN; proc TranspileVariablePart(AContext: PTranspilerContext; ALexer: PLexer): BOOLEAN;
var var
@ -379,16 +379,17 @@ begin
end end
end; end;
return Result return Result
END TranspileVariablePart; end;
proc TranspileProcedureHeading(AContext: PTranspilerContext; ALexer: PLexer); proc TranspileProcedureHeading(AContext: PTranspilerContext; ALexer: PLexer): LexerToken;
var var
Token: LexerToken; Token: LexerToken;
Result: LexerToken;
WrittenBytes: CARDINAL; WrittenBytes: CARDINAL;
begin begin
WriteString('PROCEDURE '); WriteString('PROCEDURE ');
Token := TranspilerLex(ALexer); Result := TranspilerLex(ALexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := TranspilerLex(ALexer); Token := TranspilerLex(ALexer);
@ -420,8 +421,10 @@ begin
Token := TranspilerLex(ALexer) Token := TranspilerLex(ALexer)
end; end;
Token := TranspilerLex(ALexer); Token := TranspilerLex(ALexer);
WriteSemicolon() WriteSemicolon();
END TranspileProcedureHeading;
return Result
end;
proc TranspileIfStatement(AContext: PTranspilerContext; ALexer: PLexer); proc TranspileIfStatement(AContext: PTranspilerContext; ALexer: PLexer);
var var
@ -441,7 +444,7 @@ begin
TranspileStatements(AContext, ALexer); TranspileStatements(AContext, ALexer);
WriteString(' END'); WriteString(' END');
Token := TranspilerLex(ALexer) Token := TranspilerLex(ALexer)
END TranspileIfStatement; end;
proc TranspileWhileStatement(AContext: PTranspilerContext; ALexer: PLexer); proc TranspileWhileStatement(AContext: PTranspilerContext; ALexer: PLexer);
var var
@ -461,7 +464,7 @@ begin
TranspileStatements(AContext, ALexer); TranspileStatements(AContext, ALexer);
WriteString(' END'); WriteString(' END');
Token := TranspilerLex(ALexer) Token := TranspilerLex(ALexer)
END TranspileWhileStatement; end;
proc TranspileAssignmentStatement(AContext: PTranspilerContext; ALexer: PLexer); proc TranspileAssignmentStatement(AContext: PTranspilerContext; ALexer: PLexer);
var var
@ -476,7 +479,7 @@ begin
Write(' '); Write(' ');
Token := TranspilerLex(ALexer) Token := TranspilerLex(ALexer)
end end
END TranspileAssignmentStatement; end;
proc TranspileCallStatement(AContext: PTranspilerContext; ALexer: PLexer); proc TranspileCallStatement(AContext: PTranspilerContext; ALexer: PLexer);
var var
@ -490,7 +493,7 @@ begin
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := TranspilerLex(ALexer) Token := TranspilerLex(ALexer)
end end
END TranspileCallStatement; end;
proc TranspileReturnStatement(AContext: PTranspilerContext; ALexer: PLexer); proc TranspileReturnStatement(AContext: PTranspilerContext; ALexer: PLexer);
var var
@ -501,7 +504,7 @@ begin
Token := TranspilerLex(ALexer); Token := TranspilerLex(ALexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := TranspilerLex(ALexer) Token := TranspilerLex(ALexer)
END TranspileReturnStatement; end;
proc TranspileStatement(AContext: PTranspilerContext; ALexer: PLexer); proc TranspileStatement(AContext: PTranspilerContext; ALexer: PLexer);
var var
@ -548,6 +551,16 @@ begin
Write('^'); Write('^');
Token := TranspilerLex(ALexer) Token := TranspilerLex(ALexer)
end; end;
while Token.Kind = lexerKindLeftSquare do
Write('[');
Token := TranspilerLex(ALexer);
while Token.Kind <> lexerKindRightSquare do
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := TranspilerLex(ALexer)
end;
Write(']');
Token := TranspilerLex(ALexer);
end;
if Token.Kind = lexerKindAssignment then if Token.Kind = lexerKindAssignment then
TranspileAssignmentStatement(AContext, ALexer) TranspileAssignmentStatement(AContext, ALexer)
@ -556,7 +569,7 @@ begin
TranspileCallStatement(AContext, ALexer) TranspileCallStatement(AContext, ALexer)
end end
end end
END TranspileStatement; end;
proc TranspileStatements(AContext: PTranspilerContext; ALexer: PLexer); proc TranspileStatements(AContext: PTranspilerContext; ALexer: PLexer);
var var
@ -573,7 +586,7 @@ begin
end; end;
WriteLn() WriteLn()
end end
END TranspileStatements; end;
proc TranspileStatementPart(AContext: PTranspilerContext; ALexer: PLexer); proc TranspileStatementPart(AContext: PTranspilerContext; ALexer: PLexer);
var var
@ -585,7 +598,7 @@ begin
WriteLn(); WriteLn();
TranspileStatements(AContext, ALexer) TranspileStatements(AContext, ALexer)
end end
END TranspileStatementPart; end;
proc TranspileProcedureDeclaration(AContext: PTranspilerContext; ALexer: PLexer); proc TranspileProcedureDeclaration(AContext: PTranspilerContext; ALexer: PLexer);
var var
@ -593,17 +606,18 @@ var
SeenPart: BOOLEAN; SeenPart: BOOLEAN;
WrittenBytes: CARDINAL; WrittenBytes: CARDINAL;
begin begin
TranspileProcedureHeading(AContext, ALexer); Token := TranspileProcedureHeading(AContext, ALexer);
SeenPart := TranspileConstantPart(AContext, ALexer); SeenPart := TranspileConstantPart(AContext, ALexer);
SeenPart := TranspileVariablePart(AContext, ALexer); SeenPart := TranspileVariablePart(AContext, ALexer);
TranspileStatementPart(AContext, ALexer); TranspileStatementPart(AContext, ALexer);
WriteString('END '); WriteString('END ');
Token := TranspilerLex(ALexer); WrittenBytes := WriteNBytes(StdOut, ORD(Token.identifierKind[1]), ADR(Token.identifierKind[2]));
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := TranspilerLex(ALexer); Token := TranspilerLex(ALexer);
WriteSemicolon(); WriteSemicolon();
Token := TranspilerLex(ALexer) Token := TranspilerLex(ALexer)
END TranspileProcedureDeclaration; end;
proc TranspileProcedurePart(AContext: PTranspilerContext; ALexer: PLexer); proc TranspileProcedurePart(AContext: PTranspilerContext; ALexer: PLexer);
var var
@ -616,7 +630,7 @@ begin
Token := LexerCurrent(ALexer); Token := LexerCurrent(ALexer);
WriteLn() WriteLn()
end end
END TranspileProcedurePart; end;
proc Transpile(ALexer: PLexer); proc Transpile(ALexer: PLexer);
var var
@ -625,6 +639,6 @@ var
Context: TranspilerContext; Context: TranspilerContext;
begin begin
TranspileModule(ADR(Context), ALexer) TranspileModule(ADR(Context), ALexer)
END Transpile; end;
END Transpiler. END Transpiler.