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

Parse call expressions

Browse Source
This commit is contained in:
Eugen Wissner 2025-06-07 23:50:53 +02:00
parent 8d52410be9
commit cb7d5225b6
Signed by: belka
GPG Key ID: A27FDC1E8EE902C0
5 changed files with 504 additions and 294 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
source/Lexer.def
View File

@ -7,12 +7,12 @@ FROM Common IMPORT Identifier, ShortString;
TYPE TYPE
PLexerBuffer = POINTER TO CHAR; PLexerBuffer = POINTER TO CHAR;
Lexer = RECORD Lexer = RECORD
Input: File; input: File;
Buffer: PLexerBuffer; buffer: PLexerBuffer;
Size: CARDINAL; size: CARDINAL;
Length: CARDINAL; length: CARDINAL;
Start: PLexerBuffer; start: PLexerBuffer;
Current: PLexerBuffer current: PLexerBuffer
END; END;
PLexer = POINTER TO Lexer; PLexer = POINTER TO Lexer;
LexerKind = ( LexerKind = (
@ -90,11 +90,11 @@ TYPE
END; END;
PLexerToken = POINTER TO LexerToken; PLexerToken = POINTER TO LexerToken;
PROCEDURE lexer_initialize(ALexer: PLexer; Input: File); PROCEDURE lexer_initialize(lexer: PLexer; input: File);
PROCEDURE lexer_destroy(ALexer: PLexer); PROCEDURE lexer_destroy(lexer: PLexer);
(* Returns the last read token. *) (* Returns the last read token. *)
PROCEDURE lexer_current(ALexer: PLexer): LexerToken; PROCEDURE lexer_current(lexer: PLexer): LexerToken;
(* Read and return the next token. *) (* Read and return the next token. *)
PROCEDURE lexer_lex(ALexer: PLexer): LexerToken; PROCEDURE lexer_lex(lexer: PLexer): LexerToken;
END Lexer. END Lexer.

520
source/Lexer.elna
View File

@ -64,8 +64,8 @@ type
); );
TransitionAction = proc(PLexer, PLexerToken); TransitionAction = proc(PLexer, PLexerToken);
Transition = record Transition = record
Action: TransitionAction; action: TransitionAction;
NextState: TransitionState next_state: TransitionState
end; end;
TransitionClasses = [22]Transition; TransitionClasses = [22]Transition;
@ -213,7 +213,7 @@ begin
end end
end; end;
proc compare_keyword(Keyword: ARRAY OF CHAR, TokenStart: PLexerBuffer, TokenEnd: PLexerBuffer) -> BOOLEAN; proc compare_keyword(keyword: ARRAY OF CHAR, token_start: PLexerBuffer, token_end: PLexerBuffer) -> BOOLEAN;
var var
result: BOOLEAN; result: BOOLEAN;
index: CARDINAL; index: CARDINAL;
@ -221,12 +221,12 @@ begin
index := 0; index := 0;
result := true; result := true;
while (index < Length(Keyword)) & (TokenStart <> TokenEnd) & result DO while (index < Length(keyword)) & (token_start <> token_end) & result DO
result := (Keyword[index] = TokenStart^) or (Lower(Keyword[index]) = TokenStart^); result := (keyword[index] = token_start^) or (Lower(keyword[index]) = token_start^);
INC(TokenStart); INC(token_start);
INC(index) INC(index)
end; end;
result := (index = Length(Keyword)) & (TokenStart = TokenEnd) & result; result := (index = Length(keyword)) & (token_start = token_end) & result;
return result return result
end; end;
@ -239,29 +239,29 @@ 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, token: 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, token: PLexerToken); proc transition_action_finalize(lexer: PLexer, token: PLexerToken);
begin begin
if lexer^.Start^ = ':' then if lexer^.start^ = ':' then
token^.kind := lexerKindColon token^.kind := lexerKindColon
end; end;
if lexer^.Start^ = '>' then if lexer^.start^ = '>' then
token^.kind := lexerKindGreaterThan token^.kind := lexerKindGreaterThan
end; end;
if lexer^.Start^ = '<' then if lexer^.start^ = '<' then
token^.kind := lexerKindLessThan token^.kind := lexerKindLessThan
end; end;
if lexer^.Start^ = '(' then if lexer^.start^ = '(' then
token^.kind := lexerKindLeftParen token^.kind := lexerKindLeftParen
end; end;
if lexer^.Start^ = '-' then if lexer^.start^ = '-' then
token^.kind := lexerKindLeftParen token^.kind := lexerKindLeftParen
end; end;
if lexer^.Start^ = '.' then if lexer^.start^ = '.' then
token^.kind := lexerKindDot token^.kind := lexerKindDot
end end
end; end;
@ -269,34 +269,34 @@ end;
(* An action for tokens containing multiple characters. *) (* An action for tokens containing multiple characters. *)
proc transition_action_composite(lexer: PLexer, token: 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
token^.kind := lexerKindNotEqual token^.kind := lexerKindNotEqual
end; end;
if lexer^.Current^ = '=' then if lexer^.current^ = '=' then
token^.kind := lexerKindLessEqual token^.kind := lexerKindLessEqual
end end
end; end;
if (lexer^.Start^ = '>') & (lexer^.Current^ = '=') then if (lexer^.start^ = '>') & (lexer^.current^ = '=') then
token^.kind := lexerKindGreaterEqual token^.kind := lexerKindGreaterEqual
end; end;
if (lexer^.Start^ = '.') & (lexer^.Current^ = '.') then if (lexer^.start^ = '.') & (lexer^.current^ = '.') then
token^.kind := lexerKindRange token^.kind := lexerKindRange
end; end;
if (lexer^.Start^ = ':') & (lexer^.Current^ = '=') then if (lexer^.start^ = ':') & (lexer^.current^ = '=') then
token^.kind := lexerKindAssignment token^.kind := lexerKindAssignment
end; end;
if (lexer^.Start^ = '-') & (lexer^.Current^ = '>') then if (lexer^.start^ = '-') & (lexer^.current^ = '>') then
token^.kind := lexerKindArrow 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, token: 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. *)
@ -304,20 +304,28 @@ proc transition_action_delimited(lexer: PLexer, token: PLexerToken);
var var
text_length: CARDINAL; text_length: CARDINAL;
begin begin
if lexer^.Start^ = '(' then if lexer^.start^ = '(' then
token^.kind := lexerKindComment token^.kind := lexerKindComment
end; end;
if lexer^.Start^ = '"' then if lexer^.start^ = '"' then
text_length := lexer^.current - lexer^.start;
INC(text_length);
MemZero(ADR(token^.stringKind), TSIZE(ShortString));
MemCopy(lexer^.start, text_length, ADR(token^.stringKind));
token^.kind := lexerKindCharacter token^.kind := lexerKindCharacter
end; end;
if lexer^.Start^ = "'" then if lexer^.start^ = "'" then
text_length := lexer^.Current - lexer^.Start; text_length := lexer^.current - lexer^.start;
INC(text_length);
MemZero(ADR(token^.stringKind), TSIZE(ShortString)); MemZero(ADR(token^.stringKind), TSIZE(ShortString));
MemCopy(lexer^.Start, text_length, ADR(token^.stringKind)); MemCopy(lexer^.start, text_length, ADR(token^.stringKind));
token^.kind := lexerKindString token^.kind := lexerKindString
end; end;
INC(lexer^.Current) INC(lexer^.current)
end; end;
(* Finalize keyword or identifier. *) (* Finalize keyword or identifier. *)
@ -325,101 +333,101 @@ proc transition_action_key_id(lexer: PLexer, token: PLexerToken);
begin begin
token^.kind := lexerKindIdentifier; token^.kind := lexerKindIdentifier;
token^.identifierKind[1] := lexer^.Current - lexer^.Start; token^.identifierKind[1] := lexer^.current - lexer^.start;
MemCopy(lexer^.Start, ORD(token^.identifierKind[1]), ADR(token^.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
token^.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
token^.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
token^.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
token^.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
token^.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
token^.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
token^.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
token^.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
token^.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
token^.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
token^.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
token^.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
token^.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
token^.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
token^.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
token^.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
token^.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
token^.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
token^.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
token^.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
token^.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
token^.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
token^.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
token^.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
token^.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
token^.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
token^.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
token^.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
token^.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
token^.kind := lexerKindBoolean; token^.kind := lexerKindBoolean;
token^.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
token^.kind := lexerKindBoolean; token^.kind := lexerKindBoolean;
token^.booleanKind := false token^.booleanKind := false
end end
@ -429,49 +437,49 @@ end;
* followed by other characters forming a composite token. *) * followed by other characters forming a composite token. *)
proc transition_action_single(lexer: PLexer, token: PLexerToken); proc transition_action_single(lexer: PLexer, token: PLexerToken);
begin begin
if lexer^.Current^ = '&' then if lexer^.current^ = '&' then
token^.kind := lexerKindAnd token^.kind := lexerKindAnd
end; end;
if lexer^.Current^ = ';' then if lexer^.current^ = ';' then
token^.kind := lexerKindSemicolon token^.kind := lexerKindSemicolon
end; end;
if lexer^.Current^ = ',' then if lexer^.current^ = ',' then
token^.kind := lexerKindComma token^.kind := lexerKindComma
end; end;
if lexer^.Current^ = '~' then if lexer^.current^ = '~' then
token^.kind := lexerKindTilde token^.kind := lexerKindTilde
end; end;
if lexer^.Current^ = ')' then if lexer^.current^ = ')' then
token^.kind := lexerKindRightParen token^.kind := lexerKindRightParen
end; end;
if lexer^.Current^ = '[' then if lexer^.current^ = '[' then
token^.kind := lexerKindLeftSquare token^.kind := lexerKindLeftSquare
end; end;
if lexer^.Current^ = ']' then if lexer^.current^ = ']' then
token^.kind := lexerKindRightSquare token^.kind := lexerKindRightSquare
end; end;
if lexer^.Current^ = '^' then if lexer^.current^ = '^' then
token^.kind := lexerKindHat token^.kind := lexerKindHat
end; end;
if lexer^.Current^ = '=' then if lexer^.current^ = '=' then
token^.kind := lexerKindEqual token^.kind := lexerKindEqual
end; end;
if lexer^.Current^ = '+' then if lexer^.current^ = '+' then
token^.kind := lexerKindPlus token^.kind := lexerKindPlus
end; end;
if lexer^.Current^ = '/' then if lexer^.current^ = '/' then
token^.kind := lexerKindDivision token^.kind := lexerKindDivision
end; end;
if lexer^.Current^ = '%' then if lexer^.current^ = '%' then
token^.kind := lexerKindRemainder token^.kind := lexerKindRemainder
end; end;
if lexer^.Current^ = '@' then if lexer^.current^ = '@' then
token^.kind := lexerKindAt token^.kind := lexerKindAt
end; end;
if lexer^.Current^ = '|' then if lexer^.current^ = '|' then
token^.kind := lexerKindPipe token^.kind := lexerKindPipe
end; end;
INC(lexer^.Current) INC(lexer^.current)
end; end;
(* Handle an integer literal. *) (* Handle an integer literal. *)
@ -483,44 +491,44 @@ var
begin begin
token^.kind := lexerKindInteger; token^.kind := lexerKindInteger;
integer_length := lexer^.Current - lexer^.Start; integer_length := lexer^.current - lexer^.start;
MemZero(ADR(token^.identifierKind), TSIZE(Identifier)); MemZero(ADR(token^.identifierKind), TSIZE(Identifier));
MemCopy(lexer^.Start, integer_length, ADR(token^.identifierKind[1])); MemCopy(lexer^.start, integer_length, ADR(token^.identifierKind[1]));
buffer := InitStringCharStar(ADR(token^.identifierKind[1])); buffer := InitStringCharStar(ADR(token^.identifierKind[1]));
token^.integerKind := StringToInteger(buffer, 10, found); token^.integerKind := StringToInteger(buffer, 10, found);
buffer := KillString(buffer) buffer := KillString(buffer)
end; end;
proc set_default_transition(CurrentState: TransitionState, DefaultAction: TransitionAction, NextState: TransitionState); proc set_default_transition(current_state: TransitionState, DefaultAction: TransitionAction, next_state: TransitionState);
var var
DefaultTransition: Transition; default_transition: Transition;
begin begin
DefaultTransition.Action := DefaultAction; default_transition.action := DefaultAction;
DefaultTransition.NextState := NextState; default_transition.next_state := next_state;
transitions[ORD(CurrentState) + 1][ORD(transitionClassInvalid) + 1] := DefaultTransition; transitions[ORD(current_state) + 1][ORD(transitionClassInvalid) + 1] := default_transition;
transitions[ORD(CurrentState) + 1][ORD(transitionClassDigit) + 1] := DefaultTransition; transitions[ORD(current_state) + 1][ORD(transitionClassDigit) + 1] := default_transition;
transitions[ORD(CurrentState) + 1][ORD(transitionClassAlpha) + 1] := DefaultTransition; transitions[ORD(current_state) + 1][ORD(transitionClassAlpha) + 1] := default_transition;
transitions[ORD(CurrentState) + 1][ORD(transitionClassSpace) + 1] := DefaultTransition; transitions[ORD(current_state) + 1][ORD(transitionClassSpace) + 1] := default_transition;
transitions[ORD(CurrentState) + 1][ORD(transitionClassColon) + 1] := DefaultTransition; transitions[ORD(current_state) + 1][ORD(transitionClassColon) + 1] := default_transition;
transitions[ORD(CurrentState) + 1][ORD(transitionClassEquals) + 1] := DefaultTransition; transitions[ORD(current_state) + 1][ORD(transitionClassEquals) + 1] := default_transition;
transitions[ORD(CurrentState) + 1][ORD(transitionClassLeftParen) + 1] := DefaultTransition; transitions[ORD(current_state) + 1][ORD(transitionClassLeftParen) + 1] := default_transition;
transitions[ORD(CurrentState) + 1][ORD(transitionClassRightParen) + 1] := DefaultTransition; transitions[ORD(current_state) + 1][ORD(transitionClassRightParen) + 1] := default_transition;
transitions[ORD(CurrentState) + 1][ORD(transitionClassAsterisk) + 1] := DefaultTransition; transitions[ORD(current_state) + 1][ORD(transitionClassAsterisk) + 1] := default_transition;
transitions[ORD(CurrentState) + 1][ORD(transitionClassUnderscore) + 1] := DefaultTransition; transitions[ORD(current_state) + 1][ORD(transitionClassUnderscore) + 1] := default_transition;
transitions[ORD(CurrentState) + 1][ORD(transitionClassSingle) + 1] := DefaultTransition; transitions[ORD(current_state) + 1][ORD(transitionClassSingle) + 1] := default_transition;
transitions[ORD(CurrentState) + 1][ORD(transitionClassHex) + 1] := DefaultTransition; transitions[ORD(current_state) + 1][ORD(transitionClassHex) + 1] := default_transition;
transitions[ORD(CurrentState) + 1][ORD(transitionClassZero) + 1] := DefaultTransition; transitions[ORD(current_state) + 1][ORD(transitionClassZero) + 1] := default_transition;
transitions[ORD(CurrentState) + 1][ORD(transitionClassX) + 1] := DefaultTransition; transitions[ORD(current_state) + 1][ORD(transitionClassX) + 1] := default_transition;
transitions[ORD(CurrentState) + 1][ORD(transitionClassEof) + 1] := DefaultTransition; transitions[ORD(current_state) + 1][ORD(transitionClassEof) + 1] := default_transition;
transitions[ORD(CurrentState) + 1][ORD(transitionClassDot) + 1] := DefaultTransition; transitions[ORD(current_state) + 1][ORD(transitionClassDot) + 1] := default_transition;
transitions[ORD(CurrentState) + 1][ORD(transitionClassMinus) + 1] := DefaultTransition; transitions[ORD(current_state) + 1][ORD(transitionClassMinus) + 1] := default_transition;
transitions[ORD(CurrentState) + 1][ORD(transitionClassSingleQuote) + 1] := DefaultTransition; transitions[ORD(current_state) + 1][ORD(transitionClassSingleQuote) + 1] := default_transition;
transitions[ORD(CurrentState) + 1][ORD(transitionClassDoubleQuote) + 1] := DefaultTransition; transitions[ORD(current_state) + 1][ORD(transitionClassDoubleQuote) + 1] := default_transition;
transitions[ORD(CurrentState) + 1][ORD(transitionClassGreater) + 1] := DefaultTransition; transitions[ORD(current_state) + 1][ORD(transitionClassGreater) + 1] := default_transition;
transitions[ORD(CurrentState) + 1][ORD(transitionClassLess) + 1] := DefaultTransition; transitions[ORD(current_state) + 1][ORD(transitionClassLess) + 1] := default_transition;
transitions[ORD(CurrentState) + 1][ORD(transitionClassOther) + 1] := DefaultTransition transitions[ORD(current_state) + 1][ORD(transitionClassOther) + 1] := default_transition
end; end;
(* (*
@ -542,269 +550,269 @@ end;
proc initialize_transitions(); proc initialize_transitions();
begin begin
(* Start state. *) (* Start state. *)
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassInvalid) + 1].Action := nil; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassInvalid) + 1].action := nil;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassInvalid) + 1].NextState := transitionStateEnd; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassInvalid) + 1].next_state := transitionStateEnd;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassDigit) + 1].Action := transition_action_accumulate; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassDigit) + 1].action := transition_action_accumulate;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassDigit) + 1].NextState := transitionStateDecimal; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassDigit) + 1].next_state := transitionStateDecimal;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassAlpha) + 1].Action := transition_action_accumulate; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassAlpha) + 1].action := transition_action_accumulate;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassAlpha) + 1].NextState := transitionStateIdentifier; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassAlpha) + 1].next_state := transitionStateIdentifier;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassSpace) + 1].Action := transition_action_skip; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassSpace) + 1].action := transition_action_skip;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassSpace) + 1].NextState := transitionStateStart; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassSpace) + 1].next_state := transitionStateStart;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassColon) + 1].Action := transition_action_accumulate; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassColon) + 1].action := transition_action_accumulate;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassColon) + 1].NextState := transitionStateColon; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassColon) + 1].next_state := transitionStateColon;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassEquals) + 1].Action := transition_action_single; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassEquals) + 1].action := transition_action_single;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassEquals) + 1].NextState := transitionStateEnd; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassEquals) + 1].next_state := transitionStateEnd;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassLeftParen) + 1].Action := transition_action_accumulate; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassLeftParen) + 1].action := transition_action_accumulate;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassLeftParen) + 1].NextState := transitionStateLeftParen; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassLeftParen) + 1].next_state := transitionStateLeftParen;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassRightParen) + 1].Action := transition_action_single; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassRightParen) + 1].action := transition_action_single;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassRightParen) + 1].NextState := transitionStateEnd; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassRightParen) + 1].next_state := transitionStateEnd;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassAsterisk) + 1].Action := transition_action_single; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassAsterisk) + 1].action := transition_action_single;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassAsterisk) + 1].NextState := transitionStateEnd; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassAsterisk) + 1].next_state := transitionStateEnd;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassUnderscore) + 1].Action := transition_action_accumulate; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassUnderscore) + 1].action := transition_action_accumulate;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassUnderscore) + 1].NextState := transitionStateIdentifier; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassUnderscore) + 1].next_state := transitionStateIdentifier;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassSingle) + 1].Action := transition_action_single; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassSingle) + 1].action := transition_action_single;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassSingle) + 1].NextState := transitionStateEnd; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassSingle) + 1].next_state := transitionStateEnd;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassHex) + 1].Action := transition_action_accumulate; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassHex) + 1].action := transition_action_accumulate;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassHex) + 1].NextState := transitionStateIdentifier; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassHex) + 1].next_state := transitionStateIdentifier;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassZero) + 1].Action := transition_action_accumulate; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassZero) + 1].action := transition_action_accumulate;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassZero) + 1].NextState := transitionStateLeadingZero; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassZero) + 1].next_state := transitionStateLeadingZero;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassX) + 1].Action := transition_action_accumulate; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassX) + 1].action := transition_action_accumulate;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassX) + 1].NextState := transitionStateIdentifier; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassX) + 1].next_state := transitionStateIdentifier;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassEof) + 1].Action := transition_action_eof; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassEof) + 1].action := transition_action_eof;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassEof) + 1].NextState := transitionStateEnd; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassEof) + 1].next_state := transitionStateEnd;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassDot) + 1].Action := transition_action_accumulate; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassDot) + 1].action := transition_action_accumulate;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassDot) + 1].NextState := transitionStateDot; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassDot) + 1].next_state := transitionStateDot;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassMinus) + 1].Action := transition_action_accumulate; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassMinus) + 1].action := transition_action_accumulate;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassMinus) + 1].NextState := transitionStateMinus; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassMinus) + 1].next_state := transitionStateMinus;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassSingleQuote) + 1].Action := transition_action_accumulate; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassSingleQuote) + 1].action := transition_action_accumulate;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassSingleQuote) + 1].NextState := transitionStateCharacter; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassSingleQuote) + 1].next_state := transitionStateCharacter;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassDoubleQuote) + 1].Action := transition_action_accumulate; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassDoubleQuote) + 1].action := transition_action_accumulate;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassDoubleQuote) + 1].NextState := transitionStateString; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassDoubleQuote) + 1].next_state := transitionStateString;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassGreater) + 1].Action := transition_action_accumulate; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassGreater) + 1].action := transition_action_accumulate;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassGreater) + 1].NextState := transitionStateGreater; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassGreater) + 1].next_state := transitionStateGreater;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassLess) + 1].Action := transition_action_accumulate; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassLess) + 1].action := transition_action_accumulate;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassLess) + 1].NextState := transitionStateLess; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassLess) + 1].next_state := transitionStateLess;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassOther) + 1].Action := nil; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassOther) + 1].action := nil;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassOther) + 1].NextState := transitionStateEnd; transitions[ORD(transitionStateStart) + 1][ORD(transitionClassOther) + 1].next_state := transitionStateEnd;
(* Colon state. *) (* Colon state. *)
set_default_transition(transitionStateColon, transition_action_finalize, transitionStateEnd); set_default_transition(transitionStateColon, transition_action_finalize, transitionStateEnd);
transitions[ORD(transitionStateColon) + 1][ORD(transitionClassEquals) + 1].Action := transition_action_composite; transitions[ORD(transitionStateColon) + 1][ORD(transitionClassEquals) + 1].action := transition_action_composite;
transitions[ORD(transitionStateColon) + 1][ORD(transitionClassEquals) + 1].NextState := transitionStateEnd; transitions[ORD(transitionStateColon) + 1][ORD(transitionClassEquals) + 1].next_state := transitionStateEnd;
(* Identifier state. *) (* Identifier state. *)
set_default_transition(transitionStateIdentifier, transition_action_key_id, transitionStateEnd); set_default_transition(transitionStateIdentifier, transition_action_key_id, transitionStateEnd);
transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassDigit) + 1].Action := transition_action_accumulate; transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassDigit) + 1].action := transition_action_accumulate;
transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassDigit) + 1].NextState := transitionStateIdentifier; transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassDigit) + 1].next_state := transitionStateIdentifier;
transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassAlpha) + 1].Action := transition_action_accumulate; transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassAlpha) + 1].action := transition_action_accumulate;
transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassAlpha) + 1].NextState := transitionStateIdentifier; transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassAlpha) + 1].next_state := transitionStateIdentifier;
transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassUnderscore) + 1].Action := transition_action_accumulate; transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassUnderscore) + 1].action := transition_action_accumulate;
transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassUnderscore) + 1].NextState := transitionStateIdentifier; transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassUnderscore) + 1].next_state := transitionStateIdentifier;
transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassHex) + 1].Action := transition_action_accumulate; transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassHex) + 1].action := transition_action_accumulate;
transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassHex) + 1].NextState := transitionStateIdentifier; transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassHex) + 1].next_state := transitionStateIdentifier;
transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassZero) + 1].Action := transition_action_accumulate; transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassZero) + 1].action := transition_action_accumulate;
transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassZero) + 1].NextState := transitionStateIdentifier; transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassZero) + 1].next_state := transitionStateIdentifier;
transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassX) + 1].Action := transition_action_accumulate; transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassX) + 1].action := transition_action_accumulate;
transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassX) + 1].NextState := transitionStateIdentifier; transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassX) + 1].next_state := transitionStateIdentifier;
(* Decimal state. *) (* Decimal state. *)
set_default_transition(transitionStateDecimal, transition_action_integer, transitionStateEnd); set_default_transition(transitionStateDecimal, transition_action_integer, transitionStateEnd);
transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassDigit) + 1].Action := transition_action_accumulate; transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassDigit) + 1].action := transition_action_accumulate;
transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassDigit) + 1].NextState := transitionStateDecimal; transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassDigit) + 1].next_state := transitionStateDecimal;
transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassAlpha) + 1].Action := transition_action_accumulate; transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassAlpha) + 1].action := transition_action_accumulate;
transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassAlpha) + 1].NextState := transitionStateDecimalSuffix; transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassAlpha) + 1].next_state := transitionStateDecimalSuffix;
transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassUnderscore) + 1].Action := nil; transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassUnderscore) + 1].action := nil;
transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassUnderscore) + 1].NextState := transitionStateEnd; transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassUnderscore) + 1].next_state := transitionStateEnd;
transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassHex) + 1].Action := transition_action_accumulate; transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassHex) + 1].action := transition_action_accumulate;
transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassHex) + 1].NextState := transitionStateDecimalSuffix; transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassHex) + 1].next_state := transitionStateDecimalSuffix;
transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassZero) + 1].Action := transition_action_accumulate; transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassZero) + 1].action := transition_action_accumulate;
transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassZero) + 1].NextState := transitionStateDecimal; transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassZero) + 1].next_state := transitionStateDecimal;
transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassX) + 1].Action := transition_action_accumulate; transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassX) + 1].action := transition_action_accumulate;
transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassX) + 1].NextState := transitionStateDecimalSuffix; transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassX) + 1].next_state := transitionStateDecimalSuffix;
(* Greater state. *) (* Greater state. *)
set_default_transition(transitionStateGreater, transition_action_finalize, transitionStateEnd); set_default_transition(transitionStateGreater, transition_action_finalize, transitionStateEnd);
transitions[ORD(transitionStateGreater) + 1][ORD(transitionClassEquals) + 1].Action := transition_action_composite; transitions[ORD(transitionStateGreater) + 1][ORD(transitionClassEquals) + 1].action := transition_action_composite;
transitions[ORD(transitionStateGreater) + 1][ORD(transitionClassEquals) + 1].NextState := transitionStateEnd; transitions[ORD(transitionStateGreater) + 1][ORD(transitionClassEquals) + 1].next_state := transitionStateEnd;
(* Minus state. *) (* Minus state. *)
set_default_transition(transitionStateMinus, transition_action_finalize, transitionStateEnd); set_default_transition(transitionStateMinus, transition_action_finalize, transitionStateEnd);
transitions[ORD(transitionStateMinus) + 1][ORD(transitionClassGreater) + 1].Action := transition_action_composite; transitions[ORD(transitionStateMinus) + 1][ORD(transitionClassGreater) + 1].action := transition_action_composite;
transitions[ORD(transitionStateMinus) + 1][ORD(transitionClassGreater) + 1].NextState := transitionStateEnd; transitions[ORD(transitionStateMinus) + 1][ORD(transitionClassGreater) + 1].next_state := transitionStateEnd;
(* Left paren state. *) (* Left paren state. *)
set_default_transition(transitionStateLeftParen, transition_action_finalize, transitionStateEnd); set_default_transition(transitionStateLeftParen, transition_action_finalize, transitionStateEnd);
transitions[ORD(transitionStateLeftParen) + 1][ORD(transitionClassAsterisk) + 1].Action := transition_action_accumulate; transitions[ORD(transitionStateLeftParen) + 1][ORD(transitionClassAsterisk) + 1].action := transition_action_accumulate;
transitions[ORD(transitionStateLeftParen) + 1][ORD(transitionClassAsterisk) + 1].NextState := transitionStateComment; transitions[ORD(transitionStateLeftParen) + 1][ORD(transitionClassAsterisk) + 1].next_state := transitionStateComment;
(* Less state. *) (* Less state. *)
set_default_transition(transitionStateLess, transition_action_finalize, transitionStateEnd); set_default_transition(transitionStateLess, transition_action_finalize, transitionStateEnd);
transitions[ORD(transitionStateLess) + 1][ORD(transitionClassEquals) + 1].Action := transition_action_composite; transitions[ORD(transitionStateLess) + 1][ORD(transitionClassEquals) + 1].action := transition_action_composite;
transitions[ORD(transitionStateLess) + 1][ORD(transitionClassEquals) + 1].NextState := transitionStateEnd; transitions[ORD(transitionStateLess) + 1][ORD(transitionClassEquals) + 1].next_state := transitionStateEnd;
transitions[ORD(transitionStateLess) + 1][ORD(transitionClassGreater) + 1].Action := transition_action_composite; transitions[ORD(transitionStateLess) + 1][ORD(transitionClassGreater) + 1].action := transition_action_composite;
transitions[ORD(transitionStateLess) + 1][ORD(transitionClassGreater) + 1].NextState := transitionStateEnd; transitions[ORD(transitionStateLess) + 1][ORD(transitionClassGreater) + 1].next_state := transitionStateEnd;
(* Hexadecimal after 0x. *) (* Hexadecimal after 0x. *)
set_default_transition(transitionStateDot, transition_action_finalize, transitionStateEnd); set_default_transition(transitionStateDot, transition_action_finalize, transitionStateEnd);
transitions[ORD(transitionStateDot) + 1][ORD(transitionClassDot) + 1].Action := transition_action_composite; transitions[ORD(transitionStateDot) + 1][ORD(transitionClassDot) + 1].action := transition_action_composite;
transitions[ORD(transitionStateDot) + 1][ORD(transitionClassDot) + 1].NextState := transitionStateEnd; transitions[ORD(transitionStateDot) + 1][ORD(transitionClassDot) + 1].next_state := transitionStateEnd;
(* Comment. *) (* Comment. *)
set_default_transition(transitionStateComment, transition_action_accumulate, transitionStateComment); set_default_transition(transitionStateComment, transition_action_accumulate, transitionStateComment);
transitions[ORD(transitionStateComment) + 1][ORD(transitionClassAsterisk) + 1].Action := transition_action_accumulate; transitions[ORD(transitionStateComment) + 1][ORD(transitionClassAsterisk) + 1].action := transition_action_accumulate;
transitions[ORD(transitionStateComment) + 1][ORD(transitionClassAsterisk) + 1].NextState := transitionStateClosingComment; transitions[ORD(transitionStateComment) + 1][ORD(transitionClassAsterisk) + 1].next_state := transitionStateClosingComment;
transitions[ORD(transitionStateComment) + 1][ORD(transitionClassEof) + 1].Action := nil; transitions[ORD(transitionStateComment) + 1][ORD(transitionClassEof) + 1].action := nil;
transitions[ORD(transitionStateComment) + 1][ORD(transitionClassEof) + 1].NextState := transitionStateEnd; transitions[ORD(transitionStateComment) + 1][ORD(transitionClassEof) + 1].next_state := transitionStateEnd;
(* Closing comment. *) (* Closing comment. *)
set_default_transition(transitionStateClosingComment, transition_action_accumulate, transitionStateComment); set_default_transition(transitionStateClosingComment, transition_action_accumulate, transitionStateComment);
transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassInvalid) + 1].Action := nil; transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassInvalid) + 1].action := nil;
transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassInvalid) + 1].NextState := transitionStateEnd; transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassInvalid) + 1].next_state := transitionStateEnd;
transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassRightParen) + 1].Action := transition_action_delimited; transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassRightParen) + 1].action := transition_action_delimited;
transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassRightParen) + 1].NextState := transitionStateEnd; transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassRightParen) + 1].next_state := transitionStateEnd;
transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassAsterisk) + 1].Action := transition_action_accumulate; transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassAsterisk) + 1].action := transition_action_accumulate;
transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassAsterisk) + 1].NextState := transitionStateClosingComment; transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassAsterisk) + 1].next_state := transitionStateClosingComment;
transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassEof) + 1].Action := nil; transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassEof) + 1].action := nil;
transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassEof) + 1].NextState := transitionStateEnd; transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassEof) + 1].next_state := transitionStateEnd;
(* Character. *) (* Character. *)
set_default_transition(transitionStateCharacter, transition_action_accumulate, transitionStateCharacter); set_default_transition(transitionStateCharacter, transition_action_accumulate, transitionStateCharacter);
transitions[ORD(transitionStateCharacter) + 1][ORD(transitionClassInvalid) + 1].Action := nil; transitions[ORD(transitionStateCharacter) + 1][ORD(transitionClassInvalid) + 1].action := nil;
transitions[ORD(transitionStateCharacter) + 1][ORD(transitionClassInvalid) + 1].NextState := transitionStateEnd; transitions[ORD(transitionStateCharacter) + 1][ORD(transitionClassInvalid) + 1].next_state := transitionStateEnd;
transitions[ORD(transitionStateCharacter) + 1][ORD(transitionClassEof) + 1].Action := nil; transitions[ORD(transitionStateCharacter) + 1][ORD(transitionClassEof) + 1].action := nil;
transitions[ORD(transitionStateCharacter) + 1][ORD(transitionClassEof) + 1].NextState := transitionStateEnd; transitions[ORD(transitionStateCharacter) + 1][ORD(transitionClassEof) + 1].next_state := transitionStateEnd;
transitions[ORD(transitionStateCharacter) + 1][ORD(transitionClassSingleQuote) + 1].Action := transition_action_delimited; transitions[ORD(transitionStateCharacter) + 1][ORD(transitionClassSingleQuote) + 1].action := transition_action_delimited;
transitions[ORD(transitionStateCharacter) + 1][ORD(transitionClassSingleQuote) + 1].NextState := transitionStateEnd; transitions[ORD(transitionStateCharacter) + 1][ORD(transitionClassSingleQuote) + 1].next_state := transitionStateEnd;
(* String. *) (* String. *)
set_default_transition(transitionStateString, transition_action_accumulate, transitionStateString); set_default_transition(transitionStateString, transition_action_accumulate, transitionStateString);
transitions[ORD(transitionStateString) + 1][ORD(transitionClassInvalid) + 1].Action := nil; transitions[ORD(transitionStateString) + 1][ORD(transitionClassInvalid) + 1].action := nil;
transitions[ORD(transitionStateString) + 1][ORD(transitionClassInvalid) + 1].NextState := transitionStateEnd; transitions[ORD(transitionStateString) + 1][ORD(transitionClassInvalid) + 1].next_state := transitionStateEnd;
transitions[ORD(transitionStateString) + 1][ORD(transitionClassEof) + 1].Action := nil; transitions[ORD(transitionStateString) + 1][ORD(transitionClassEof) + 1].action := nil;
transitions[ORD(transitionStateString) + 1][ORD(transitionClassEof) + 1].NextState := transitionStateEnd; transitions[ORD(transitionStateString) + 1][ORD(transitionClassEof) + 1].next_state := transitionStateEnd;
transitions[ORD(transitionStateString) + 1][ORD(transitionClassDoubleQuote) + 1].Action := transition_action_delimited; transitions[ORD(transitionStateString) + 1][ORD(transitionClassDoubleQuote) + 1].action := transition_action_delimited;
transitions[ORD(transitionStateString) + 1][ORD(transitionClassDoubleQuote) + 1].NextState := transitionStateEnd; transitions[ORD(transitionStateString) + 1][ORD(transitionClassDoubleQuote) + 1].next_state := transitionStateEnd;
(* Leading zero. *) (* Leading zero. *)
set_default_transition(transitionStateLeadingZero, transition_action_integer, transitionStateEnd); set_default_transition(transitionStateLeadingZero, transition_action_integer, transitionStateEnd);
transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassDigit) + 1].Action := nil; transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassDigit) + 1].action := nil;
transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassDigit) + 1].NextState := transitionStateEnd; transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassDigit) + 1].next_state := transitionStateEnd;
transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassAlpha) + 1].Action := nil; transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassAlpha) + 1].action := nil;
transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassAlpha) + 1].NextState := transitionStateEnd; transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassAlpha) + 1].next_state := transitionStateEnd;
transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassUnderscore) + 1].Action := nil; transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassUnderscore) + 1].action := nil;
transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassUnderscore) + 1].NextState := transitionStateEnd; transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassUnderscore) + 1].next_state := transitionStateEnd;
transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassHex) + 1].Action := nil; transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassHex) + 1].action := nil;
transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassHex) + 1].NextState := transitionStateEnd; transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassHex) + 1].next_state := transitionStateEnd;
transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassZero) + 1].Action := nil; transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassZero) + 1].action := nil;
transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassZero) + 1].NextState := transitionStateEnd; transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassZero) + 1].next_state := transitionStateEnd;
transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassX) + 1].Action := nil; transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassX) + 1].action := nil;
transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassX) + 1].NextState := transitionStateEnd; transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassX) + 1].next_state := transitionStateEnd;
(* Digit with a character suffix. *) (* Digit with a character suffix. *)
set_default_transition(transitionStateDecimalSuffix, transition_action_integer, transitionStateEnd); set_default_transition(transitionStateDecimalSuffix, transition_action_integer, transitionStateEnd);
transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassAlpha) + 1].Action := nil; transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassAlpha) + 1].action := nil;
transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassAlpha) + 1].NextState := transitionStateEnd; transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassAlpha) + 1].next_state := transitionStateEnd;
transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassDigit) + 1].Action := nil; transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassDigit) + 1].action := nil;
transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassDigit) + 1].NextState := transitionStateEnd; transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassDigit) + 1].next_state := transitionStateEnd;
transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassHex) + 1].Action := nil; transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassHex) + 1].action := nil;
transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassHex) + 1].NextState := transitionStateEnd; transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassHex) + 1].next_state := transitionStateEnd;
transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassZero) + 1].Action := nil; transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassZero) + 1].action := nil;
transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassZero) + 1].NextState := transitionStateEnd; transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassZero) + 1].next_state := transitionStateEnd;
transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassX) + 1].Action := nil; transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassX) + 1].action := nil;
transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassX) + 1].NextState := transitionStateEnd transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassX) + 1].next_state := transitionStateEnd
end; end;
proc lexer_initialize(lexer: PLexer, Input: File); proc lexer_initialize(lexer: PLexer, input: File);
begin begin
lexer^.Input := Input; lexer^.input := input;
lexer^.Length := 0; lexer^.length := 0;
ALLOCATE(lexer^.Buffer, CHUNK_SIZE); ALLOCATE(lexer^.buffer, CHUNK_SIZE);
MemZero(lexer^.Buffer, CHUNK_SIZE); MemZero(lexer^.buffer, CHUNK_SIZE);
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; current_class: TransitionClass;
CurrentState: TransitionState; current_state: TransitionState;
CurrentTransition: Transition; current_transition: Transition;
result: LexerToken; result: LexerToken;
begin begin
lexer^.Current := lexer^.Start; lexer^.current := lexer^.start;
CurrentState := transitionStateStart; current_state := transitionStateStart;
while CurrentState <> transitionStateEnd DO while current_state <> transitionStateEnd DO
CurrentClass := classification[ORD(lexer^.Current^) + 1]; current_class := classification[ORD(lexer^.current^) + 1];
CurrentTransition := transitions[ORD(CurrentState) + 1][ORD(CurrentClass) + 1]; current_transition := transitions[ORD(current_state) + 1][ORD(current_class) + 1];
if CurrentTransition.Action <> nil then if current_transition.action <> nil then
CurrentTransition.Action(lexer, ADR(result)) current_transition.action(lexer, ADR(result))
end; end;
CurrentState := CurrentTransition.NextState current_state := current_transition.next_state
end; end;
return result return result
end; end;
@ -813,11 +821,11 @@ 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);
lexer^.Current := lexer^.Buffer lexer^.current := lexer^.buffer
end; end;
lexer^.Start := lexer^.Current; lexer^.start := lexer^.current;
result := lexer_current(lexer); result := lexer_current(lexer);
return result return result
@ -825,7 +833,7 @@ end;
proc lexer_destroy(lexer: PLexer); proc lexer_destroy(lexer: PLexer);
begin begin
DEALLOCATE(lexer^.Buffer, lexer^.Size) DEALLOCATE(lexer^.buffer, lexer^.size)
end; end;
begin begin

