belka/elna
1
0
Fork 0
Code Issues 5 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 6e415e474f
Signed by: belka
GPG Key ID: A27FDC1E8EE902C0
4 changed files with 287 additions and 266 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Rakefile
View File

@ -107,6 +107,7 @@ task :backport do
.gsub(/\b(record|nil|or)\b/) { |match| match.upcase } .gsub(/\b(record|nil|or)\b/) { |match| match.upcase }
.gsub(/proc\(/, 'PROCEDURE(') .gsub(/proc\(/, 'PROCEDURE(')
.gsub(/ & /, ' AND ') .gsub(/ & /, ' AND ')
.gsub(/ -> /, ': ')
.gsub(/([[:space:]]*)end(;?)$/, '\1END\2') .gsub(/([[:space:]]*)end(;?)$/, '\1END\2')
.gsub(/^([[:space:]]*)(while|return|if)\b/) { |match| match.upcase } .gsub(/^([[:space:]]*)(while|return|if)\b/) { |match| match.upcase }
.gsub(/^from ([[:alnum:]]+) import/, 'FROM \1 IMPORT') .gsub(/^from ([[:alnum:]]+) import/, 'FROM \1 IMPORT')

4
source/Lexer.def
View File

@ -73,13 +73,13 @@ TYPE
lexerKindFrom, lexerKindFrom,
lexerKindPointer, lexerKindPointer,
lexerKindArray, lexerKindArray,
lexerKindTrait, lexerKindArrow,
lexerKindProgram, lexerKindProgram,
lexerKindModule, lexerKindModule,
lexerKindImport lexerKindImport
); );
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 lexerKindIdentifier: identifierKind: ARRAY[1..256] OF CHAR
END END

