Handle ASCII codes > 128 in the tokenizer
This commit is contained in:
parent
4eccc147ba
commit
6e415e474f
1
Rakefile
1
Rakefile
@ -107,6 +107,7 @@ task :backport do
|
||||
.gsub(/\b(record|nil|or)\b/) { |match| match.upcase }
|
||||
.gsub(/proc\(/, 'PROCEDURE(')
|
||||
.gsub(/ & /, ' AND ')
|
||||
.gsub(/ -> /, ': ')
|
||||
.gsub(/([[:space:]]*)end(;?)$/, '\1END\2')
|
||||
.gsub(/^([[:space:]]*)(while|return|if)\b/) { |match| match.upcase }
|
||||
.gsub(/^from ([[:alnum:]]+) import/, 'FROM \1 IMPORT')
|
||||
|
@ -73,13 +73,13 @@ TYPE
|
||||
lexerKindFrom,
|
||||
lexerKindPointer,
|
||||
lexerKindArray,
|
||||
lexerKindTrait,
|
||||
lexerKindArrow,
|
||||
lexerKindProgram,
|
||||
lexerKindModule,
|
||||
lexerKindImport
|
||||
);
|
||||
LexerToken = RECORD
|
||||
CASE Kind: LexerKind OF
|
||||
CASE kind: LexerKind OF
|
||||
lexerKindBoolean: booleanKind: BOOLEAN |
|
||||
lexerKindIdentifier: identifierKind: ARRAY[1..256] OF CHAR
|
||||
END
|
||||
|
@ -72,6 +72,8 @@ var
|
||||
transitions: [16]TransitionClasses;
|
||||
|
||||
proc initialize_classification();
|
||||
var
|
||||
i: CARDINAL;
|
||||
begin
|
||||
classification[1] := transitionClassEof; (* NUL *)
|
||||
classification[2] := transitionClassInvalid; (* SOH *)
|
||||
@ -200,265 +202,274 @@ begin
|
||||
classification[125] := transitionClassSingle; (* | *)
|
||||
classification[126] := transitionClassOther; (* } *)
|
||||
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;
|
||||
|
||||
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
|
||||
Result: BOOLEAN;
|
||||
Index: CARDINAL;
|
||||
result: BOOLEAN;
|
||||
index: CARDINAL;
|
||||
begin
|
||||
Index := 0;
|
||||
Result := TRUE;
|
||||
index := 0;
|
||||
result := TRUE;
|
||||
|
||||
while (Index < Length(Keyword)) & (TokenStart <> TokenEnd) & Result DO
|
||||
Result := (Keyword[Index] = TokenStart^) or (Lower(Keyword[Index]) = TokenStart^);
|
||||
while (index < Length(Keyword)) & (TokenStart <> TokenEnd) & result DO
|
||||
result := (Keyword[index] = TokenStart^) or (Lower(Keyword[index]) = TokenStart^);
|
||||
INC(TokenStart);
|
||||
INC(Index)
|
||||
INC(index)
|
||||
end;
|
||||
Result := (Index = Length(Keyword)) & (TokenStart = TokenEnd) & Result;
|
||||
return Result
|
||||
result := (index = Length(Keyword)) & (TokenStart = TokenEnd) & result;
|
||||
return result
|
||||
end;
|
||||
|
||||
(* Reached the end of file. *)
|
||||
proc transition_action_eof(lexer: PLexer, AToken: PLexerToken);
|
||||
proc transition_action_eof(lexer: PLexer, token: PLexerToken);
|
||||
begin
|
||||
AToken^.Kind := lexerKindEof
|
||||
token^.kind := lexerKindEof
|
||||
end;
|
||||
|
||||
(* 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
|
||||
INC(lexer^.Current)
|
||||
end;
|
||||
|
||||
(* The current character is not a part of the token. Finish the token already
|
||||
* 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
|
||||
if lexer^.Start^ = ':' then
|
||||
AToken^.Kind := lexerKindColon
|
||||
token^.kind := lexerKindColon
|
||||
end;
|
||||
if lexer^.Start^ = '>' then
|
||||
AToken^.Kind := lexerKindGreaterThan
|
||||
token^.kind := lexerKindGreaterThan
|
||||
end;
|
||||
if lexer^.Start^ = '<' then
|
||||
AToken^.Kind := lexerKindLessThan
|
||||
token^.kind := lexerKindLessThan
|
||||
end;
|
||||
if lexer^.Start^ = '(' then
|
||||
AToken^.Kind := lexerKindLeftParen
|
||||
token^.kind := lexerKindLeftParen
|
||||
end;
|
||||
if lexer^.Start^ = '-' then
|
||||
AToken^.Kind := lexerKindLeftParen
|
||||
token^.kind := lexerKindLeftParen
|
||||
end;
|
||||
if lexer^.Start^ = '.' then
|
||||
AToken^.Kind := lexerKindDot
|
||||
token^.kind := lexerKindDot
|
||||
end
|
||||
end;
|
||||
|
||||
(* An action for tokens containing multiple characters. *)
|
||||
proc transition_action_composite(lexer: PLexer, AToken: PLexerToken);
|
||||
proc transition_action_composite(lexer: PLexer, token: PLexerToken);
|
||||
begin
|
||||
if lexer^.Start^ = '<' then
|
||||
if lexer^.Current^ = '>' then
|
||||
AToken^.Kind := lexerKindNotEqual
|
||||
token^.kind := lexerKindNotEqual
|
||||
end;
|
||||
if lexer^.Current^ = '=' then
|
||||
AToken^.Kind := lexerKindLessEqual
|
||||
token^.kind := lexerKindLessEqual
|
||||
end
|
||||
end;
|
||||
if (lexer^.Start^ = '>') & (lexer^.Current^ = '=') then
|
||||
AToken^.Kind := lexerKindGreaterEqual
|
||||
token^.kind := lexerKindGreaterEqual
|
||||
end;
|
||||
if (lexer^.Start^ = '.') & (lexer^.Current^ = '.') then
|
||||
AToken^.Kind := lexerKindRange
|
||||
token^.kind := lexerKindRange
|
||||
end;
|
||||
if (lexer^.Start^ = ':') & (lexer^.Current^ = '=') then
|
||||
AToken^.Kind := lexerKindAssignment
|
||||
token^.kind := lexerKindAssignment
|
||||
end;
|
||||
if (lexer^.Start^ = '-') & (lexer^.Current^ = '>') then
|
||||
token^.kind := lexerKindArrow
|
||||
end;
|
||||
INC(lexer^.Current)
|
||||
end;
|
||||
|
||||
(* Skip a space. *)
|
||||
proc transition_action_skip(lexer: PLexer, AToken: PLexerToken);
|
||||
proc transition_action_skip(lexer: PLexer, token: PLexerToken);
|
||||
begin
|
||||
INC(lexer^.Current);
|
||||
INC(lexer^.Start)
|
||||
end;
|
||||
|
||||
(* Delimited string action. *)
|
||||
proc transition_action_delimited(lexer: PLexer, AToken: PLexerToken);
|
||||
proc transition_action_delimited(lexer: PLexer, token: PLexerToken);
|
||||
begin
|
||||
if lexer^.Start^ = '(' then
|
||||
AToken^.Kind := lexerKindComment
|
||||
token^.kind := lexerKindComment
|
||||
end;
|
||||
if lexer^.Start^ = '"' then
|
||||
AToken^.Kind := lexerKindCharacter
|
||||
token^.kind := lexerKindCharacter
|
||||
end;
|
||||
if lexer^.Start^ = "'" then
|
||||
AToken^.Kind := lexerKindString
|
||||
token^.kind := lexerKindString
|
||||
end;
|
||||
INC(lexer^.Current)
|
||||
end;
|
||||
|
||||
(* Finalize keyword or identifier. *)
|
||||
proc transition_action_key_id(lexer: PLexer, AToken: PLexerToken);
|
||||
proc transition_action_key_id(lexer: PLexer, token: PLexerToken);
|
||||
begin
|
||||
AToken^.Kind := lexerKindIdentifier;
|
||||
token^.kind := lexerKindIdentifier;
|
||||
|
||||
AToken^.identifierKind[1] := lexer^.Current - lexer^.Start;
|
||||
MemCopy(lexer^.Start, ORD(AToken^.identifierKind[1]), ADR(AToken^.identifierKind[2]));
|
||||
token^.identifierKind[1] := lexer^.Current - lexer^.Start;
|
||||
MemCopy(lexer^.Start, ORD(token^.identifierKind[1]), ADR(token^.identifierKind[2]));
|
||||
|
||||
if compare_keyword('PROGRAM', lexer^.Start, lexer^.Current) then
|
||||
AToken^.Kind := lexerKindProgram
|
||||
token^.kind := lexerKindProgram
|
||||
end;
|
||||
if compare_keyword('IMPORT', lexer^.Start, lexer^.Current) then
|
||||
AToken^.Kind := lexerKindImport
|
||||
token^.kind := lexerKindImport
|
||||
end;
|
||||
if compare_keyword('CONST', lexer^.Start, lexer^.Current) then
|
||||
AToken^.Kind := lexerKindConst
|
||||
token^.kind := lexerKindConst
|
||||
end;
|
||||
if compare_keyword('VAR', lexer^.Start, lexer^.Current) then
|
||||
AToken^.Kind := lexerKindVar
|
||||
token^.kind := lexerKindVar
|
||||
end;
|
||||
if compare_keyword('IF', lexer^.Start, lexer^.Current) then
|
||||
AToken^.Kind := lexerKindIf
|
||||
token^.kind := lexerKindIf
|
||||
end;
|
||||
if compare_keyword('THEN', lexer^.Start, lexer^.Current) then
|
||||
AToken^.Kind := lexerKindThen
|
||||
token^.kind := lexerKindThen
|
||||
end;
|
||||
if compare_keyword('ELSIF', lexer^.Start, lexer^.Current) then
|
||||
AToken^.Kind := lexerKindElsif
|
||||
token^.kind := lexerKindElsif
|
||||
end;
|
||||
if compare_keyword('ELSE', lexer^.Start, lexer^.Current) then
|
||||
AToken^.Kind := lexerKindElse
|
||||
token^.kind := lexerKindElse
|
||||
end;
|
||||
if compare_keyword('WHILE', lexer^.Start, lexer^.Current) then
|
||||
AToken^.Kind := lexerKindWhile
|
||||
token^.kind := lexerKindWhile
|
||||
end;
|
||||
if compare_keyword('DO', lexer^.Start, lexer^.Current) then
|
||||
AToken^.Kind := lexerKindDo
|
||||
token^.kind := lexerKindDo
|
||||
end;
|
||||
if compare_keyword('proc', lexer^.Start, lexer^.Current) then
|
||||
AToken^.Kind := lexerKindProc
|
||||
token^.kind := lexerKindProc
|
||||
end;
|
||||
if compare_keyword('BEGIN', lexer^.Start, lexer^.Current) then
|
||||
AToken^.Kind := lexerKindBegin
|
||||
token^.kind := lexerKindBegin
|
||||
end;
|
||||
if compare_keyword('END', lexer^.Start, lexer^.Current) then
|
||||
AToken^.Kind := lexerKindEnd
|
||||
token^.kind := lexerKindEnd
|
||||
end;
|
||||
if compare_keyword('TYPE', lexer^.Start, lexer^.Current) then
|
||||
AToken^.Kind := lexerKindType
|
||||
token^.kind := lexerKindType
|
||||
end;
|
||||
if compare_keyword('RECORD', lexer^.Start, lexer^.Current) then
|
||||
AToken^.Kind := lexerKindRecord
|
||||
token^.kind := lexerKindRecord
|
||||
end;
|
||||
if compare_keyword('UNION', lexer^.Start, lexer^.Current) then
|
||||
AToken^.Kind := lexerKindUnion
|
||||
token^.kind := lexerKindUnion
|
||||
end;
|
||||
if compare_keyword('NIL', lexer^.Start, lexer^.Current) then
|
||||
AToken^.Kind := lexerKindNull
|
||||
token^.kind := lexerKindNull
|
||||
end;
|
||||
if compare_keyword('AND', lexer^.Start, lexer^.Current) then
|
||||
AToken^.Kind := lexerKindAnd
|
||||
token^.kind := lexerKindAnd
|
||||
end;
|
||||
if compare_keyword('OR', lexer^.Start, lexer^.Current) then
|
||||
AToken^.Kind := lexerKindOr
|
||||
token^.kind := lexerKindOr
|
||||
end;
|
||||
if compare_keyword('RETURN', lexer^.Start, lexer^.Current) then
|
||||
AToken^.Kind := lexerKindReturn
|
||||
token^.kind := lexerKindReturn
|
||||
end;
|
||||
if compare_keyword('DEFINITION', lexer^.Start, lexer^.Current) then
|
||||
AToken^.Kind := lexerKindDefinition
|
||||
token^.kind := lexerKindDefinition
|
||||
end;
|
||||
if compare_keyword('TO', lexer^.Start, lexer^.Current) then
|
||||
AToken^.Kind := lexerKindTo
|
||||
token^.kind := lexerKindTo
|
||||
end;
|
||||
if compare_keyword('CASE', lexer^.Start, lexer^.Current) then
|
||||
AToken^.Kind := lexerKindCase
|
||||
token^.kind := lexerKindCase
|
||||
end;
|
||||
if compare_keyword('OF', lexer^.Start, lexer^.Current) then
|
||||
AToken^.Kind := lexerKindOf
|
||||
token^.kind := lexerKindOf
|
||||
end;
|
||||
if compare_keyword('FROM', lexer^.Start, lexer^.Current) then
|
||||
AToken^.Kind := lexerKindFrom
|
||||
token^.kind := lexerKindFrom
|
||||
end;
|
||||
if compare_keyword('MODULE', lexer^.Start, lexer^.Current) then
|
||||
AToken^.Kind := lexerKindModule
|
||||
token^.kind := lexerKindModule
|
||||
end;
|
||||
if compare_keyword('IMPLEMENTATION', lexer^.Start, lexer^.Current) then
|
||||
AToken^.Kind := lexerKindImplementation
|
||||
token^.kind := lexerKindImplementation
|
||||
end;
|
||||
if compare_keyword('POINTER', lexer^.Start, lexer^.Current) then
|
||||
AToken^.Kind := lexerKindPointer
|
||||
token^.kind := lexerKindPointer
|
||||
end;
|
||||
if compare_keyword('ARRAY', lexer^.Start, lexer^.Current) then
|
||||
AToken^.Kind := lexerKindArray
|
||||
token^.kind := lexerKindArray
|
||||
end;
|
||||
if compare_keyword('TRUE', lexer^.Start, lexer^.Current) then
|
||||
AToken^.Kind := lexerKindBoolean;
|
||||
AToken^.booleanKind := TRUE
|
||||
token^.kind := lexerKindBoolean;
|
||||
token^.booleanKind := TRUE
|
||||
end;
|
||||
if compare_keyword('FALSE', lexer^.Start, lexer^.Current) then
|
||||
AToken^.Kind := lexerKindBoolean;
|
||||
AToken^.booleanKind := FALSE
|
||||
token^.kind := lexerKindBoolean;
|
||||
token^.booleanKind := FALSE
|
||||
end
|
||||
end;
|
||||
|
||||
(* Action for tokens containing only one character. The character cannot be
|
||||
* 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
|
||||
if lexer^.Current^ = '&' then
|
||||
AToken^.Kind := lexerKindAnd
|
||||
token^.kind := lexerKindAnd
|
||||
end;
|
||||
if lexer^.Current^ = ';' then
|
||||
AToken^.Kind := lexerKindSemicolon
|
||||
token^.kind := lexerKindSemicolon
|
||||
end;
|
||||
if lexer^.Current^ = ',' then
|
||||
AToken^.Kind := lexerKindComma
|
||||
token^.kind := lexerKindComma
|
||||
end;
|
||||
if lexer^.Current^ = ',' then
|
||||
AToken^.Kind := lexerKindComma
|
||||
token^.kind := lexerKindComma
|
||||
end;
|
||||
if lexer^.Current^ = ')' then
|
||||
AToken^.Kind := lexerKindRightParen
|
||||
token^.kind := lexerKindRightParen
|
||||
end;
|
||||
if lexer^.Current^ = '[' then
|
||||
AToken^.Kind := lexerKindLeftSquare
|
||||
token^.kind := lexerKindLeftSquare
|
||||
end;
|
||||
if lexer^.Current^ = ']' then
|
||||
AToken^.Kind := lexerKindRightSquare
|
||||
token^.kind := lexerKindRightSquare
|
||||
end;
|
||||
if lexer^.Current^ = '^' then
|
||||
AToken^.Kind := lexerKindHat
|
||||
token^.kind := lexerKindHat
|
||||
end;
|
||||
if lexer^.Current^ = '=' then
|
||||
AToken^.Kind := lexerKindEqual
|
||||
token^.kind := lexerKindEqual
|
||||
end;
|
||||
if lexer^.Current^ = '+' then
|
||||
AToken^.Kind := lexerKindPlus
|
||||
token^.kind := lexerKindPlus
|
||||
end;
|
||||
if lexer^.Current^ = '/' then
|
||||
AToken^.Kind := lexerKindDivision
|
||||
token^.kind := lexerKindDivision
|
||||
end;
|
||||
if lexer^.Current^ = '%' then
|
||||
AToken^.Kind := lexerKindRemainder
|
||||
token^.kind := lexerKindRemainder
|
||||
end;
|
||||
if lexer^.Current^ = '@' then
|
||||
AToken^.Kind := lexerKindAt
|
||||
token^.kind := lexerKindAt
|
||||
end;
|
||||
if lexer^.Current^ = '|' then
|
||||
AToken^.Kind := lexerKindPipe
|
||||
token^.kind := lexerKindPipe
|
||||
end;
|
||||
INC(lexer^.Current)
|
||||
end;
|
||||
|
||||
(* Handle an integer literal. *)
|
||||
proc transition_action_integer(lexer: PLexer, AToken: PLexerToken);
|
||||
proc transition_action_integer(lexer: PLexer, token: PLexerToken);
|
||||
begin
|
||||
AToken^.Kind := lexerKindInteger
|
||||
token^.kind := lexerKindInteger
|
||||
end;
|
||||
|
||||
proc set_default_transition(CurrentState: TransitionState, DefaultAction: TransitionAction, NextState: TransitionState);
|
||||
@ -756,12 +767,12 @@ begin
|
||||
lexer^.Size := CHUNK_SIZE
|
||||
end;
|
||||
|
||||
proc lexer_current(lexer: PLexer): LexerToken;
|
||||
proc lexer_current(lexer: PLexer) -> LexerToken;
|
||||
var
|
||||
CurrentClass: TransitionClass;
|
||||
CurrentState: TransitionState;
|
||||
CurrentTransition: Transition;
|
||||
Result: LexerToken;
|
||||
result: LexerToken;
|
||||
begin
|
||||
lexer^.Current := lexer^.Start;
|
||||
CurrentState := transitionStateStart;
|
||||
@ -771,16 +782,16 @@ begin
|
||||
|
||||
CurrentTransition := transitions[ORD(CurrentState) + 1][ORD(CurrentClass) + 1];
|
||||
if CurrentTransition.Action <> nil then
|
||||
CurrentTransition.Action(lexer, ADR(Result))
|
||||
CurrentTransition.Action(lexer, ADR(result))
|
||||
end;
|
||||
CurrentState := CurrentTransition.NextState
|
||||
end;
|
||||
return Result
|
||||
return result
|
||||
end;
|
||||
|
||||
proc lexer_lex(lexer: PLexer): LexerToken;
|
||||
proc lexer_lex(lexer: PLexer) -> LexerToken;
|
||||
var
|
||||
Result: LexerToken;
|
||||
result: LexerToken;
|
||||
begin
|
||||
if lexer^.Length = 0 then
|
||||
lexer^.Length := ReadNBytes(lexer^.Input, CHUNK_SIZE, lexer^.Buffer);
|
||||
@ -788,8 +799,8 @@ begin
|
||||
end;
|
||||
lexer^.Start := lexer^.Current;
|
||||
|
||||
Result := lexer_current(lexer);
|
||||
return Result
|
||||
result := lexer_current(lexer);
|
||||
return result
|
||||
end;
|
||||
|
||||
proc lexer_destroy(lexer: PLexer);
|
||||
|
@ -13,13 +13,13 @@ type
|
||||
end;
|
||||
|
||||
(* Calls lexer_lex() but skips the comments. *)
|
||||
proc transpiler_lex(lexer: PLexer): LexerToken;
|
||||
proc transpiler_lex(lexer: PLexer) -> LexerToken;
|
||||
var
|
||||
result: LexerToken;
|
||||
begin
|
||||
result := lexer_lex(lexer);
|
||||
|
||||
while result.Kind = lexerKindComment do
|
||||
while result.kind = lexerKindComment do
|
||||
result := lexer_lex(lexer)
|
||||
end;
|
||||
|
||||
@ -50,7 +50,7 @@ begin
|
||||
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
|
||||
|
||||
token := transpiler_lex(lexer);
|
||||
while token.Kind <> lexerKindSemicolon do
|
||||
while token.kind <> lexerKindSemicolon do
|
||||
WriteString(', ');
|
||||
token := transpiler_lex(lexer);
|
||||
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
|
||||
@ -66,7 +66,7 @@ var
|
||||
begin
|
||||
token := lexer_current(lexer);
|
||||
|
||||
while token.Kind = lexerKindFrom do
|
||||
while token.kind = lexerKindFrom do
|
||||
transpile_import(context, lexer);
|
||||
token := lexer_current(lexer)
|
||||
end;
|
||||
@ -75,39 +75,39 @@ end;
|
||||
|
||||
proc transpile_constant(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
token: LexerToken;
|
||||
written_bytes: CARDINAL;
|
||||
begin
|
||||
WriteString(' ');
|
||||
Token := lexer_current(lexer);
|
||||
token := lexer_current(lexer);
|
||||
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
|
||||
|
||||
Token := transpiler_lex(lexer);
|
||||
token := transpiler_lex(lexer);
|
||||
WriteString(' = ');
|
||||
|
||||
Token := transpiler_lex(lexer);
|
||||
token := transpiler_lex(lexer);
|
||||
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
|
||||
|
||||
Token := transpiler_lex(lexer);
|
||||
token := transpiler_lex(lexer);
|
||||
write_semicolon()
|
||||
end;
|
||||
|
||||
proc transpile_constant_part(context: PTranspilerContext, lexer: PLexer): BOOLEAN;
|
||||
proc transpile_constant_part(context: PTranspilerContext, lexer: PLexer) -> BOOLEAN;
|
||||
var
|
||||
Token: LexerToken;
|
||||
token: LexerToken;
|
||||
result: BOOLEAN;
|
||||
begin
|
||||
Token := lexer_current(lexer);
|
||||
result := Token.Kind = lexerKindConst;
|
||||
token := lexer_current(lexer);
|
||||
result := token.kind = lexerKindConst;
|
||||
|
||||
if result then
|
||||
WriteString('CONST');
|
||||
WriteLn();
|
||||
Token := transpiler_lex(lexer);
|
||||
token := transpiler_lex(lexer);
|
||||
|
||||
while Token.Kind = lexerKindIdentifier do
|
||||
while token.kind = lexerKindIdentifier do
|
||||
transpile_constant(context, lexer);
|
||||
Token := transpiler_lex(lexer)
|
||||
token := transpiler_lex(lexer)
|
||||
end
|
||||
end;
|
||||
return result
|
||||
@ -115,31 +115,31 @@ end;
|
||||
|
||||
proc transpile_module(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
token: LexerToken;
|
||||
written_bytes: CARDINAL;
|
||||
begin
|
||||
Token := transpiler_lex(lexer);
|
||||
token := transpiler_lex(lexer);
|
||||
|
||||
if Token.Kind = lexerKindDefinition then
|
||||
if token.kind = lexerKindDefinition then
|
||||
WriteString('DEFINITION ');
|
||||
Token := transpiler_lex(lexer)
|
||||
token := transpiler_lex(lexer)
|
||||
end;
|
||||
if Token.Kind = lexerKindImplementation then
|
||||
if token.kind = lexerKindImplementation then
|
||||
WriteString('IMPLEMENTATION ');
|
||||
Token := transpiler_lex(lexer)
|
||||
token := transpiler_lex(lexer)
|
||||
end;
|
||||
WriteString('MODULE ');
|
||||
|
||||
(* 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);
|
||||
|
||||
Token := transpiler_lex(lexer);
|
||||
token := transpiler_lex(lexer);
|
||||
write_semicolon();
|
||||
WriteLn();
|
||||
|
||||
(* Write the module body. *)
|
||||
Token := transpiler_lex(lexer);
|
||||
token := transpiler_lex(lexer);
|
||||
transpile_import_part(context, lexer);
|
||||
if transpile_constant_part(context, lexer) then
|
||||
WriteLn()
|
||||
@ -153,33 +153,33 @@ begin
|
||||
|
||||
WriteString('END ');
|
||||
|
||||
Token := transpiler_lex(lexer);
|
||||
token := transpiler_lex(lexer);
|
||||
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
|
||||
|
||||
Token := transpiler_lex(lexer);
|
||||
token := transpiler_lex(lexer);
|
||||
Write('.');
|
||||
|
||||
Token := transpiler_lex(lexer);
|
||||
token := transpiler_lex(lexer);
|
||||
WriteLn()
|
||||
end;
|
||||
|
||||
proc transpile_type_fields(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
token: LexerToken;
|
||||
written_bytes: CARDINAL;
|
||||
begin
|
||||
Token := transpiler_lex(lexer);
|
||||
token := transpiler_lex(lexer);
|
||||
|
||||
while Token.Kind <> lexerKindEnd do
|
||||
while token.kind <> lexerKindEnd do
|
||||
WriteString(' ');
|
||||
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
|
||||
Token := transpiler_lex(lexer);
|
||||
token := transpiler_lex(lexer);
|
||||
WriteString(': ');
|
||||
transpile_type_expression(context, lexer);
|
||||
Token := transpiler_lex(lexer);
|
||||
token := transpiler_lex(lexer);
|
||||
|
||||
if Token.Kind = lexerKindSemicolon then
|
||||
Token := transpiler_lex(lexer);
|
||||
if token.kind = lexerKindSemicolon then
|
||||
token := transpiler_lex(lexer);
|
||||
Write(';')
|
||||
end;
|
||||
WriteLn()
|
||||
@ -188,7 +188,7 @@ end;
|
||||
|
||||
proc transpile_record_type(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
token: LexerToken;
|
||||
begin
|
||||
WriteString('RECORD');
|
||||
WriteLn();
|
||||
@ -198,33 +198,33 @@ end;
|
||||
|
||||
proc transpile_pointer_type(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
token: LexerToken;
|
||||
written_bytes: CARDINAL;
|
||||
begin
|
||||
Token := lexer_current(lexer);
|
||||
token := lexer_current(lexer);
|
||||
WriteString('POINTER TO ');
|
||||
if Token.Kind = lexerKindPointer then
|
||||
Token := transpiler_lex(lexer)
|
||||
if token.kind = lexerKindPointer then
|
||||
token := transpiler_lex(lexer)
|
||||
end;
|
||||
transpile_type_expression(context, lexer)
|
||||
end;
|
||||
|
||||
proc transpile_array_type(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
token: LexerToken;
|
||||
written_bytes: CARDINAL;
|
||||
begin
|
||||
WriteString('ARRAY');
|
||||
Token := lexer_current(lexer);
|
||||
token := lexer_current(lexer);
|
||||
|
||||
if Token.Kind = lexerKindArray then
|
||||
Token := transpiler_lex(lexer)
|
||||
if token.kind = lexerKindArray then
|
||||
token := transpiler_lex(lexer)
|
||||
end;
|
||||
if Token.Kind <> lexerKindOf then
|
||||
if token.kind <> lexerKindOf then
|
||||
WriteString('[1..');
|
||||
Token := transpiler_lex(lexer);
|
||||
token := transpiler_lex(lexer);
|
||||
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
|
||||
Token := transpiler_lex(lexer);
|
||||
token := transpiler_lex(lexer);
|
||||
Write(']')
|
||||
end;
|
||||
WriteString(' OF ');
|
||||
@ -233,26 +233,26 @@ end;
|
||||
|
||||
proc transpile_enumeration_type(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
token: LexerToken;
|
||||
written_bytes: CARDINAL;
|
||||
begin
|
||||
WriteString('(');
|
||||
WriteLn();
|
||||
WriteString(' ');
|
||||
|
||||
Token := transpiler_lex(lexer);
|
||||
token := transpiler_lex(lexer);
|
||||
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(',');
|
||||
WriteLn();
|
||||
WriteString(' ');
|
||||
Token := transpiler_lex(lexer);
|
||||
token := transpiler_lex(lexer);
|
||||
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
|
||||
|
||||
Token := transpiler_lex(lexer)
|
||||
token := transpiler_lex(lexer)
|
||||
end;
|
||||
WriteLn();
|
||||
WriteString(' )')
|
||||
@ -260,25 +260,25 @@ end;
|
||||
|
||||
proc transpile_union_type(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
token: LexerToken;
|
||||
end;
|
||||
|
||||
proc transpile_procedure_type(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
token: LexerToken;
|
||||
written_bytes: CARDINAL;
|
||||
begin
|
||||
Token := transpiler_lex(lexer);
|
||||
token := transpiler_lex(lexer);
|
||||
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);
|
||||
|
||||
Token := transpiler_lex(lexer);
|
||||
if Token.Kind = lexerKindComma then
|
||||
Token := transpiler_lex(lexer);
|
||||
token := transpiler_lex(lexer);
|
||||
if token.kind = lexerKindComma then
|
||||
token := transpiler_lex(lexer);
|
||||
WriteString(', ')
|
||||
end
|
||||
end;
|
||||
@ -287,43 +287,43 @@ end;
|
||||
|
||||
proc transpile_type_expression(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
token: LexerToken;
|
||||
written_bytes: CARDINAL;
|
||||
begin
|
||||
Token := transpiler_lex(lexer);
|
||||
if Token.Kind = lexerKindRecord then
|
||||
token := transpiler_lex(lexer);
|
||||
if token.kind = lexerKindRecord then
|
||||
transpile_record_type(context, lexer)
|
||||
end;
|
||||
if Token.Kind = lexerKindLeftParen then
|
||||
if token.kind = lexerKindLeftParen then
|
||||
transpile_enumeration_type(context, lexer)
|
||||
end;
|
||||
if (Token.Kind = lexerKindArray) or (Token.Kind = lexerKindLeftSquare) then
|
||||
if (token.kind = lexerKindArray) or (token.kind = lexerKindLeftSquare) then
|
||||
transpile_array_type(context, lexer)
|
||||
end;
|
||||
if Token.Kind = lexerKindHat then
|
||||
if token.kind = lexerKindHat then
|
||||
transpile_pointer_type(context, lexer)
|
||||
end;
|
||||
if Token.Kind = lexerKindProc then
|
||||
if token.kind = lexerKindProc then
|
||||
transpile_procedure_type(context, lexer)
|
||||
end;
|
||||
if Token.Kind = lexerKindIdentifier then
|
||||
if token.kind = lexerKindIdentifier then
|
||||
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start)
|
||||
end
|
||||
end;
|
||||
|
||||
proc transpile_type_declaration(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
token: LexerToken;
|
||||
written_bytes: CARDINAL;
|
||||
begin
|
||||
WriteString(' ');
|
||||
Token := lexer_current(lexer);
|
||||
token := lexer_current(lexer);
|
||||
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
|
||||
|
||||
Token := transpiler_lex(lexer);
|
||||
token := transpiler_lex(lexer);
|
||||
WriteString(' = ');
|
||||
transpile_type_expression(context, lexer);
|
||||
Token := transpiler_lex(lexer);
|
||||
token := transpiler_lex(lexer);
|
||||
write_semicolon();
|
||||
end;
|
||||
|
||||
@ -333,12 +333,12 @@ var
|
||||
begin
|
||||
token := lexer_current(lexer);
|
||||
|
||||
if token.Kind = lexerKindType then
|
||||
if token.kind = lexerKindType then
|
||||
WriteString('TYPE');
|
||||
WriteLn();
|
||||
token := transpiler_lex(lexer);
|
||||
|
||||
while token.Kind = lexerKindIdentifier do
|
||||
while token.kind = lexerKindIdentifier do
|
||||
transpile_type_declaration(context, lexer);
|
||||
token := transpiler_lex(lexer)
|
||||
end;
|
||||
@ -348,42 +348,42 @@ end;
|
||||
|
||||
proc transpile_variable_declaration(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
token: LexerToken;
|
||||
written_bytes: CARDINAL;
|
||||
begin
|
||||
WriteString(' ');
|
||||
Token := lexer_current(lexer);
|
||||
token := lexer_current(lexer);
|
||||
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
|
||||
|
||||
Token := transpiler_lex(lexer);
|
||||
token := transpiler_lex(lexer);
|
||||
WriteString(': ');
|
||||
transpile_type_expression(context, lexer);
|
||||
Token := transpiler_lex(lexer);
|
||||
token := transpiler_lex(lexer);
|
||||
write_semicolon()
|
||||
end;
|
||||
|
||||
proc transpile_variable_part(context: PTranspilerContext, lexer: PLexer): BOOLEAN;
|
||||
proc transpile_variable_part(context: PTranspilerContext, lexer: PLexer) -> BOOLEAN;
|
||||
var
|
||||
Token: LexerToken;
|
||||
token: LexerToken;
|
||||
result: BOOLEAN;
|
||||
begin
|
||||
Token := lexer_current(lexer);
|
||||
result := Token.Kind = lexerKindVar;
|
||||
token := lexer_current(lexer);
|
||||
result := token.kind = lexerKindVar;
|
||||
|
||||
if result then
|
||||
WriteString('VAR');
|
||||
WriteLn();
|
||||
Token := transpiler_lex(lexer);
|
||||
token := transpiler_lex(lexer);
|
||||
|
||||
while Token.Kind = lexerKindIdentifier do
|
||||
while token.kind = lexerKindIdentifier do
|
||||
transpile_variable_declaration(context, lexer);
|
||||
Token := transpiler_lex(lexer)
|
||||
token := transpiler_lex(lexer)
|
||||
end
|
||||
end;
|
||||
return result
|
||||
end;
|
||||
|
||||
proc transpile_procedure_heading(context: PTranspilerContext, lexer: PLexer): LexerToken;
|
||||
proc transpile_procedure_heading(context: PTranspilerContext, lexer: PLexer) -> LexerToken;
|
||||
var
|
||||
token: LexerToken;
|
||||
result: LexerToken;
|
||||
@ -398,7 +398,7 @@ begin
|
||||
Write('(');
|
||||
|
||||
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);
|
||||
|
||||
token := transpiler_lex(lexer);
|
||||
@ -407,7 +407,7 @@ begin
|
||||
transpile_type_expression(context, lexer);
|
||||
|
||||
token := transpiler_lex(lexer);
|
||||
if (token.Kind = lexerKindSemicolon) or (token.Kind = lexerKindComma) then
|
||||
if (token.kind = lexerKindSemicolon) or (token.kind = lexerKindComma) then
|
||||
WriteString('; ');
|
||||
token := transpiler_lex(lexer)
|
||||
end
|
||||
@ -416,7 +416,7 @@ begin
|
||||
token := transpiler_lex(lexer);
|
||||
|
||||
(* Check for the return type and write it. *)
|
||||
if token.Kind = lexerKindColon then
|
||||
if token.kind = lexerKindArrow then
|
||||
WriteString(': ');
|
||||
token := transpiler_lex(lexer);
|
||||
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
|
||||
@ -428,28 +428,28 @@ begin
|
||||
return result
|
||||
end;
|
||||
|
||||
proc transpile_expression(context: PTranspilerContext, lexer: PLexer, TrailingToken: LexerKind);
|
||||
proc transpile_expression(context: PTranspilerContext, lexer: PLexer, trailing_token: LexerKind);
|
||||
var
|
||||
token: LexerToken;
|
||||
written_bytes: CARDINAL;
|
||||
begin
|
||||
token := transpiler_lex(lexer);
|
||||
|
||||
while (token.Kind <> TrailingToken) & (token.Kind <> lexerKindEnd) do
|
||||
while (token.kind <> trailing_token) & (token.kind <> lexerKindEnd) do
|
||||
written_bytes := 0;
|
||||
if token.Kind = lexerKindNull then
|
||||
if token.kind = lexerKindNull then
|
||||
WriteString('NIL ');
|
||||
written_bytes := 1
|
||||
end;
|
||||
if token.Kind = lexerKindOr then
|
||||
if token.kind = lexerKindOr then
|
||||
WriteString('OR ');
|
||||
written_bytes := 1
|
||||
end;
|
||||
if token.Kind = lexerKindAnd then
|
||||
if token.kind = lexerKindAnd then
|
||||
WriteString('AND ');
|
||||
written_bytes := 1
|
||||
end;
|
||||
if token.Kind = lexerKindNot then
|
||||
if token.kind = lexerKindNot then
|
||||
WriteString('NOT ');
|
||||
written_bytes := 1
|
||||
end;
|
||||
@ -478,7 +478,7 @@ end;
|
||||
|
||||
proc transpile_while_statement(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
token: LexerToken;
|
||||
written_bytes: CARDINAL;
|
||||
begin
|
||||
WriteString(' WHILE ');
|
||||
@ -488,7 +488,7 @@ begin
|
||||
WriteLn();
|
||||
transpile_statements(context, lexer);
|
||||
WriteString(' END');
|
||||
Token := transpiler_lex(lexer)
|
||||
token := transpiler_lex(lexer)
|
||||
end;
|
||||
|
||||
proc transpile_assignment_statement(context: PTranspilerContext, lexer: PLexer);
|
||||
@ -499,27 +499,72 @@ end;
|
||||
|
||||
proc transpile_call_statement(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
token: LexerToken;
|
||||
written_bytes: CARDINAL;
|
||||
begin
|
||||
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);
|
||||
Token := transpiler_lex(lexer)
|
||||
token := transpiler_lex(lexer)
|
||||
end
|
||||
end;
|
||||
|
||||
proc transpile_return_statement(context: PTranspilerContext, lexer: PLexer);
|
||||
proc transpile_designator_expression(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
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;
|
||||
|
||||
proc transpile_return_statement(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
token: LexerToken;
|
||||
written_bytes: CARDINAL;
|
||||
begin
|
||||
WriteString(' RETURN ');
|
||||
Token := transpiler_lex(lexer);
|
||||
token := transpiler_lex(lexer);
|
||||
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
|
||||
Token := transpiler_lex(lexer)
|
||||
token := transpiler_lex(lexer)
|
||||
end;
|
||||
|
||||
proc transpile_statement(context: PTranspilerContext, lexer: PLexer);
|
||||
@ -529,59 +574,23 @@ var
|
||||
begin
|
||||
token := transpiler_lex(lexer);
|
||||
|
||||
if token.Kind = lexerKindIf then
|
||||
if token.kind = lexerKindIf then
|
||||
transpile_if_statement(context, lexer)
|
||||
end;
|
||||
if token.Kind = lexerKindWhile then
|
||||
if token.kind = lexerKindWhile then
|
||||
transpile_while_statement(context, lexer)
|
||||
end;
|
||||
if token.Kind = lexerKindReturn then
|
||||
if token.kind = lexerKindReturn then
|
||||
transpile_return_statement(context, lexer)
|
||||
end;
|
||||
if token.Kind = lexerKindIdentifier then
|
||||
WriteString(' ');
|
||||
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
|
||||
token := transpiler_lex(lexer);
|
||||
if token.kind = lexerKindIdentifier then
|
||||
transpile_designator_expression(context, lexer);
|
||||
token := lexer_current(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;
|
||||
|
||||
if token.Kind = lexerKindAssignment then
|
||||
if token.kind = lexerKindAssignment then
|
||||
transpile_assignment_statement(context, lexer)
|
||||
end;
|
||||
if token.Kind = lexerKindLeftParen then
|
||||
if token.kind = lexerKindLeftParen then
|
||||
transpile_call_statement(context, lexer)
|
||||
end
|
||||
end
|
||||
@ -589,15 +598,15 @@ end;
|
||||
|
||||
proc transpile_statements(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
token: LexerToken;
|
||||
begin
|
||||
Token := lexer_current(lexer);
|
||||
token := lexer_current(lexer);
|
||||
|
||||
while Token.Kind <> lexerKindEnd do
|
||||
while token.kind <> lexerKindEnd do
|
||||
transpile_statement(context, lexer);
|
||||
Token := lexer_current(lexer);
|
||||
token := lexer_current(lexer);
|
||||
|
||||
if Token.Kind = lexerKindSemicolon then
|
||||
if token.kind = lexerKindSemicolon then
|
||||
Write(';')
|
||||
end;
|
||||
WriteLn()
|
||||
@ -606,10 +615,10 @@ end;
|
||||
|
||||
proc transpile_statement_part(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
token: LexerToken;
|
||||
begin
|
||||
Token := lexer_current(lexer);
|
||||
if Token.Kind = lexerKindBegin then
|
||||
token := lexer_current(lexer);
|
||||
if token.kind = lexerKindBegin then
|
||||
WriteString('BEGIN');
|
||||
WriteLn();
|
||||
transpile_statements(context, lexer)
|
||||
@ -618,43 +627,43 @@ end;
|
||||
|
||||
proc transpile_procedure_declaration(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
token: LexerToken;
|
||||
seen_part: BOOLEAN;
|
||||
written_bytes: CARDINAL;
|
||||
begin
|
||||
Token := transpile_procedure_heading(context, lexer);
|
||||
token := transpile_procedure_heading(context, lexer);
|
||||
seen_part := transpile_constant_part(context, lexer);
|
||||
seen_part := transpile_variable_part(context, lexer);
|
||||
transpile_statement_part(context, lexer);
|
||||
|
||||
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();
|
||||
Token := transpiler_lex(lexer)
|
||||
token := transpiler_lex(lexer)
|
||||
end;
|
||||
|
||||
proc transpile_procedure_part(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
token: LexerToken;
|
||||
begin
|
||||
Token := lexer_current(lexer);
|
||||
token := lexer_current(lexer);
|
||||
|
||||
while Token.Kind = lexerKindProc do
|
||||
while token.kind = lexerKindProc do
|
||||
transpile_procedure_declaration(context, lexer);
|
||||
Token := lexer_current(lexer);
|
||||
token := lexer_current(lexer);
|
||||
WriteLn()
|
||||
end
|
||||
end;
|
||||
|
||||
proc transpile(lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
token: LexerToken;
|
||||
written_bytes: CARDINAL;
|
||||
Context: TranspilerContext;
|
||||
context: TranspilerContext;
|
||||
begin
|
||||
transpile_module(ADR(Context), lexer)
|
||||
transpile_module(ADR(context), lexer)
|
||||
end;
|
||||
|
||||
end Transpiler.
|
||||
|
Loading…
x
Reference in New Issue
Block a user