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

Handle ASCII codes > 128 in the tokenizer

Browse Source
This commit is contained in:
Eugen Wissner
2025-05-30 19:51:40 +02:00
parent 4eccc147ba
commit 8ad1259ee8
2 changed files with 128 additions and 120 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
source/Lexer.elna
View File

@@ -72,6 +72,8 @@ var
transitions: [16]TransitionClasses; transitions: [16]TransitionClasses;
proc initialize_classification(); proc initialize_classification();
var
i: CARDINAL;
begin begin
classification[1] := transitionClassEof; (* NUL *) classification[1] := transitionClassEof; (* NUL *)
classification[2] := transitionClassInvalid; (* SOH *) classification[2] := transitionClassInvalid; (* SOH *)
@@ -200,24 +202,30 @@ begin
classification[125] := transitionClassSingle; (* | *) classification[125] := transitionClassSingle; (* | *)
classification[126] := transitionClassOther; (* } *) classification[126] := transitionClassOther; (* } *)
classification[127] := transitionClassSingle; (* ~ *) classification[127] := transitionClassSingle; (* ~ *)
classification[128] := transitionClassInvalid (* DEL *) classification[128] := transitionClassInvalid; (* DEL *)
i := 129;
while i <= 256 do
classification[i] := transitionClassOther;
i := i + 1
end
end; end;
proc compare_keyword(Keyword: ARRAY OF CHAR, TokenStart: PLexerBuffer, TokenEnd: PLexerBuffer): BOOLEAN; proc compare_keyword(Keyword: ARRAY OF CHAR, TokenStart: PLexerBuffer, TokenEnd: PLexerBuffer): BOOLEAN;
var var
Result: BOOLEAN; result: BOOLEAN;
Index: CARDINAL; Index: CARDINAL;
begin begin
Index := 0; Index := 0;
Result := TRUE; result := TRUE;
while (Index < Length(Keyword)) & (TokenStart <> TokenEnd) & Result DO while (Index < Length(Keyword)) & (TokenStart <> TokenEnd) & result DO
Result := (Keyword[Index] = TokenStart^) or (Lower(Keyword[Index]) = TokenStart^); result := (Keyword[Index] = TokenStart^) or (Lower(Keyword[Index]) = TokenStart^);
INC(TokenStart); INC(TokenStart);
INC(Index) INC(Index)
end; end;
Result := (Index = Length(Keyword)) & (TokenStart = TokenEnd) & Result; result := (Index = Length(Keyword)) & (TokenStart = TokenEnd) & result;
return Result return result
end; end;
(* Reached the end of file. *) (* Reached the end of file. *)
@@ -761,7 +769,7 @@ var
CurrentClass: TransitionClass; CurrentClass: TransitionClass;
CurrentState: TransitionState; CurrentState: TransitionState;
CurrentTransition: Transition; CurrentTransition: Transition;
Result: LexerToken; result: LexerToken;
begin begin
lexer^.Current := lexer^.Start; lexer^.Current := lexer^.Start;
CurrentState := transitionStateStart; CurrentState := transitionStateStart;
@@ -771,16 +779,16 @@ begin
CurrentTransition := transitions[ORD(CurrentState) + 1][ORD(CurrentClass) + 1]; CurrentTransition := transitions[ORD(CurrentState) + 1][ORD(CurrentClass) + 1];
if CurrentTransition.Action <> nil then if CurrentTransition.Action <> nil then
CurrentTransition.Action(lexer, ADR(Result)) CurrentTransition.Action(lexer, ADR(result))
end; end;
CurrentState := CurrentTransition.NextState CurrentState := CurrentTransition.NextState
end; end;
return Result return result
end; end;
proc lexer_lex(lexer: PLexer): LexerToken; proc lexer_lex(lexer: PLexer): LexerToken;
var var
Result: LexerToken; result: LexerToken;
begin begin
if lexer^.Length = 0 then if lexer^.Length = 0 then
lexer^.Length := ReadNBytes(lexer^.Input, CHUNK_SIZE, lexer^.Buffer); lexer^.Length := ReadNBytes(lexer^.Input, CHUNK_SIZE, lexer^.Buffer);
@@ -788,8 +796,8 @@ begin
end; end;
lexer^.Start := lexer^.Current; lexer^.Start := lexer^.Current;
Result := lexer_current(lexer); result := lexer_current(lexer);
return Result return result
end; end;
proc lexer_destroy(lexer: PLexer); proc lexer_destroy(lexer: PLexer);