40
source/Parser.def
View File

@ -7,21 +7,42 @@ TYPE
AstLiteralKind = ( AstLiteralKind = (
astLiteralKindInteger, astLiteralKindInteger,
astLiteralKindString, astLiteralKindString,
astLiteralKindNull astLiteralKindNull,
astLiteralKindBoolean
); );
AstLiteral = RECORD AstLiteral = RECORD
CASE kind: AstLiteralKind OF CASE kind: AstLiteralKind OF
astLiteralKindInteger: integer: INTEGER | astLiteralKindInteger: integer: INTEGER |
astLiteralKindString: string: ShortString | astLiteralKindString: string: ShortString |
astLiteralKindNull: astLiteralKindNull: |
astLiteralKindBoolean: boolean: BOOLEAN
END END
END; END;
PAstLiteral = POINTER TO AstLiteral; PAstLiteral = POINTER TO AstLiteral;
AstUnaryOperator = ( AstUnaryOperator = (
astUnaryOperatorReference,
astUnaryOperatorNot, astUnaryOperatorNot,
astUnaryOperatorMinus astUnaryOperatorMinus
); );
AstBinaryOperator = (
astBinaryOperatorSum,
astBinaryOperatorSubtraction,
astBinaryOperatorMultiplication,
astBinaryOperatorDivision,
astBinaryOperatorRemainder,
astBinaryOperatorEquals,
astBinaryOperatorNotEquals,
astBinaryOperatorLess,
astBinaryOperatorGreater,
astBinaryOperatorLessEqual,
astBinaryOperatorGreaterEqual,
astBinaryOperatorDisjunction,
astBinaryOperatorConjunction,
astBinaryOperatorExclusiveDisjunction,
astBinaryOperatorShiftLeft,
astBinaryOperatorShiftRight
);
AstExpressionKind = ( AstExpressionKind = (
astExpressionKindLiteral, astExpressionKindLiteral,
@ -29,7 +50,9 @@ TYPE
astExpressionKindArrayAccess, astExpressionKindArrayAccess,
astExpressionKindDereference, astExpressionKindDereference,
astExpressionKindFieldAccess, astExpressionKindFieldAccess,
astExpressionKindUnary astExpressionKindUnary,
astExpressionKindBinary,
astExpressionKindCall
); );
AstExpression = RECORD AstExpression = RECORD
CASE kind: AstExpressionKind OF CASE kind: AstExpressionKind OF
@ -44,7 +67,15 @@ TYPE
field: Identifier | field: Identifier |
astExpressionKindUnary: astExpressionKindUnary:
unary_operator: AstUnaryOperator; unary_operator: AstUnaryOperator;
unary_operand: PAstExpression unary_operand: PAstExpression |
astExpressionKindBinary:
binary_operator: AstBinaryOperator;
lhs: PAstExpression;
rhs: PAstExpression |
astExpressionKindCall:
callable: PAstExpression;
argument_count: CARDINAL;
arguments: PPAstExpression
END END
END; END;
PAstExpression = POINTER TO AstExpression; PAstExpression = POINTER TO AstExpression;
@ -121,5 +152,6 @@ PROCEDURE parse_variable_part(lexer: PLexer): PPAstVariableDeclaration;
PROCEDURE parse_constant_part(lexer: PLexer): PPAstConstantDeclaration; PROCEDURE parse_constant_part(lexer: PLexer): PPAstConstantDeclaration;
PROCEDURE parse_import_part(lexer: PLexer): PPAstImportStatement; PROCEDURE parse_import_part(lexer: PLexer): PPAstImportStatement;
PROCEDURE parse_designator(lexer: PLexer): PAstExpression; PROCEDURE parse_designator(lexer: PLexer): PAstExpression;
PROCEDURE parse_expression(lexer: PLexer): PAstExpression;
END Parser. END Parser.