199
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,265 +202,274 @@ 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. *)
proc transition_action_eof(lexer: PLexer, AToken: PLexerToken); proc transition_action_eof(lexer: PLexer, token: PLexerToken);
begin begin
AToken^.Kind := lexerKindEof token^.kind := lexerKindEof
end; 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 transition_action_accumulate(lexer: PLexer, AToken: PLexerToken); proc transition_action_accumulate(lexer: PLexer, token: PLexerToken);
begin begin
INC(lexer^.Current) INC(lexer^.Current)
end; 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. *)
proc transition_action_finalize(lexer: PLexer, AToken: PLexerToken); proc transition_action_finalize(lexer: PLexer, token: PLexerToken);
begin begin
if lexer^.Start^ = ':' then if lexer^.Start^ = ':' then
AToken^.Kind := lexerKindColon token^.kind := lexerKindColon
end; end;
if lexer^.Start^ = '>' then if lexer^.Start^ = '>' then
AToken^.Kind := lexerKindGreaterThan token^.kind := lexerKindGreaterThan
end; end;
if lexer^.Start^ = '<' then if lexer^.Start^ = '<' then
AToken^.Kind := lexerKindLessThan token^.kind := lexerKindLessThan
end; end;
if lexer^.Start^ = '(' then if lexer^.Start^ = '(' then
AToken^.Kind := lexerKindLeftParen token^.kind := lexerKindLeftParen
end; end;
if lexer^.Start^ = '-' then if lexer^.Start^ = '-' then
AToken^.Kind := lexerKindLeftParen token^.kind := lexerKindLeftParen
end; end;
if lexer^.Start^ = '.' then if lexer^.Start^ = '.' then
AToken^.Kind := lexerKindDot token^.kind := lexerKindDot
end end
end; end;
(* An action for tokens containing multiple characters. *) (* An action for tokens containing multiple characters. *)
proc transition_action_composite(lexer: PLexer, AToken: PLexerToken); proc transition_action_composite(lexer: PLexer, token: PLexerToken);
begin begin
if lexer^.Start^ = '<' then if lexer^.Start^ = '<' then
if lexer^.Current^ = '>' then if lexer^.Current^ = '>' then
AToken^.Kind := lexerKindNotEqual token^.kind := lexerKindNotEqual
end; end;
if lexer^.Current^ = '=' then if lexer^.Current^ = '=' then
AToken^.Kind := lexerKindLessEqual token^.kind := lexerKindLessEqual
end end
end; end;
if (lexer^.Start^ = '>') & (lexer^.Current^ = '=') then if (lexer^.Start^ = '>') & (lexer^.Current^ = '=') then
AToken^.Kind := lexerKindGreaterEqual token^.kind := lexerKindGreaterEqual
end; end;
if (lexer^.Start^ = '.') & (lexer^.Current^ = '.') then if (lexer^.Start^ = '.') & (lexer^.Current^ = '.') then
AToken^.Kind := lexerKindRange token^.kind := lexerKindRange
end; end;
if (lexer^.Start^ = ':') & (lexer^.Current^ = '=') then if (lexer^.Start^ = ':') & (lexer^.Current^ = '=') then
AToken^.Kind := lexerKindAssignment token^.kind := lexerKindAssignment
end;
if (lexer^.Start^ = '-') & (lexer^.Current^ = '>') then
token^.kind := lexerKindArrow
end; end;
INC(lexer^.Current) INC(lexer^.Current)
end; end;
(* Skip a space. *) (* Skip a space. *)
proc transition_action_skip(lexer: PLexer, AToken: PLexerToken); proc transition_action_skip(lexer: PLexer, token: PLexerToken);
begin begin
INC(lexer^.Current); INC(lexer^.Current);
INC(lexer^.Start) INC(lexer^.Start)
end; end;
(* Delimited string action. *) (* Delimited string action. *)
proc transition_action_delimited(lexer: PLexer, AToken: PLexerToken); proc transition_action_delimited(lexer: PLexer, token: PLexerToken);
begin begin
if lexer^.Start^ = '(' then if lexer^.Start^ = '(' then
AToken^.Kind := lexerKindComment token^.kind := lexerKindComment
end; end;
if lexer^.Start^ = '"' then if lexer^.Start^ = '"' then
AToken^.Kind := lexerKindCharacter token^.kind := lexerKindCharacter
end; end;
if lexer^.Start^ = "'" then if lexer^.Start^ = "'" then
AToken^.Kind := lexerKindString token^.kind := lexerKindString
end; end;
INC(lexer^.Current) INC(lexer^.Current)
end; end;
(* Finalize keyword or identifier. *) (* Finalize keyword or identifier. *)
proc transition_action_key_id(lexer: PLexer, AToken: PLexerToken); proc transition_action_key_id(lexer: PLexer, token: PLexerToken);
begin begin
AToken^.Kind := lexerKindIdentifier; token^.kind := lexerKindIdentifier;
AToken^.identifierKind[1] := lexer^.Current - lexer^.Start; token^.identifierKind[1] := lexer^.Current - lexer^.Start;
MemCopy(lexer^.Start, ORD(AToken^.identifierKind[1]), ADR(AToken^.identifierKind[2])); MemCopy(lexer^.Start, ORD(token^.identifierKind[1]), ADR(token^.identifierKind[2]));
if compare_keyword('PROGRAM', lexer^.Start, lexer^.Current) then if compare_keyword('PROGRAM', lexer^.Start, lexer^.Current) then
AToken^.Kind := lexerKindProgram token^.kind := lexerKindProgram
end; end;
if compare_keyword('IMPORT', lexer^.Start, lexer^.Current) then if compare_keyword('IMPORT', lexer^.Start, lexer^.Current) then
AToken^.Kind := lexerKindImport token^.kind := lexerKindImport
end; end;
if compare_keyword('CONST', lexer^.Start, lexer^.Current) then if compare_keyword('CONST', lexer^.Start, lexer^.Current) then
AToken^.Kind := lexerKindConst token^.kind := lexerKindConst
end; end;
if compare_keyword('VAR', lexer^.Start, lexer^.Current) then if compare_keyword('VAR', lexer^.Start, lexer^.Current) then
AToken^.Kind := lexerKindVar token^.kind := lexerKindVar
end; end;
if compare_keyword('IF', lexer^.Start, lexer^.Current) then if compare_keyword('IF', lexer^.Start, lexer^.Current) then
AToken^.Kind := lexerKindIf token^.kind := lexerKindIf
end; end;
if compare_keyword('THEN', lexer^.Start, lexer^.Current) then if compare_keyword('THEN', lexer^.Start, lexer^.Current) then
AToken^.Kind := lexerKindThen token^.kind := lexerKindThen
end; end;
if compare_keyword('ELSIF', lexer^.Start, lexer^.Current) then if compare_keyword('ELSIF', lexer^.Start, lexer^.Current) then
AToken^.Kind := lexerKindElsif token^.kind := lexerKindElsif
end; end;
if compare_keyword('ELSE', lexer^.Start, lexer^.Current) then if compare_keyword('ELSE', lexer^.Start, lexer^.Current) then
AToken^.Kind := lexerKindElse token^.kind := lexerKindElse
end; end;
if compare_keyword('WHILE', lexer^.Start, lexer^.Current) then if compare_keyword('WHILE', lexer^.Start, lexer^.Current) then
AToken^.Kind := lexerKindWhile token^.kind := lexerKindWhile
end; end;
if compare_keyword('DO', lexer^.Start, lexer^.Current) then if compare_keyword('DO', lexer^.Start, lexer^.Current) then
AToken^.Kind := lexerKindDo token^.kind := lexerKindDo
end; end;
if compare_keyword('proc', lexer^.Start, lexer^.Current) then if compare_keyword('proc', lexer^.Start, lexer^.Current) then
AToken^.Kind := lexerKindProc token^.kind := lexerKindProc
end; end;
if compare_keyword('BEGIN', lexer^.Start, lexer^.Current) then if compare_keyword('BEGIN', lexer^.Start, lexer^.Current) then
AToken^.Kind := lexerKindBegin token^.kind := lexerKindBegin
end; end;
if compare_keyword('END', lexer^.Start, lexer^.Current) then if compare_keyword('END', lexer^.Start, lexer^.Current) then
AToken^.Kind := lexerKindEnd token^.kind := lexerKindEnd
end; end;
if compare_keyword('TYPE', lexer^.Start, lexer^.Current) then if compare_keyword('TYPE', lexer^.Start, lexer^.Current) then
AToken^.Kind := lexerKindType token^.kind := lexerKindType
end; end;
if compare_keyword('RECORD', lexer^.Start, lexer^.Current) then if compare_keyword('RECORD', lexer^.Start, lexer^.Current) then
AToken^.Kind := lexerKindRecord token^.kind := lexerKindRecord
end; end;
if compare_keyword('UNION', lexer^.Start, lexer^.Current) then if compare_keyword('UNION', lexer^.Start, lexer^.Current) then
AToken^.Kind := lexerKindUnion token^.kind := lexerKindUnion
end; end;
if compare_keyword('NIL', lexer^.Start, lexer^.Current) then if compare_keyword('NIL', lexer^.Start, lexer^.Current) then
AToken^.Kind := lexerKindNull token^.kind := lexerKindNull
end; end;
if compare_keyword('AND', lexer^.Start, lexer^.Current) then if compare_keyword('AND', lexer^.Start, lexer^.Current) then
AToken^.Kind := lexerKindAnd token^.kind := lexerKindAnd
end; end;
if compare_keyword('OR', lexer^.Start, lexer^.Current) then if compare_keyword('OR', lexer^.Start, lexer^.Current) then
AToken^.Kind := lexerKindOr token^.kind := lexerKindOr
end; end;
if compare_keyword('RETURN', lexer^.Start, lexer^.Current) then if compare_keyword('RETURN', lexer^.Start, lexer^.Current) then
AToken^.Kind := lexerKindReturn token^.kind := lexerKindReturn
end; end;
if compare_keyword('DEFINITION', lexer^.Start, lexer^.Current) then if compare_keyword('DEFINITION', lexer^.Start, lexer^.Current) then
AToken^.Kind := lexerKindDefinition token^.kind := lexerKindDefinition
end; end;
if compare_keyword('TO', lexer^.Start, lexer^.Current) then if compare_keyword('TO', lexer^.Start, lexer^.Current) then
AToken^.Kind := lexerKindTo token^.kind := lexerKindTo
end; end;
if compare_keyword('CASE', lexer^.Start, lexer^.Current) then if compare_keyword('CASE', lexer^.Start, lexer^.Current) then
AToken^.Kind := lexerKindCase token^.kind := lexerKindCase
end; end;
if compare_keyword('OF', lexer^.Start, lexer^.Current) then if compare_keyword('OF', lexer^.Start, lexer^.Current) then
AToken^.Kind := lexerKindOf token^.kind := lexerKindOf
end; end;
if compare_keyword('FROM', lexer^.Start, lexer^.Current) then if compare_keyword('FROM', lexer^.Start, lexer^.Current) then
AToken^.Kind := lexerKindFrom token^.kind := lexerKindFrom
end; end;
if compare_keyword('MODULE', lexer^.Start, lexer^.Current) then if compare_keyword('MODULE', lexer^.Start, lexer^.Current) then
AToken^.Kind := lexerKindModule token^.kind := lexerKindModule
end; end;
if compare_keyword('IMPLEMENTATION', lexer^.Start, lexer^.Current) then if compare_keyword('IMPLEMENTATION', lexer^.Start, lexer^.Current) then
AToken^.Kind := lexerKindImplementation token^.kind := lexerKindImplementation
end; end;
if compare_keyword('POINTER', lexer^.Start, lexer^.Current) then if compare_keyword('POINTER', lexer^.Start, lexer^.Current) then
AToken^.Kind := lexerKindPointer token^.kind := lexerKindPointer
end; end;
if compare_keyword('ARRAY', lexer^.Start, lexer^.Current) then if compare_keyword('ARRAY', lexer^.Start, lexer^.Current) then
AToken^.Kind := lexerKindArray token^.kind := lexerKindArray
end; end;
if compare_keyword('TRUE', lexer^.Start, lexer^.Current) then if compare_keyword('TRUE', lexer^.Start, lexer^.Current) then
AToken^.Kind := lexerKindBoolean; token^.kind := lexerKindBoolean;
AToken^.booleanKind := TRUE token^.booleanKind := TRUE
end; end;
if compare_keyword('FALSE', lexer^.Start, lexer^.Current) then if compare_keyword('FALSE', lexer^.Start, lexer^.Current) then
AToken^.Kind := lexerKindBoolean; token^.kind := lexerKindBoolean;
AToken^.booleanKind := FALSE token^.booleanKind := FALSE
end end
end; 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. *)
proc transition_action_single(lexer: PLexer, AToken: PLexerToken); proc transition_action_single(lexer: PLexer, token: PLexerToken);
begin begin
if lexer^.Current^ = '&' then if lexer^.Current^ = '&' then
AToken^.Kind := lexerKindAnd token^.kind := lexerKindAnd
end; end;
if lexer^.Current^ = ';' then if lexer^.Current^ = ';' then
AToken^.Kind := lexerKindSemicolon token^.kind := lexerKindSemicolon
end; end;
if lexer^.Current^ = ',' then if lexer^.Current^ = ',' then
AToken^.Kind := lexerKindComma token^.kind := lexerKindComma
end; end;
if lexer^.Current^ = ',' then if lexer^.Current^ = ',' then
AToken^.Kind := lexerKindComma token^.kind := lexerKindComma
end; end;
if lexer^.Current^ = ')' then if lexer^.Current^ = ')' then
AToken^.Kind := lexerKindRightParen token^.kind := lexerKindRightParen
end; end;
if lexer^.Current^ = '[' then if lexer^.Current^ = '[' then
AToken^.Kind := lexerKindLeftSquare token^.kind := lexerKindLeftSquare
end; end;
if lexer^.Current^ = ']' then if lexer^.Current^ = ']' then
AToken^.Kind := lexerKindRightSquare token^.kind := lexerKindRightSquare
end; end;
if lexer^.Current^ = '^' then if lexer^.Current^ = '^' then
AToken^.Kind := lexerKindHat token^.kind := lexerKindHat
end; end;
if lexer^.Current^ = '=' then if lexer^.Current^ = '=' then
AToken^.Kind := lexerKindEqual token^.kind := lexerKindEqual
end; end;
if lexer^.Current^ = '+' then if lexer^.Current^ = '+' then
AToken^.Kind := lexerKindPlus token^.kind := lexerKindPlus
end; end;
if lexer^.Current^ = '/' then if lexer^.Current^ = '/' then
AToken^.Kind := lexerKindDivision token^.kind := lexerKindDivision
end; end;
if lexer^.Current^ = '%' then if lexer^.Current^ = '%' then
AToken^.Kind := lexerKindRemainder token^.kind := lexerKindRemainder
end; end;
if lexer^.Current^ = '@' then if lexer^.Current^ = '@' then
AToken^.Kind := lexerKindAt token^.kind := lexerKindAt
end; end;
if lexer^.Current^ = '|' then if lexer^.Current^ = '|' then
AToken^.Kind := lexerKindPipe token^.kind := lexerKindPipe
end; end;
INC(lexer^.Current) INC(lexer^.Current)
end; end;
(* Handle an integer literal. *) (* Handle an integer literal. *)
proc transition_action_integer(lexer: PLexer, AToken: PLexerToken); proc transition_action_integer(lexer: PLexer, token: PLexerToken);
begin begin
AToken^.Kind := lexerKindInteger token^.kind := lexerKindInteger
end; end;
proc set_default_transition(CurrentState: TransitionState, DefaultAction: TransitionAction, NextState: TransitionState); proc set_default_transition(CurrentState: TransitionState, DefaultAction: TransitionAction, NextState: TransitionState);
@ -756,12 +767,12 @@ begin
lexer^.Size := CHUNK_SIZE lexer^.Size := CHUNK_SIZE
end; end;
proc lexer_current(lexer: PLexer): LexerToken; proc lexer_current(lexer: PLexer) -> LexerToken;
var 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 +782,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 +799,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);

