Handle ASCII codes > 128 in the tokenizer
This commit is contained in:
parent
15135f14d8
commit
a93d12eb50
GPG Key ID:
A27FDC1E8EE902C0
@ -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
|
||||
|
||||
193
source/Lexer.mod
193
source/Lexer.mod
@ -72,6 +72,8 @@ VAR
|
||||
transitions: ARRAY[1..16] OF TransitionClasses;
|
||||
|
||||
PROCEDURE initialize_classification();
|
||||
VAR
|
||||
i: CARDINAL;
|
||||
BEGIN
|
||||
classification[1] := transitionClassEof; (* NUL *)
|
||||
classification[2] := transitionClassInvalid; (* SOH *)
|
||||
@ -200,255 +202,264 @@ 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 initialize_classification;
|
||||
PROCEDURE 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)) AND (TokenStart <> TokenEnd) AND Result DO
|
||||
Result := (Keyword[Index] = TokenStart^) OR (Lower(Keyword[Index]) = TokenStart^);
|
||||
WHILE (index < Length(Keyword)) AND (TokenStart <> TokenEnd) AND result DO
|
||||
result := (Keyword[index] = TokenStart^) OR (Lower(Keyword[index]) = TokenStart^);
|
||||
INC(TokenStart);
|
||||
INC(Index)
|
||||
INC(index)
|
||||
END;
|
||||
Result := (Index = Length(Keyword)) AND (TokenStart = TokenEnd) AND Result;
|
||||
RETURN Result
|
||||
result := (index = Length(Keyword)) AND (TokenStart = TokenEnd) AND result;
|
||||
RETURN result
|
||||
END compare_keyword;
|
||||
(* Reached the end of file. *)
|
||||
PROCEDURE transition_action_eof(lexer: PLexer; AToken: PLexerToken);
|
||||
PROCEDURE transition_action_eof(lexer: PLexer; token: PLexerToken);
|
||||
BEGIN
|
||||
AToken^.Kind := lexerKindEof
|
||||
token^.kind := lexerKindEof
|
||||
END transition_action_eof;
|
||||
(* Add the character to the token currently read and advance to the next character. *)
|
||||
PROCEDURE transition_action_accumulate(lexer: PLexer; AToken: PLexerToken);
|
||||
PROCEDURE transition_action_accumulate(lexer: PLexer; token: PLexerToken);
|
||||
BEGIN
|
||||
INC(lexer^.Current)
|
||||
END transition_action_accumulate;
|
||||
(* The current character is not a part of the token. Finish the token already
|
||||
* read. Don't advance to the next character. *)
|
||||
PROCEDURE transition_action_finalize(lexer: PLexer; AToken: PLexerToken);
|
||||
PROCEDURE 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 transition_action_finalize;
|
||||
(* An action for tokens containing multiple characters. *)
|
||||
PROCEDURE transition_action_composite(lexer: PLexer; AToken: PLexerToken);
|
||||
PROCEDURE 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^ = '>') AND (lexer^.Current^ = '=') THEN
|
||||
AToken^.Kind := lexerKindGreaterEqual
|
||||
token^.kind := lexerKindGreaterEqual
|
||||
END;
|
||||
IF (lexer^.Start^ = '.') AND (lexer^.Current^ = '.') THEN
|
||||
AToken^.Kind := lexerKindRange
|
||||
token^.kind := lexerKindRange
|
||||
END;
|
||||
IF (lexer^.Start^ = ':') AND (lexer^.Current^ = '=') THEN
|
||||
AToken^.Kind := lexerKindAssignment
|
||||
token^.kind := lexerKindAssignment
|
||||
END;
|
||||
IF (lexer^.Start^ = '-') AND (lexer^.Current^ = '>') THEN
|
||||
token^.kind := lexerKindArrow
|
||||
END;
|
||||
INC(lexer^.Current)
|
||||
END transition_action_composite;
|
||||
(* Skip a space. *)
|
||||
PROCEDURE transition_action_skip(lexer: PLexer; AToken: PLexerToken);
|
||||
PROCEDURE transition_action_skip(lexer: PLexer; token: PLexerToken);
|
||||
BEGIN
|
||||
INC(lexer^.Current);
|
||||
INC(lexer^.Start)
|
||||
END transition_action_skip;
|
||||
(* Delimited string action. *)
|
||||
PROCEDURE transition_action_delimited(lexer: PLexer; AToken: PLexerToken);
|
||||
PROCEDURE 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 transition_action_delimited;
|
||||
(* Finalize keyword OR identifier. *)
|
||||
PROCEDURE transition_action_key_id(lexer: PLexer; AToken: PLexerToken);
|
||||
PROCEDURE 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 transition_action_key_id;
|
||||
(* Action for tokens containing only one character. The character cannot be
|
||||
* followed by other characters forming a composite token. *)
|
||||
PROCEDURE transition_action_single(lexer: PLexer; AToken: PLexerToken);
|
||||
PROCEDURE 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 transition_action_single;
|
||||
(* Handle an integer literal. *)
|
||||
PROCEDURE transition_action_integer(lexer: PLexer; AToken: PLexerToken);
|
||||
PROCEDURE transition_action_integer(lexer: PLexer; token: PLexerToken);
|
||||
BEGIN
|
||||
AToken^.Kind := lexerKindInteger
|
||||
token^.kind := lexerKindInteger
|
||||
END transition_action_integer;
|
||||
PROCEDURE set_default_transition(CurrentState: TransitionState; DefaultAction: TransitionAction; NextState: TransitionState);
|
||||
VAR
|
||||
@ -747,7 +758,7 @@ VAR
|
||||
CurrentClass: TransitionClass;
|
||||
CurrentState: TransitionState;
|
||||
CurrentTransition: Transition;
|
||||
Result: LexerToken;
|
||||
result: LexerToken;
|
||||
BEGIN
|
||||
lexer^.Current := lexer^.Start;
|
||||
CurrentState := transitionStateStart;
|
||||
@ -757,15 +768,15 @@ 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 lexer_current;
|
||||
PROCEDURE 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);
|
||||
@ -773,8 +784,8 @@ BEGIN
|
||||
END;
|
||||
lexer^.Start := lexer^.Current;
|
||||
|
||||
Result := lexer_current(lexer);
|
||||
RETURN Result
|
||||
result := lexer_current(lexer);
|
||||
RETURN result
|
||||
END lexer_lex;
|
||||
PROCEDURE lexer_destroy(lexer: PLexer);
|
||||
BEGIN
|
||||
|
||||
@ -19,7 +19,7 @@ VAR
|
||||
BEGIN
|
||||
result := lexer_lex(lexer);
|
||||
|
||||
WHILE result.Kind = lexerKindComment DO
|
||||
WHILE result.kind = lexerKindComment DO
|
||||
result := lexer_lex(lexer)
|
||||
END;
|
||||
|
||||
@ -48,7 +48,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);
|
||||
@ -63,7 +63,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;
|
||||
@ -71,69 +71,69 @@ BEGIN
|
||||
END transpile_import_part;
|
||||
PROCEDURE 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 transpile_constant;
|
||||
PROCEDURE 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
|
||||
END transpile_constant_part;
|
||||
PROCEDURE 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()
|
||||
@ -147,32 +147,32 @@ 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 transpile_module;
|
||||
PROCEDURE 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()
|
||||
@ -180,7 +180,7 @@ BEGIN
|
||||
END transpile_type_fields;
|
||||
PROCEDURE transpile_record_type(context: PTranspilerContext; lexer: PLexer);
|
||||
VAR
|
||||
Token: LexerToken;
|
||||
token: LexerToken;
|
||||
BEGIN
|
||||
WriteString('RECORD');
|
||||
WriteLn();
|
||||
@ -189,32 +189,32 @@ BEGIN
|
||||
END transpile_record_type;
|
||||
PROCEDURE 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 transpile_pointer_type;
|
||||
PROCEDURE 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 ');
|
||||
@ -222,50 +222,50 @@ BEGIN
|
||||
END transpile_array_type;
|
||||
PROCEDURE 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(' )')
|
||||
END transpile_enumeration_type;
|
||||
PROCEDURE transpile_union_type(context: PTranspilerContext; lexer: PLexer);
|
||||
VAR
|
||||
Token: LexerToken;
|
||||
token: LexerToken;
|
||||
END transpile_union_type;
|
||||
PROCEDURE 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;
|
||||
@ -273,42 +273,42 @@ BEGIN
|
||||
END transpile_procedure_type;
|
||||
PROCEDURE 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 transpile_type_expression;
|
||||
PROCEDURE 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 transpile_type_declaration;
|
||||
PROCEDURE transpile_type_part(context: PTranspilerContext; lexer: PLexer);
|
||||
@ -317,12 +317,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;
|
||||
@ -331,35 +331,35 @@ BEGIN
|
||||
END transpile_type_part;
|
||||
PROCEDURE 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 transpile_variable_declaration;
|
||||
PROCEDURE 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
|
||||
@ -379,7 +379,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);
|
||||
@ -388,7 +388,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
|
||||
@ -397,7 +397,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);
|
||||
@ -408,28 +408,28 @@ BEGIN
|
||||
|
||||
RETURN result
|
||||
END transpile_procedure_heading;
|
||||
PROCEDURE transpile_expression(context: PTranspilerContext; lexer: PLexer; TrailingToken: LexerKind);
|
||||
PROCEDURE transpile_expression(context: PTranspilerContext; lexer: PLexer; trailing_token: LexerKind);
|
||||
VAR
|
||||
token: LexerToken;
|
||||
written_bytes: CARDINAL;
|
||||
BEGIN
|
||||
token := transpiler_lex(lexer);
|
||||
|
||||
WHILE (token.Kind <> TrailingToken) AND (token.Kind <> lexerKindEnd) DO
|
||||
WHILE (token.kind <> trailing_token) AND (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;
|
||||
@ -456,7 +456,7 @@ BEGIN
|
||||
END transpile_if_statement;
|
||||
PROCEDURE transpile_while_statement(context: PTranspilerContext; lexer: PLexer);
|
||||
VAR
|
||||
Token: LexerToken;
|
||||
token: LexerToken;
|
||||
written_bytes: CARDINAL;
|
||||
BEGIN
|
||||
WriteString(' WHILE ');
|
||||
@ -466,7 +466,7 @@ BEGIN
|
||||
WriteLn();
|
||||
transpile_statements(context, lexer);
|
||||
WriteString(' END');
|
||||
Token := transpiler_lex(lexer)
|
||||
token := transpiler_lex(lexer)
|
||||
END transpile_while_statement;
|
||||
PROCEDURE transpile_assignment_statement(context: PTranspilerContext; lexer: PLexer);
|
||||
BEGIN
|
||||
@ -475,26 +475,70 @@ BEGIN
|
||||
END transpile_assignment_statement;
|
||||
PROCEDURE 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) AND (Token.Kind <> lexerKindEnd) DO
|
||||
WHILE (token.kind <> lexerKindSemicolon) AND (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 transpile_call_statement;
|
||||
PROCEDURE transpile_return_statement(context: PTranspilerContext; lexer: PLexer);
|
||||
PROCEDURE 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 transpile_designator_expression;
|
||||
PROCEDURE 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 transpile_return_statement;
|
||||
PROCEDURE transpile_statement(context: PTranspilerContext; lexer: PLexer);
|
||||
VAR
|
||||
@ -503,74 +547,38 @@ 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
|
||||
END transpile_statement;
|
||||
PROCEDURE 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()
|
||||
@ -578,10 +586,10 @@ BEGIN
|
||||
END transpile_statements;
|
||||
PROCEDURE 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)
|
||||
@ -589,40 +597,40 @@ BEGIN
|
||||
END transpile_statement_part;
|
||||
PROCEDURE 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 transpile_procedure_declaration;
|
||||
PROCEDURE 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 transpile_procedure_part;
|
||||
PROCEDURE 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 transpile;
|
||||
END Transpiler.
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user