214
source/Transpiler.elna
View File

@@ -75,39 +75,39 @@ end;
proc transpile_constant(context: PTranspilerContext, lexer: PLexer); proc transpile_constant(context: PTranspilerContext, lexer: PLexer);
var var
Token: LexerToken; token: LexerToken;
written_bytes: CARDINAL; written_bytes: CARDINAL;
begin begin
WriteString(' '); WriteString(' ');
Token := lexer_current(lexer); token := lexer_current(lexer);
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start); written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(lexer); token := transpiler_lex(lexer);
WriteString(' = '); WriteString(' = ');
Token := transpiler_lex(lexer); token := transpiler_lex(lexer);
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start); written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(lexer); token := transpiler_lex(lexer);
write_semicolon() write_semicolon()
end; end;
proc transpile_constant_part(context: PTranspilerContext, lexer: PLexer): BOOLEAN; proc transpile_constant_part(context: PTranspilerContext, lexer: PLexer): BOOLEAN;
var var
Token: LexerToken; token: LexerToken;
result: BOOLEAN; result: BOOLEAN;
begin begin
Token := lexer_current(lexer); token := lexer_current(lexer);
result := Token.Kind = lexerKindConst; result := token.Kind = lexerKindConst;
if result then if result then
WriteString('CONST'); WriteString('CONST');
WriteLn(); WriteLn();
Token := transpiler_lex(lexer); token := transpiler_lex(lexer);
while Token.Kind = lexerKindIdentifier do while token.Kind = lexerKindIdentifier do
transpile_constant(context, lexer); transpile_constant(context, lexer);
Token := transpiler_lex(lexer) token := transpiler_lex(lexer)
end end
end; end;
return result return result
@@ -115,31 +115,31 @@ end;
proc transpile_module(context: PTranspilerContext, lexer: PLexer); proc transpile_module(context: PTranspilerContext, lexer: PLexer);
var var
Token: LexerToken; token: LexerToken;
written_bytes: CARDINAL; written_bytes: CARDINAL;
begin begin
Token := transpiler_lex(lexer); token := transpiler_lex(lexer);
if Token.Kind = lexerKindDefinition then if token.Kind = lexerKindDefinition then
WriteString('DEFINITION '); WriteString('DEFINITION ');
Token := transpiler_lex(lexer) token := transpiler_lex(lexer)
end; end;
if Token.Kind = lexerKindImplementation then if token.Kind = lexerKindImplementation then
WriteString('IMPLEMENTATION '); WriteString('IMPLEMENTATION ');
Token := transpiler_lex(lexer) token := transpiler_lex(lexer)
end; end;
WriteString('MODULE '); WriteString('MODULE ');
(* Write the module name and end the line with a semicolon and newline. *) (* Write the module name and end the line with a semicolon and newline. *)
Token := transpiler_lex(lexer); token := transpiler_lex(lexer);
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start); written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(lexer); token := transpiler_lex(lexer);
write_semicolon(); write_semicolon();
WriteLn(); WriteLn();
(* Write the module body. *) (* Write the module body. *)
Token := transpiler_lex(lexer); token := transpiler_lex(lexer);
transpile_import_part(context, lexer); transpile_import_part(context, lexer);
if transpile_constant_part(context, lexer) then if transpile_constant_part(context, lexer) then
WriteLn() WriteLn()
@@ -153,33 +153,33 @@ begin
WriteString('END '); WriteString('END ');
Token := transpiler_lex(lexer); token := transpiler_lex(lexer);
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start); written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(lexer); token := transpiler_lex(lexer);
Write('.'); Write('.');
Token := transpiler_lex(lexer); token := transpiler_lex(lexer);
WriteLn() WriteLn()
end; end;
proc transpile_type_fields(context: PTranspilerContext, lexer: PLexer); proc transpile_type_fields(context: PTranspilerContext, lexer: PLexer);
var var
Token: LexerToken; token: LexerToken;
written_bytes: CARDINAL; written_bytes: CARDINAL;
begin begin
Token := transpiler_lex(lexer); token := transpiler_lex(lexer);
while Token.Kind <> lexerKindEnd do while token.Kind <> lexerKindEnd do
WriteString(' '); WriteString(' ');
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start); written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(lexer); token := transpiler_lex(lexer);
WriteString(': '); WriteString(': ');
transpile_type_expression(context, lexer); transpile_type_expression(context, lexer);
Token := transpiler_lex(lexer); token := transpiler_lex(lexer);
if Token.Kind = lexerKindSemicolon then if token.Kind = lexerKindSemicolon then
Token := transpiler_lex(lexer); token := transpiler_lex(lexer);
Write(';') Write(';')
end; end;
WriteLn() WriteLn()
@@ -188,7 +188,7 @@ end;
proc transpile_record_type(context: PTranspilerContext, lexer: PLexer); proc transpile_record_type(context: PTranspilerContext, lexer: PLexer);
var var
Token: LexerToken; token: LexerToken;
begin begin
WriteString('RECORD'); WriteString('RECORD');
WriteLn(); WriteLn();
@@ -198,33 +198,33 @@ end;
proc transpile_pointer_type(context: PTranspilerContext, lexer: PLexer); proc transpile_pointer_type(context: PTranspilerContext, lexer: PLexer);
var var
Token: LexerToken; token: LexerToken;
written_bytes: CARDINAL; written_bytes: CARDINAL;
begin begin
Token := lexer_current(lexer); token := lexer_current(lexer);
WriteString('POINTER TO '); WriteString('POINTER TO ');
if Token.Kind = lexerKindPointer then if token.Kind = lexerKindPointer then
Token := transpiler_lex(lexer) token := transpiler_lex(lexer)
end; end;
transpile_type_expression(context, lexer) transpile_type_expression(context, lexer)
end; end;
proc transpile_array_type(context: PTranspilerContext, lexer: PLexer); proc transpile_array_type(context: PTranspilerContext, lexer: PLexer);
var var
Token: LexerToken; token: LexerToken;
written_bytes: CARDINAL; written_bytes: CARDINAL;
begin begin
WriteString('ARRAY'); WriteString('ARRAY');
Token := lexer_current(lexer); token := lexer_current(lexer);
if Token.Kind = lexerKindArray then if token.Kind = lexerKindArray then
Token := transpiler_lex(lexer) token := transpiler_lex(lexer)
end; end;
if Token.Kind <> lexerKindOf then if token.Kind <> lexerKindOf then
WriteString('[1..'); WriteString('[1..');
Token := transpiler_lex(lexer); token := transpiler_lex(lexer);
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start); written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(lexer); token := transpiler_lex(lexer);
Write(']') Write(']')
end; end;
WriteString(' OF '); WriteString(' OF ');
@@ -233,26 +233,26 @@ end;
proc transpile_enumeration_type(context: PTranspilerContext, lexer: PLexer); proc transpile_enumeration_type(context: PTranspilerContext, lexer: PLexer);
var var
Token: LexerToken; token: LexerToken;
written_bytes: CARDINAL; written_bytes: CARDINAL;
begin begin
WriteString('('); WriteString('(');
WriteLn(); WriteLn();
WriteString(' '); WriteString(' ');
Token := transpiler_lex(lexer); token := transpiler_lex(lexer);
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start); written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(lexer); token := transpiler_lex(lexer);
while Token.Kind = lexerKindComma do while token.Kind = lexerKindComma do
Write(','); Write(',');
WriteLn(); WriteLn();
WriteString(' '); WriteString(' ');
Token := transpiler_lex(lexer); token := transpiler_lex(lexer);
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start); written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(lexer) token := transpiler_lex(lexer)
end; end;
WriteLn(); WriteLn();
WriteString(' )') WriteString(' )')
@@ -260,25 +260,25 @@ end;
proc transpile_union_type(context: PTranspilerContext, lexer: PLexer); proc transpile_union_type(context: PTranspilerContext, lexer: PLexer);
var var
Token: LexerToken; token: LexerToken;
end; end;
proc transpile_procedure_type(context: PTranspilerContext, lexer: PLexer); proc transpile_procedure_type(context: PTranspilerContext, lexer: PLexer);
var var
Token: LexerToken; token: LexerToken;
written_bytes: CARDINAL; written_bytes: CARDINAL;
begin begin
Token := transpiler_lex(lexer); token := transpiler_lex(lexer);
WriteString('PROCEDURE('); WriteString('PROCEDURE(');
Token := transpiler_lex(lexer); token := transpiler_lex(lexer);
while Token.Kind <> lexerKindRightParen do while token.Kind <> lexerKindRightParen do
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start); written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(lexer); token := transpiler_lex(lexer);
if Token.Kind = lexerKindComma then if token.Kind = lexerKindComma then
Token := transpiler_lex(lexer); token := transpiler_lex(lexer);
WriteString(', ') WriteString(', ')
end end
end; end;
@@ -287,43 +287,43 @@ end;
proc transpile_type_expression(context: PTranspilerContext, lexer: PLexer); proc transpile_type_expression(context: PTranspilerContext, lexer: PLexer);
var var
Token: LexerToken; token: LexerToken;
written_bytes: CARDINAL; written_bytes: CARDINAL;
begin begin
Token := transpiler_lex(lexer); token := transpiler_lex(lexer);
if Token.Kind = lexerKindRecord then if token.Kind = lexerKindRecord then
transpile_record_type(context, lexer) transpile_record_type(context, lexer)
end; end;
if Token.Kind = lexerKindLeftParen then if token.Kind = lexerKindLeftParen then
transpile_enumeration_type(context, lexer) transpile_enumeration_type(context, lexer)
end; end;
if (Token.Kind = lexerKindArray) or (Token.Kind = lexerKindLeftSquare) then if (token.Kind = lexerKindArray) or (token.Kind = lexerKindLeftSquare) then
transpile_array_type(context, lexer) transpile_array_type(context, lexer)
end; end;
if Token.Kind = lexerKindHat then if token.Kind = lexerKindHat then
transpile_pointer_type(context, lexer) transpile_pointer_type(context, lexer)
end; end;
if Token.Kind = lexerKindProc then if token.Kind = lexerKindProc then
transpile_procedure_type(context, lexer) transpile_procedure_type(context, lexer)
end; end;
if Token.Kind = lexerKindIdentifier then if token.Kind = lexerKindIdentifier then
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start) written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start)
end end
end; end;
proc transpile_type_declaration(context: PTranspilerContext, lexer: PLexer); proc transpile_type_declaration(context: PTranspilerContext, lexer: PLexer);
var var
Token: LexerToken; token: LexerToken;
written_bytes: CARDINAL; written_bytes: CARDINAL;
begin begin
WriteString(' '); WriteString(' ');
Token := lexer_current(lexer); token := lexer_current(lexer);
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start); written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(lexer); token := transpiler_lex(lexer);
WriteString(' = '); WriteString(' = ');
transpile_type_expression(context, lexer); transpile_type_expression(context, lexer);
Token := transpiler_lex(lexer); token := transpiler_lex(lexer);
write_semicolon(); write_semicolon();
end; end;
@@ -348,36 +348,36 @@ end;
proc transpile_variable_declaration(context: PTranspilerContext, lexer: PLexer); proc transpile_variable_declaration(context: PTranspilerContext, lexer: PLexer);
var var
Token: LexerToken; token: LexerToken;
written_bytes: CARDINAL; written_bytes: CARDINAL;
begin begin
WriteString(' '); WriteString(' ');
Token := lexer_current(lexer); token := lexer_current(lexer);
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start); written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(lexer); token := transpiler_lex(lexer);
WriteString(': '); WriteString(': ');
transpile_type_expression(context, lexer); transpile_type_expression(context, lexer);
Token := transpiler_lex(lexer); token := transpiler_lex(lexer);
write_semicolon() write_semicolon()
end; end;
proc transpile_variable_part(context: PTranspilerContext, lexer: PLexer): BOOLEAN; proc transpile_variable_part(context: PTranspilerContext, lexer: PLexer): BOOLEAN;
var var
Token: LexerToken; token: LexerToken;
result: BOOLEAN; result: BOOLEAN;
begin begin
Token := lexer_current(lexer); token := lexer_current(lexer);
result := Token.Kind = lexerKindVar; result := token.Kind = lexerKindVar;
if result then if result then
WriteString('VAR'); WriteString('VAR');
WriteLn(); WriteLn();
Token := transpiler_lex(lexer); token := transpiler_lex(lexer);
while Token.Kind = lexerKindIdentifier do while token.Kind = lexerKindIdentifier do
transpile_variable_declaration(context, lexer); transpile_variable_declaration(context, lexer);
Token := transpiler_lex(lexer) token := transpiler_lex(lexer)
end end
end; end;
return result return result
@@ -428,14 +428,14 @@ begin
return result return result
end; end;
proc transpile_expression(context: PTranspilerContext, lexer: PLexer, TrailingToken: LexerKind); proc transpile_expression(context: PTranspilerContext, lexer: PLexer, trailing_token: LexerKind);
var var
token: LexerToken; token: LexerToken;
written_bytes: CARDINAL; written_bytes: CARDINAL;
begin begin
token := transpiler_lex(lexer); token := transpiler_lex(lexer);
while (token.Kind <> TrailingToken) & (token.Kind <> lexerKindEnd) do while (token.Kind <> trailing_token) & (token.Kind <> lexerKindEnd) do
written_bytes := 0; written_bytes := 0;
if token.Kind = lexerKindNull then if token.Kind = lexerKindNull then
WriteString('NIL '); WriteString('NIL ');
@@ -478,7 +478,7 @@ end;
proc transpile_while_statement(context: PTranspilerContext, lexer: PLexer); proc transpile_while_statement(context: PTranspilerContext, lexer: PLexer);
var var
Token: LexerToken; token: LexerToken;
written_bytes: CARDINAL; written_bytes: CARDINAL;
begin begin
WriteString(' WHILE '); WriteString(' WHILE ');
@@ -488,7 +488,7 @@ begin
WriteLn(); WriteLn();
transpile_statements(context, lexer); transpile_statements(context, lexer);
WriteString(' END'); WriteString(' END');
Token := transpiler_lex(lexer) token := transpiler_lex(lexer)
end; end;
proc transpile_assignment_statement(context: PTranspilerContext, lexer: PLexer); proc transpile_assignment_statement(context: PTranspilerContext, lexer: PLexer);
@@ -499,27 +499,27 @@ end;
proc transpile_call_statement(context: PTranspilerContext, lexer: PLexer); proc transpile_call_statement(context: PTranspilerContext, lexer: PLexer);
var var
Token: LexerToken; token: LexerToken;
written_bytes: CARDINAL; written_bytes: CARDINAL;
begin begin
WriteString('('); WriteString('(');
Token := transpiler_lex(lexer); token := transpiler_lex(lexer);
while (Token.Kind <> lexerKindSemicolon) & (Token.Kind <> lexerKindEnd) do while (token.Kind <> lexerKindSemicolon) & (token.Kind <> lexerKindEnd) do
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start); written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(lexer) token := transpiler_lex(lexer)
end end
end; end;
proc transpile_return_statement(context: PTranspilerContext, lexer: PLexer); proc transpile_return_statement(context: PTranspilerContext, lexer: PLexer);
var var
Token: LexerToken; token: LexerToken;
written_bytes: CARDINAL; written_bytes: CARDINAL;
begin begin
WriteString(' RETURN '); WriteString(' RETURN ');
Token := transpiler_lex(lexer); token := transpiler_lex(lexer);
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start); written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(lexer) token := transpiler_lex(lexer)
end; end;
proc transpile_statement(context: PTranspilerContext, lexer: PLexer); proc transpile_statement(context: PTranspilerContext, lexer: PLexer);
@@ -589,15 +589,15 @@ end;
proc transpile_statements(context: PTranspilerContext, lexer: PLexer); proc transpile_statements(context: PTranspilerContext, lexer: PLexer);
var var
Token: LexerToken; token: LexerToken;
begin begin
Token := lexer_current(lexer); token := lexer_current(lexer);
while Token.Kind <> lexerKindEnd do while token.Kind <> lexerKindEnd do
transpile_statement(context, lexer); transpile_statement(context, lexer);
Token := lexer_current(lexer); token := lexer_current(lexer);
if Token.Kind = lexerKindSemicolon then if token.Kind = lexerKindSemicolon then
Write(';') Write(';')
end; end;
WriteLn() WriteLn()
@@ -606,10 +606,10 @@ end;
proc transpile_statement_part(context: PTranspilerContext, lexer: PLexer); proc transpile_statement_part(context: PTranspilerContext, lexer: PLexer);
var var
Token: LexerToken; token: LexerToken;
begin begin
Token := lexer_current(lexer); token := lexer_current(lexer);
if Token.Kind = lexerKindBegin then if token.Kind = lexerKindBegin then
WriteString('BEGIN'); WriteString('BEGIN');
WriteLn(); WriteLn();
transpile_statements(context, lexer) transpile_statements(context, lexer)
@@ -618,39 +618,39 @@ end;
proc transpile_procedure_declaration(context: PTranspilerContext, lexer: PLexer); proc transpile_procedure_declaration(context: PTranspilerContext, lexer: PLexer);
var var
Token: LexerToken; token: LexerToken;
seen_part: BOOLEAN; seen_part: BOOLEAN;
written_bytes: CARDINAL; written_bytes: CARDINAL;
begin begin
Token := transpile_procedure_heading(context, lexer); token := transpile_procedure_heading(context, lexer);
seen_part := transpile_constant_part(context, lexer); seen_part := transpile_constant_part(context, lexer);
seen_part := transpile_variable_part(context, lexer); seen_part := transpile_variable_part(context, lexer);
transpile_statement_part(context, lexer); transpile_statement_part(context, lexer);
WriteString('END '); WriteString('END ');
written_bytes := WriteNBytes(StdOut, ORD(Token.identifierKind[1]), ADR(Token.identifierKind[2])); written_bytes := WriteNBytes(StdOut, ORD(token.identifierKind[1]), ADR(token.identifierKind[2]));
Token := transpiler_lex(lexer); token := transpiler_lex(lexer);
write_semicolon(); write_semicolon();
Token := transpiler_lex(lexer) token := transpiler_lex(lexer)
end; end;
proc transpile_procedure_part(context: PTranspilerContext, lexer: PLexer); proc transpile_procedure_part(context: PTranspilerContext, lexer: PLexer);
var var
Token: LexerToken; token: LexerToken;
begin begin
Token := lexer_current(lexer); token := lexer_current(lexer);
while Token.Kind = lexerKindProc do while token.Kind = lexerKindProc do
transpile_procedure_declaration(context, lexer); transpile_procedure_declaration(context, lexer);
Token := lexer_current(lexer); token := lexer_current(lexer);
WriteLn() WriteLn()
end end
end; end;
proc transpile(lexer: PLexer); proc transpile(lexer: PLexer);
var var
Token: LexerToken; token: LexerToken;
written_bytes: CARDINAL; written_bytes: CARDINAL;
Context: TranspilerContext; Context: TranspilerContext;
begin begin