347
source/Transpiler.elna
View File

@ -13,13 +13,13 @@ type
end; end;
(* Calls lexer_lex() but skips the comments. *) (* Calls lexer_lex() but skips the comments. *)
proc transpiler_lex(lexer: PLexer): LexerToken; proc transpiler_lex(lexer: PLexer) -> LexerToken;
var var
result: LexerToken; result: LexerToken;
begin begin
result := lexer_lex(lexer); result := lexer_lex(lexer);
while result.Kind = lexerKindComment do while result.kind = lexerKindComment do
result := lexer_lex(lexer) result := lexer_lex(lexer)
end; end;
@ -50,7 +50,7 @@ begin
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 <> lexerKindSemicolon do while token.kind <> lexerKindSemicolon do
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);
@ -66,7 +66,7 @@ var
begin begin
token := lexer_current(lexer); token := lexer_current(lexer);
while token.Kind = lexerKindFrom do while token.kind = lexerKindFrom do
transpile_import(context, lexer); transpile_import(context, lexer);
token := lexer_current(lexer) token := lexer_current(lexer)
end; end;
@ -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;
@ -333,12 +333,12 @@ var
begin begin
token := lexer_current(lexer); token := lexer_current(lexer);
if token.Kind = lexerKindType then if token.kind = lexerKindType then
WriteString('TYPE'); WriteString('TYPE');
WriteLn(); WriteLn();
token := transpiler_lex(lexer); token := transpiler_lex(lexer);
while token.Kind = lexerKindIdentifier do while token.kind = lexerKindIdentifier do
transpile_type_declaration(context, lexer); transpile_type_declaration(context, lexer);
token := transpiler_lex(lexer) token := transpiler_lex(lexer)
end; end;
@ -348,42 +348,42 @@ 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
end; end;
proc transpile_procedure_heading(context: PTranspilerContext, lexer: PLexer): LexerToken; proc transpile_procedure_heading(context: PTranspilerContext, lexer: PLexer) -> LexerToken;
var var
token: LexerToken; token: LexerToken;
result: LexerToken; result: LexerToken;
@ -398,7 +398,7 @@ begin
Write('('); Write('(');
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);
@ -407,7 +407,7 @@ begin
transpile_type_expression(context, lexer); transpile_type_expression(context, lexer);
token := transpiler_lex(lexer); token := transpiler_lex(lexer);
if (token.Kind = lexerKindSemicolon) or (token.Kind = lexerKindComma) then if (token.kind = lexerKindSemicolon) or (token.kind = lexerKindComma) then
WriteString('; '); WriteString('; ');
token := transpiler_lex(lexer) token := transpiler_lex(lexer)
end end
@ -416,7 +416,7 @@ begin
token := transpiler_lex(lexer); token := transpiler_lex(lexer);
(* Check for the return type and write it. *) (* Check for the return type and write it. *)
if token.Kind = lexerKindColon then if token.kind = lexerKindArrow then
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);
@ -428,28 +428,28 @@ 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 ');
written_bytes := 1 written_bytes := 1
end; end;
if token.Kind = lexerKindOr then if token.kind = lexerKindOr then
WriteString('OR '); WriteString('OR ');
written_bytes := 1 written_bytes := 1
end; end;
if token.Kind = lexerKindAnd then if token.kind = lexerKindAnd then
WriteString('AND '); WriteString('AND ');
written_bytes := 1 written_bytes := 1
end; end;
if token.Kind = lexerKindNot then if token.kind = lexerKindNot then
WriteString('NOT '); WriteString('NOT ');
written_bytes := 1 written_bytes := 1
end; end;
@ -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,72 @@ 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;
proc transpile_designator_expression(context: PTranspilerContext, lexer: PLexer);
var
token: LexerToken;
written_bytes: CARDINAL;
begin
WriteString(' ');
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
token := transpiler_lex(lexer);
while token.kind = lexerKindLeftSquare do
Write('[');
token := transpiler_lex(lexer);
while token.kind <> lexerKindRightSquare do
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
token := transpiler_lex(lexer)
end;
Write(']');
token := transpiler_lex(lexer)
end;
if token.kind = lexerKindHat then
Write('^');
token := transpiler_lex(lexer)
end;
if token.kind = lexerKindDot then
Write('.');
token := transpiler_lex(lexer);
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
token := transpiler_lex(lexer)
end;
if token.kind = lexerKindHat then
Write('^');
token := transpiler_lex(lexer)
end;
while token.kind = lexerKindLeftSquare do
Write('[');
token := transpiler_lex(lexer);
while token.kind <> lexerKindRightSquare do
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
token := transpiler_lex(lexer)
end;
Write(']');
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);
@ -529,59 +574,23 @@ var
begin begin
token := transpiler_lex(lexer); token := transpiler_lex(lexer);
if token.Kind = lexerKindIf then if token.kind = lexerKindIf then
transpile_if_statement(context, lexer) transpile_if_statement(context, lexer)
end; end;
if token.Kind = lexerKindWhile then if token.kind = lexerKindWhile then
transpile_while_statement(context, lexer) transpile_while_statement(context, lexer)
end; end;
if token.Kind = lexerKindReturn then if token.kind = lexerKindReturn then
transpile_return_statement(context, lexer) transpile_return_statement(context, lexer)
end; end;
if token.Kind = lexerKindIdentifier then if token.kind = lexerKindIdentifier then
WriteString(' '); transpile_designator_expression(context, lexer);
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start); token := lexer_current(lexer);
token := transpiler_lex(lexer);
while token.Kind = lexerKindLeftSquare do if token.kind = lexerKindAssignment then
Write('[');
token := transpiler_lex(lexer);
while token.Kind <> lexerKindRightSquare do
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
token := transpiler_lex(lexer)
end;
Write(']');
token := transpiler_lex(lexer);
end;
if token.Kind = lexerKindHat then
Write('^');
token := transpiler_lex(lexer)
end;
if token.Kind = lexerKindDot then
Write('.');
token := transpiler_lex(lexer);
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
token := transpiler_lex(lexer);
end;
if token.Kind = lexerKindHat then
Write('^');
token := transpiler_lex(lexer)
end;
while token.Kind = lexerKindLeftSquare do
Write('[');
token := transpiler_lex(lexer);
while token.Kind <> lexerKindRightSquare do
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
token := transpiler_lex(lexer)
end;
Write(']');
token := transpiler_lex(lexer);
end;
if token.Kind = lexerKindAssignment then
transpile_assignment_statement(context, lexer) transpile_assignment_statement(context, lexer)
end; end;
if token.Kind = lexerKindLeftParen then if token.kind = lexerKindLeftParen then
transpile_call_statement(context, lexer) transpile_call_statement(context, lexer)
end end
end end
@ -589,15 +598,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 +615,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,43 +627,43 @@ 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
transpile_module(ADR(Context), lexer) transpile_module(ADR(context), lexer)
end; end;
end Transpiler. end Transpiler.