108
source/Parser.elna
View File

@ -5,7 +5,7 @@ from SYSTEM import TSIZE;
from MemUtils import MemZero; from MemUtils import MemZero;
from Storage import ALLOCATE, REALLOCATE; from Storage import ALLOCATE, REALLOCATE;
from Lexer import LexerKind, LexerToken, lexer_current, lexer_lex; from Lexer import Lexer, LexerKind, LexerToken, lexer_current, lexer_lex;
(* 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;
@ -476,7 +476,7 @@ begin
literal^.kind := astLiteralKindInteger; literal^.kind := astLiteralKindInteger;
literal^.integer := token.integerKind; literal^.integer := token.integerKind;
end; end;
if token.kind = lexerKindCharacter then if (token.kind = lexerKindCharacter) or (token.kind = lexerKindString) then
NEW(literal); NEW(literal);
literal^.kind := astLiteralKindString; literal^.kind := astLiteralKindString;
@ -487,6 +487,12 @@ begin
literal^.kind := astLiteralKindNull; literal^.kind := astLiteralKindNull;
end; end;
if token.kind = lexerKindBoolean then
NEW(literal);
literal^.kind := astLiteralKindBoolean;
literal^.boolean := token.booleanKind
end;
if literal <> nil then if literal <> nil then
token := transpiler_lex(lexer) token := transpiler_lex(lexer)
end; end;
@ -544,6 +550,7 @@ var
next_token: LexerToken; next_token: LexerToken;
inner_expression: PAstExpression; inner_expression: PAstExpression;
designator: PAstExpression; designator: PAstExpression;
arguments: PPAstExpression;
handled: BOOLEAN; handled: BOOLEAN;
begin begin
designator := parse_factor(lexer); designator := parse_factor(lexer);
@ -582,6 +589,38 @@ begin
designator^.aggregate := inner_expression; designator^.aggregate := inner_expression;
designator^.field := next_token.identifierKind; designator^.field := next_token.identifierKind;
next_token := transpiler_lex(lexer);
handled := true
end;
if ~handled & (next_token.kind = lexerKindLeftParen) then
NEW(designator);
next_token := transpiler_lex(lexer);
designator^.kind := astExpressionKindCall;
designator^.callable := inner_expression;
designator^.argument_count := 0;
designator^.arguments := nil;
if next_token.kind <> lexerKindRightParen then
ALLOCATE(designator^.arguments, TSIZE(PAstExpression));
designator^.argument_count := 1;
designator^.arguments^ := parse_designator(lexer);
next_token := lexer_current(lexer);
while next_token.kind = lexerKindComma do
next_token := transpiler_lex(lexer);
designator^.argument_count := designator^.argument_count + 1;
REALLOCATE(designator^.arguments, TSIZE(PAstExpression) * designator^.argument_count);
arguments := designator^.arguments;
INC(arguments, TSIZE(PAstExpression) * (designator^.argument_count - 1));
arguments^ := parse_designator(lexer);
next_token := lexer_current(lexer)
end
end;
next_token := transpiler_lex(lexer); next_token := transpiler_lex(lexer);
handled := true handled := true
end end
@ -590,4 +629,69 @@ begin
return designator return designator
end; end;
proc parse_binary_expression(lexer: PLexer, left: PAstExpression, operator: AstBinaryOperator) -> PAstExpression;
var
next_token: LexerToken;
result: PAstExpression;
right: PAstExpression;
begin
next_token := transpiler_lex(lexer);
right := parse_designator(lexer);
result := nil;
if right <> nil then
NEW(result);
result^.kind := astExpressionKindBinary;
result^.binary_operator := operator;
result^.lhs := left;
result^.rhs := right;
end;
return result
end;
proc parse_expression(lexer: PLexer) -> PAstExpression;
var
next_token: LexerToken;
left: PAstExpression;
result: PAstExpression;
saved: Lexer;
begin
left := parse_designator(lexer);
saved := lexer^;
result := nil;
next_token := lexer_current(lexer);
if (left <> nil) & (result = nil) & (next_token.kind = lexerKindNotEqual) then
result := parse_binary_expression(lexer, left, astBinaryOperatorNotEquals)
end;
if (left <> nil) & (result = nil) & (next_token.kind = lexerKindEqual) then
result := parse_binary_expression(lexer, left, astBinaryOperatorEquals)
end;
if (left <> nil) & (result = nil) & (next_token.kind = lexerKindGreaterThan) then
result := parse_binary_expression(lexer, left, astBinaryOperatorGreater)
end;
if (left <> nil) & (result = nil) & (next_token.kind = lexerKindLessThan) then
result := parse_binary_expression(lexer, left, astBinaryOperatorLess)
end;
if (left <> nil) & (result = nil) & (next_token.kind = lexerKindGreaterEqual) then
result := parse_binary_expression(lexer, left, astBinaryOperatorGreaterEqual)
end;
if (left <> nil) & (result = nil) & (next_token.kind = lexerKindLessEqual) then
result := parse_binary_expression(lexer, left, astBinaryOperatorLessEqual)
end;
if (left <> nil) & (result = nil) & (next_token.kind = lexerKindAnd) then
result := parse_binary_expression(lexer, left, astBinaryOperatorConjunction)
end;
if (left <> nil) & (result = nil) & (next_token.kind = lexerKindOr) then
result := parse_binary_expression(lexer, left, astBinaryOperatorDisjunction)
end;
if (result = nil) & (left <> nil) then
result := left;
lexer^ := saved
end;
return result
end;
end. end.

110
source/Transpiler.elna
View File

@ -9,14 +9,14 @@ from MemUtils import MemCopy, MemZero;
from Common import Identifier, PIdentifier, ShortString; from Common import Identifier, PIdentifier, ShortString;
from Lexer import Lexer, LexerToken, lexer_current, lexer_lex, LexerKind; from Lexer import Lexer, LexerToken, lexer_current, lexer_lex, LexerKind;
from Parser import AstTypeExpressionKind, AstExpressionKind, AstLiteralKind, AstUnaryOperator, from Parser import AstTypeExpressionKind, AstExpressionKind, AstLiteralKind, AstUnaryOperator, AstBinaryOperator,
AstModule, PAstModule, AstExpression, PAstExpression, PAstLiteral, AstModule, PAstModule, AstExpression, PPAstExpression, PAstExpression, PAstLiteral,
PAstConstantDeclaration, PPAstConstantDeclaration, PAstConstantDeclaration, PPAstConstantDeclaration,
AstTypeDeclaration, PAstTypeDeclaration, PPAstTypeDeclaration, AstTypeDeclaration, PAstTypeDeclaration, PPAstTypeDeclaration,
PAstVariableDeclaration, PPAstVariableDeclaration, PAstImportStatement, PPAstImportStatement, PAstVariableDeclaration, PPAstVariableDeclaration, PAstImportStatement, PPAstImportStatement,
PAstTypeExpression, PPAstTypeExpression, AstFieldDeclaration, PAstFieldDeclaration, PAstTypeExpression, PPAstTypeExpression, AstFieldDeclaration, PAstFieldDeclaration,
parse_type_expression, parse_variable_part, parse_type_part, parse_constant_part, parse_import_part, parse_type_expression, parse_variable_part, parse_type_part, parse_constant_part, parse_import_part,
parse_designator; parse_designator, parse_expression;
(* 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;
@ -43,7 +43,7 @@ proc write_current(lexer: PLexer, output: File);
var var
written_bytes: CARDINAL; written_bytes: CARDINAL;
begin begin
written_bytes := WriteNBytes(output, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start) written_bytes := WriteNBytes(output, ADDRESS(lexer^.current - lexer^.start), lexer^.start)
end; end;
proc transpile_import_statement(context: PTranspilerContext, import_statement: PAstImportStatement); proc transpile_import_statement(context: PTranspilerContext, import_statement: PAstImportStatement);
@ -447,20 +447,6 @@ begin
end end
end; end;
proc parse_expression(lexer: PLexer) -> PAstExpression;
var
next_token: LexerToken;
result: PAstExpression;
written_bytes: CARDINAL;
begin
result := parse_designator(lexer);
written_bytes := WriteNBytes(StdErr, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
WriteLine(StdErr);
return result
end;
proc transpile_unary_operator(context: PTranspilerContext, operator: AstUnaryOperator); proc transpile_unary_operator(context: PTranspilerContext, operator: AstUnaryOperator);
begin begin
if operator = astUnaryOperatorMinus then if operator = astUnaryOperatorMinus then
@ -471,11 +457,50 @@ begin
end end
end; end;
proc transpile_binary_operator(context: PTranspilerContext, operator: AstBinaryOperator);
begin
if operator = astBinaryOperatorSum then
WriteChar(context^.output, '+')
end;
if operator = astBinaryOperatorSubtraction then
WriteChar(context^.output, '-')
end;
if operator = astBinaryOperatorMultiplication then
WriteChar(context^.output, '*')
end;
if operator = astBinaryOperatorEquals then
WriteChar(context^.output, '=')
end;
if operator = astBinaryOperatorNotEquals then
WriteChar(context^.output, '#')
end;
if operator = astBinaryOperatorLess then
WriteChar(context^.output, '<')
end;
if operator = astBinaryOperatorGreater then
WriteChar(context^.output, '>')
end;
if operator = astBinaryOperatorLessEqual then
WriteString(context^.output, '<=')
end;
if operator = astBinaryOperatorGreaterEqual then
WriteString(context^.output, '>=')
end;
if operator = astBinaryOperatorDisjunction then
WriteString(context^.output, 'OR')
end;
if operator = astBinaryOperatorConjunction then
WriteString(context^.output, 'AND')
end
end;
proc transpile_expression(context: PTranspilerContext, expression: PAstExpression); proc transpile_expression(context: PTranspilerContext, expression: PAstExpression);
var var
literal: PAstLiteral; literal: PAstLiteral;
buffer: [20]CHAR; buffer: [20]CHAR;
written_bytes: CARDINAL; written_bytes: CARDINAL;
argument_index: CARDINAL;
current_argument: PPAstExpression;
begin begin
if expression^.kind = astExpressionKindLiteral then if expression^.kind = astExpressionKindLiteral then
literal := expression^.literal; literal := expression^.literal;
@ -486,7 +511,16 @@ begin
end; end;
if literal^.kind = astLiteralKindString then if literal^.kind = astLiteralKindString then
WriteString(context^.output, literal^.string) WriteString(context^.output, literal^.string)
end end;
if literal^.kind = astLiteralKindNull then
WriteString(context^.output, 'NIL')
end;
if (literal^.kind = astLiteralKindBoolean) & literal^.boolean then
WriteString(context^.output, 'TRUE')
end;
if (literal^.kind = astLiteralKindBoolean) & (literal^.boolean = false) then
WriteString(context^.output, 'FALSE')
end
end; end;
if expression^.kind = astExpressionKindIdentifier then if expression^.kind = astExpressionKindIdentifier then
written_bytes := WriteNBytes(context^.output, ORD(expression^.identifier[1]), ADR(expression^.identifier[2])) written_bytes := WriteNBytes(context^.output, ORD(expression^.identifier[1]), ADR(expression^.identifier[2]))
@ -509,6 +543,35 @@ begin
if expression^.kind = astExpressionKindUnary then if expression^.kind = astExpressionKindUnary then
transpile_unary_operator(context, expression^.unary_operator); transpile_unary_operator(context, expression^.unary_operator);
transpile_expression(context, expression^.unary_operand) transpile_expression(context, expression^.unary_operand)
end;
if expression^.kind = astExpressionKindBinary then
transpile_expression(context, expression^.lhs);
WriteChar(context^.output, ' ');
transpile_binary_operator(context, expression^.binary_operator);
WriteChar(context^.output, ' ');
transpile_expression(context, expression^.rhs)
end;
if expression^.kind = astExpressionKindCall then
transpile_expression(context, expression^.callable);
WriteChar(context^.output, '(');
current_argument := expression^.arguments;
if expression^.argument_count > 0 then
transpile_expression(context, current_argument^);
argument_index := 1;
INC(current_argument, TSIZE(PAstExpression));
while argument_index < expression^.argument_count do
WriteString(context^.output, ', ');
transpile_expression(context, current_argument^);
INC(current_argument, TSIZE(PAstExpression));
INC(argument_index)
end
end;
WriteChar(context^.output, ')')
end end
end; end;
@ -517,11 +580,12 @@ var
token: LexerToken; token: LexerToken;
expression: PAstExpression; expression: PAstExpression;
lexer: Lexer; lexer: Lexer;
written_bytes: CARDINAL;
begin begin
WriteString(context^.output, ' IF '); WriteString(context^.output, ' IF ');
token := transpiler_lex(context^.lexer);
lexer := context^.lexer^; lexer := context^.lexer^;
token := transpiler_lex(ADR(lexer));
expression := parse_expression(ADR(lexer)); expression := parse_expression(ADR(lexer));
if expression <> nil then if expression <> nil then
@ -529,8 +593,10 @@ begin
transpile_expression(context, expression); transpile_expression(context, expression);
WriteChar(context^.output, ' ') WriteChar(context^.output, ' ')
end; end;
if expression = nil then token := lexer_current(context^.lexer);
token := transpiler_lex(context^.lexer) if token.kind <> lexerKindThen then
written_bytes := WriteNBytes(StdErr, 10, context^.lexer^.start);
WriteLine(StdErr)
end; end;
transpile_unchanged(context, lexerKindThen); transpile_unchanged(context, lexerKindThen);