From 62cdd39f51da67ec9235daed6149e6987a79bebd Mon Sep 17 00:00:00 2001 From: Eugen Wissner Date: Sat, 7 Jun 2025 23:50:33 +0200 Subject: [PATCH] Parse call expressions --- source/Lexer.def | 20 +- source/Lexer.mod | 520 +++++++++++++++++++++--------------------- source/Parser.def | 40 +++- source/Parser.mod | 106 ++++++++- source/Transpiler.mod | 108 +++++++-- 5 files changed, 501 insertions(+), 293 deletions(-) diff --git a/source/Lexer.def b/source/Lexer.def index ce6fd01..bd3fbcf 100644 --- a/source/Lexer.def +++ b/source/Lexer.def @@ -7,12 +7,12 @@ FROM Common IMPORT Identifier, ShortString; TYPE PLexerBuffer = POINTER TO CHAR; Lexer = RECORD - Input: File; - Buffer: PLexerBuffer; - Size: CARDINAL; - Length: CARDINAL; - Start: PLexerBuffer; - Current: PLexerBuffer + input: File; + buffer: PLexerBuffer; + size: CARDINAL; + length: CARDINAL; + start: PLexerBuffer; + current: PLexerBuffer END; PLexer = POINTER TO Lexer; LexerKind = ( @@ -90,11 +90,11 @@ TYPE END; PLexerToken = POINTER TO LexerToken; -PROCEDURE lexer_initialize(ALexer: PLexer; Input: File); -PROCEDURE lexer_destroy(ALexer: PLexer); +PROCEDURE lexer_initialize(lexer: PLexer; input: File); +PROCEDURE lexer_destroy(lexer: PLexer); (* Returns the last read token. *) -PROCEDURE lexer_current(ALexer: PLexer): LexerToken; +PROCEDURE lexer_current(lexer: PLexer): LexerToken; (* Read and return the next token. *) -PROCEDURE lexer_lex(ALexer: PLexer): LexerToken; +PROCEDURE lexer_lex(lexer: PLexer): LexerToken; END Lexer. diff --git a/source/Lexer.mod b/source/Lexer.mod index 4d8ca20..a6834ae 100644 --- a/source/Lexer.mod +++ b/source/Lexer.mod @@ -64,8 +64,8 @@ TYPE ); TransitionAction = PROCEDURE(PLexer, PLexerToken); Transition = RECORD - Action: TransitionAction; - NextState: TransitionState + action: TransitionAction; + next_state: TransitionState END; TransitionClasses = ARRAY[1..22] OF Transition; @@ -212,7 +212,7 @@ BEGIN i := i + 1 END END initialize_classification; -PROCEDURE compare_keyword(Keyword: ARRAY OF CHAR; TokenStart: PLexerBuffer; TokenEnd: PLexerBuffer): BOOLEAN; +PROCEDURE compare_keyword(keyword: ARRAY OF CHAR; token_start: PLexerBuffer; token_end: PLexerBuffer): BOOLEAN; VAR result: BOOLEAN; index: CARDINAL; @@ -220,12 +220,12 @@ BEGIN index := 0; result := TRUE; - WHILE (index < Length(Keyword)) AND (TokenStart <> TokenEnd) AND result DO - result := (Keyword[index] = TokenStart^) OR (Lower(Keyword[index]) = TokenStart^); - INC(TokenStart); + WHILE (index < Length(keyword)) AND (token_start <> token_end) AND result DO + result := (keyword[index] = token_start^) OR (Lower(keyword[index]) = token_start^); + INC(token_start); INC(index) END; - result := (index = Length(Keyword)) AND (TokenStart = TokenEnd) AND result; + result := (index = Length(keyword)) AND (token_start = token_end) AND result; RETURN result END compare_keyword; (* Reached the end of file. *) @@ -236,182 +236,190 @@ END transition_action_eof; (* Add the character to the token currently read and advance to the next character. *) PROCEDURE transition_action_accumulate(lexer: PLexer; token: PLexerToken); BEGIN - INC(lexer^.Current) + 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; token: PLexerToken); BEGIN - IF lexer^.Start^ = ':' THEN + IF lexer^.start^ = ':' THEN token^.kind := lexerKindColon END; - IF lexer^.Start^ = '>' THEN + IF lexer^.start^ = '>' THEN token^.kind := lexerKindGreaterThan END; - IF lexer^.Start^ = '<' THEN + IF lexer^.start^ = '<' THEN token^.kind := lexerKindLessThan END; - IF lexer^.Start^ = '(' THEN + IF lexer^.start^ = '(' THEN token^.kind := lexerKindLeftParen END; - IF lexer^.Start^ = '-' THEN + IF lexer^.start^ = '-' THEN token^.kind := lexerKindLeftParen END; - IF lexer^.Start^ = '.' THEN + IF lexer^.start^ = '.' THEN token^.kind := lexerKindDot END END transition_action_finalize; (* An action for tokens containing multiple characters. *) PROCEDURE transition_action_composite(lexer: PLexer; token: PLexerToken); BEGIN - IF lexer^.Start^ = '<' THEN - IF lexer^.Current^ = '>' THEN + IF lexer^.start^ = '<' THEN + IF lexer^.current^ = '>' THEN token^.kind := lexerKindNotEqual END; - IF lexer^.Current^ = '=' THEN + IF lexer^.current^ = '=' THEN token^.kind := lexerKindLessEqual END END; - IF (lexer^.Start^ = '>') AND (lexer^.Current^ = '=') THEN + IF (lexer^.start^ = '>') AND (lexer^.current^ = '=') THEN token^.kind := lexerKindGreaterEqual END; - IF (lexer^.Start^ = '.') AND (lexer^.Current^ = '.') THEN + IF (lexer^.start^ = '.') AND (lexer^.current^ = '.') THEN token^.kind := lexerKindRange END; - IF (lexer^.Start^ = ':') AND (lexer^.Current^ = '=') THEN + IF (lexer^.start^ = ':') AND (lexer^.current^ = '=') THEN token^.kind := lexerKindAssignment END; - IF (lexer^.Start^ = '-') AND (lexer^.Current^ = '>') THEN + IF (lexer^.start^ = '-') AND (lexer^.current^ = '>') THEN token^.kind := lexerKindArrow END; - INC(lexer^.Current) + INC(lexer^.current) END transition_action_composite; (* Skip a space. *) PROCEDURE transition_action_skip(lexer: PLexer; token: PLexerToken); BEGIN - INC(lexer^.Current); - INC(lexer^.Start) + INC(lexer^.current); + INC(lexer^.start) END transition_action_skip; (* Delimited string action. *) PROCEDURE transition_action_delimited(lexer: PLexer; token: PLexerToken); VAR text_length: CARDINAL; BEGIN - IF lexer^.Start^ = '(' THEN + IF lexer^.start^ = '(' THEN token^.kind := lexerKindComment 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 END; - IF lexer^.Start^ = "'" THEN - text_length := lexer^.Current - lexer^.Start; + 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)); + MemCopy(lexer^.start, text_length, ADR(token^.stringKind)); token^.kind := lexerKindString END; - INC(lexer^.Current) + INC(lexer^.current) END transition_action_delimited; (* Finalize keyword OR identifier. *) PROCEDURE transition_action_key_id(lexer: PLexer; token: PLexerToken); BEGIN token^.kind := lexerKindIdentifier; - token^.identifierKind[1] := lexer^.Current - lexer^.Start; - MemCopy(lexer^.Start, ORD(token^.identifierKind[1]), ADR(token^.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 + IF compare_keyword('PROGRAM', lexer^.start, lexer^.current) THEN token^.kind := lexerKindProgram END; - IF compare_keyword('IMPORT', lexer^.Start, lexer^.Current) THEN + IF compare_keyword('IMPORT', lexer^.start, lexer^.current) THEN token^.kind := lexerKindImport END; - IF compare_keyword('CONST', lexer^.Start, lexer^.Current) THEN + IF compare_keyword('CONST', lexer^.start, lexer^.current) THEN token^.kind := lexerKindConst END; - IF compare_keyword('VAR', lexer^.Start, lexer^.Current) THEN + IF compare_keyword('VAR', lexer^.start, lexer^.current) THEN token^.kind := lexerKindVar END; - IF compare_keyword('IF', lexer^.Start, lexer^.Current) THEN + IF compare_keyword('IF', lexer^.start, lexer^.current) THEN token^.kind := lexerKindIf END; - IF compare_keyword('THEN', lexer^.Start, lexer^.Current) THEN + IF compare_keyword('THEN', lexer^.start, lexer^.current) THEN token^.kind := lexerKindThen END; - IF compare_keyword('ELSIF', lexer^.Start, lexer^.Current) THEN + IF compare_keyword('ELSIF', lexer^.start, lexer^.current) THEN token^.kind := lexerKindElsif END; - IF compare_keyword('ELSE', lexer^.Start, lexer^.Current) THEN + IF compare_keyword('ELSE', lexer^.start, lexer^.current) THEN token^.kind := lexerKindElse END; - IF compare_keyword('WHILE', lexer^.Start, lexer^.Current) THEN + IF compare_keyword('WHILE', lexer^.start, lexer^.current) THEN token^.kind := lexerKindWhile END; - IF compare_keyword('DO', lexer^.Start, lexer^.Current) THEN + IF compare_keyword('DO', lexer^.start, lexer^.current) THEN token^.kind := lexerKindDo END; - IF compare_keyword('proc', lexer^.Start, lexer^.Current) THEN + IF compare_keyword('proc', lexer^.start, lexer^.current) THEN token^.kind := lexerKindProc END; - IF compare_keyword('BEGIN', lexer^.Start, lexer^.Current) THEN + IF compare_keyword('BEGIN', lexer^.start, lexer^.current) THEN token^.kind := lexerKindBegin END; - IF compare_keyword('END', lexer^.Start, lexer^.Current) THEN + IF compare_keyword('END', lexer^.start, lexer^.current) THEN token^.kind := lexerKindEnd END; - IF compare_keyword('TYPE', lexer^.Start, lexer^.Current) THEN + IF compare_keyword('TYPE', lexer^.start, lexer^.current) THEN token^.kind := lexerKindType END; - IF compare_keyword('RECORD', lexer^.Start, lexer^.Current) THEN + IF compare_keyword('RECORD', lexer^.start, lexer^.current) THEN token^.kind := lexerKindRecord END; - IF compare_keyword('UNION', lexer^.Start, lexer^.Current) THEN + IF compare_keyword('UNION', lexer^.start, lexer^.current) THEN token^.kind := lexerKindUnion END; - IF compare_keyword('NIL', lexer^.Start, lexer^.Current) THEN + IF compare_keyword('NIL', lexer^.start, lexer^.current) THEN token^.kind := lexerKindNull END; - IF compare_keyword('AND', lexer^.Start, lexer^.Current) THEN + IF compare_keyword('AND', lexer^.start, lexer^.current) THEN token^.kind := lexerKindAnd END; - IF compare_keyword('OR', lexer^.Start, lexer^.Current) THEN + IF compare_keyword('OR', lexer^.start, lexer^.current) THEN token^.kind := lexerKindOr END; - IF compare_keyword('RETURN', lexer^.Start, lexer^.Current) THEN + IF compare_keyword('RETURN', lexer^.start, lexer^.current) THEN token^.kind := lexerKindReturn END; - IF compare_keyword('DEFINITION', lexer^.Start, lexer^.Current) THEN + IF compare_keyword('DEFINITION', lexer^.start, lexer^.current) THEN token^.kind := lexerKindDefinition END; - IF compare_keyword('TO', lexer^.Start, lexer^.Current) THEN + IF compare_keyword('TO', lexer^.start, lexer^.current) THEN token^.kind := lexerKindTo END; - IF compare_keyword('CASE', lexer^.Start, lexer^.Current) THEN + IF compare_keyword('CASE', lexer^.start, lexer^.current) THEN token^.kind := lexerKindCase END; - IF compare_keyword('OF', lexer^.Start, lexer^.Current) THEN + IF compare_keyword('OF', lexer^.start, lexer^.current) THEN token^.kind := lexerKindOf END; - IF compare_keyword('FROM', lexer^.Start, lexer^.Current) THEN + IF compare_keyword('FROM', lexer^.start, lexer^.current) THEN token^.kind := lexerKindFrom END; - IF compare_keyword('MODULE', lexer^.Start, lexer^.Current) THEN + IF compare_keyword('MODULE', lexer^.start, lexer^.current) THEN token^.kind := lexerKindModule END; - IF compare_keyword('IMPLEMENTATION', lexer^.Start, lexer^.Current) THEN + IF compare_keyword('IMPLEMENTATION', lexer^.start, lexer^.current) THEN token^.kind := lexerKindImplementation END; - IF compare_keyword('POINTER', lexer^.Start, lexer^.Current) THEN + IF compare_keyword('POINTER', lexer^.start, lexer^.current) THEN token^.kind := lexerKindPointer END; - IF compare_keyword('ARRAY', lexer^.Start, lexer^.Current) THEN + IF compare_keyword('ARRAY', lexer^.start, lexer^.current) THEN token^.kind := lexerKindArray END; - IF compare_keyword('TRUE', lexer^.Start, lexer^.Current) THEN + IF compare_keyword('TRUE', lexer^.start, lexer^.current) THEN token^.kind := lexerKindBoolean; token^.booleanKind := TRUE END; - IF compare_keyword('FALSE', lexer^.Start, lexer^.Current) THEN + IF compare_keyword('FALSE', lexer^.start, lexer^.current) THEN token^.kind := lexerKindBoolean; token^.booleanKind := FALSE END @@ -420,49 +428,49 @@ END transition_action_key_id; * followed by other characters forming a composite token. *) PROCEDURE transition_action_single(lexer: PLexer; token: PLexerToken); BEGIN - IF lexer^.Current^ = '&' THEN + IF lexer^.current^ = '&' THEN token^.kind := lexerKindAnd END; - IF lexer^.Current^ = ';' THEN + IF lexer^.current^ = ';' THEN token^.kind := lexerKindSemicolon END; - IF lexer^.Current^ = ',' THEN + IF lexer^.current^ = ',' THEN token^.kind := lexerKindComma END; - IF lexer^.Current^ = '~' THEN + IF lexer^.current^ = '~' THEN token^.kind := lexerKindTilde END; - IF lexer^.Current^ = ')' THEN + IF lexer^.current^ = ')' THEN token^.kind := lexerKindRightParen END; - IF lexer^.Current^ = '[' THEN + IF lexer^.current^ = '[' THEN token^.kind := lexerKindLeftSquare END; - IF lexer^.Current^ = ']' THEN + IF lexer^.current^ = ']' THEN token^.kind := lexerKindRightSquare END; - IF lexer^.Current^ = '^' THEN + IF lexer^.current^ = '^' THEN token^.kind := lexerKindHat END; - IF lexer^.Current^ = '=' THEN + IF lexer^.current^ = '=' THEN token^.kind := lexerKindEqual END; - IF lexer^.Current^ = '+' THEN + IF lexer^.current^ = '+' THEN token^.kind := lexerKindPlus END; - IF lexer^.Current^ = '/' THEN + IF lexer^.current^ = '/' THEN token^.kind := lexerKindDivision END; - IF lexer^.Current^ = '%' THEN + IF lexer^.current^ = '%' THEN token^.kind := lexerKindRemainder END; - IF lexer^.Current^ = '@' THEN + IF lexer^.current^ = '@' THEN token^.kind := lexerKindAt END; - IF lexer^.Current^ = '|' THEN + IF lexer^.current^ = '|' THEN token^.kind := lexerKindPipe END; - INC(lexer^.Current) + INC(lexer^.current) END transition_action_single; (* Handle an integer literal. *) PROCEDURE transition_action_integer(lexer: PLexer; token: PLexerToken); @@ -473,43 +481,43 @@ VAR BEGIN token^.kind := lexerKindInteger; - integer_length := lexer^.Current - lexer^.Start; + integer_length := lexer^.current - lexer^.start; 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])); token^.integerKind := StringToInteger(buffer, 10, found); buffer := KillString(buffer) END transition_action_integer; -PROCEDURE set_default_transition(CurrentState: TransitionState; DefaultAction: TransitionAction; NextState: TransitionState); +PROCEDURE set_default_transition(current_state: TransitionState; DefaultAction: TransitionAction; next_state: TransitionState); VAR - DefaultTransition: Transition; + default_transition: Transition; BEGIN - DefaultTransition.Action := DefaultAction; - DefaultTransition.NextState := NextState; + default_transition.action := DefaultAction; + default_transition.next_state := next_state; - transitions[ORD(CurrentState) + 1][ORD(transitionClassInvalid) + 1] := DefaultTransition; - transitions[ORD(CurrentState) + 1][ORD(transitionClassDigit) + 1] := DefaultTransition; - transitions[ORD(CurrentState) + 1][ORD(transitionClassAlpha) + 1] := DefaultTransition; - transitions[ORD(CurrentState) + 1][ORD(transitionClassSpace) + 1] := DefaultTransition; - transitions[ORD(CurrentState) + 1][ORD(transitionClassColon) + 1] := DefaultTransition; - transitions[ORD(CurrentState) + 1][ORD(transitionClassEquals) + 1] := DefaultTransition; - transitions[ORD(CurrentState) + 1][ORD(transitionClassLeftParen) + 1] := DefaultTransition; - transitions[ORD(CurrentState) + 1][ORD(transitionClassRightParen) + 1] := DefaultTransition; - transitions[ORD(CurrentState) + 1][ORD(transitionClassAsterisk) + 1] := DefaultTransition; - transitions[ORD(CurrentState) + 1][ORD(transitionClassUnderscore) + 1] := DefaultTransition; - transitions[ORD(CurrentState) + 1][ORD(transitionClassSingle) + 1] := DefaultTransition; - transitions[ORD(CurrentState) + 1][ORD(transitionClassHex) + 1] := DefaultTransition; - transitions[ORD(CurrentState) + 1][ORD(transitionClassZero) + 1] := DefaultTransition; - transitions[ORD(CurrentState) + 1][ORD(transitionClassX) + 1] := DefaultTransition; - transitions[ORD(CurrentState) + 1][ORD(transitionClassEof) + 1] := DefaultTransition; - transitions[ORD(CurrentState) + 1][ORD(transitionClassDot) + 1] := DefaultTransition; - transitions[ORD(CurrentState) + 1][ORD(transitionClassMinus) + 1] := DefaultTransition; - transitions[ORD(CurrentState) + 1][ORD(transitionClassSingleQuote) + 1] := DefaultTransition; - transitions[ORD(CurrentState) + 1][ORD(transitionClassDoubleQuote) + 1] := DefaultTransition; - transitions[ORD(CurrentState) + 1][ORD(transitionClassGreater) + 1] := DefaultTransition; - transitions[ORD(CurrentState) + 1][ORD(transitionClassLess) + 1] := DefaultTransition; - transitions[ORD(CurrentState) + 1][ORD(transitionClassOther) + 1] := DefaultTransition + transitions[ORD(current_state) + 1][ORD(transitionClassInvalid) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(transitionClassDigit) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(transitionClassAlpha) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(transitionClassSpace) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(transitionClassColon) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(transitionClassEquals) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(transitionClassLeftParen) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(transitionClassRightParen) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(transitionClassAsterisk) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(transitionClassUnderscore) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(transitionClassSingle) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(transitionClassHex) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(transitionClassZero) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(transitionClassX) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(transitionClassEof) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(transitionClassDot) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(transitionClassMinus) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(transitionClassSingleQuote) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(transitionClassDoubleQuote) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(transitionClassGreater) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(transitionClassLess) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(transitionClassOther) + 1] := default_transition END set_default_transition; (* * The transition table describes transitions from one state to another, given @@ -530,267 +538,267 @@ END set_default_transition; PROCEDURE initialize_transitions(); BEGIN (* Start state. *) - 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].action := NIL; + 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].NextState := transitionStateDecimal; + transitions[ORD(transitionStateStart) + 1][ORD(transitionClassDigit) + 1].action := transition_action_accumulate; + 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].NextState := transitionStateIdentifier; + transitions[ORD(transitionStateStart) + 1][ORD(transitionClassAlpha) + 1].action := transition_action_accumulate; + 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].NextState := transitionStateStart; + transitions[ORD(transitionStateStart) + 1][ORD(transitionClassSpace) + 1].action := transition_action_skip; + 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].NextState := transitionStateColon; + transitions[ORD(transitionStateStart) + 1][ORD(transitionClassColon) + 1].action := transition_action_accumulate; + 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].NextState := transitionStateEnd; + transitions[ORD(transitionStateStart) + 1][ORD(transitionClassEquals) + 1].action := transition_action_single; + 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].NextState := transitionStateLeftParen; + transitions[ORD(transitionStateStart) + 1][ORD(transitionClassLeftParen) + 1].action := transition_action_accumulate; + 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].NextState := transitionStateEnd; + transitions[ORD(transitionStateStart) + 1][ORD(transitionClassRightParen) + 1].action := transition_action_single; + 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].NextState := transitionStateEnd; + transitions[ORD(transitionStateStart) + 1][ORD(transitionClassAsterisk) + 1].action := transition_action_single; + 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].NextState := transitionStateIdentifier; + transitions[ORD(transitionStateStart) + 1][ORD(transitionClassUnderscore) + 1].action := transition_action_accumulate; + 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].NextState := transitionStateEnd; + transitions[ORD(transitionStateStart) + 1][ORD(transitionClassSingle) + 1].action := transition_action_single; + 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].NextState := transitionStateIdentifier; + transitions[ORD(transitionStateStart) + 1][ORD(transitionClassHex) + 1].action := transition_action_accumulate; + 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].NextState := transitionStateLeadingZero; + transitions[ORD(transitionStateStart) + 1][ORD(transitionClassZero) + 1].action := transition_action_accumulate; + 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].NextState := transitionStateIdentifier; + transitions[ORD(transitionStateStart) + 1][ORD(transitionClassX) + 1].action := transition_action_accumulate; + 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].NextState := transitionStateEnd; + transitions[ORD(transitionStateStart) + 1][ORD(transitionClassEof) + 1].action := transition_action_eof; + 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].NextState := transitionStateDot; + transitions[ORD(transitionStateStart) + 1][ORD(transitionClassDot) + 1].action := transition_action_accumulate; + 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].NextState := transitionStateMinus; + transitions[ORD(transitionStateStart) + 1][ORD(transitionClassMinus) + 1].action := transition_action_accumulate; + 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].NextState := transitionStateCharacter; + transitions[ORD(transitionStateStart) + 1][ORD(transitionClassSingleQuote) + 1].action := transition_action_accumulate; + 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].NextState := transitionStateString; + transitions[ORD(transitionStateStart) + 1][ORD(transitionClassDoubleQuote) + 1].action := transition_action_accumulate; + 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].NextState := transitionStateGreater; + transitions[ORD(transitionStateStart) + 1][ORD(transitionClassGreater) + 1].action := transition_action_accumulate; + 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].NextState := transitionStateLess; + transitions[ORD(transitionStateStart) + 1][ORD(transitionClassLess) + 1].action := transition_action_accumulate; + 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].NextState := transitionStateEnd; + transitions[ORD(transitionStateStart) + 1][ORD(transitionClassOther) + 1].action := NIL; + transitions[ORD(transitionStateStart) + 1][ORD(transitionClassOther) + 1].next_state := transitionStateEnd; (* Colon state. *) 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].NextState := transitionStateEnd; + transitions[ORD(transitionStateColon) + 1][ORD(transitionClassEquals) + 1].action := transition_action_composite; + transitions[ORD(transitionStateColon) + 1][ORD(transitionClassEquals) + 1].next_state := transitionStateEnd; (* Identifier state. *) 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].NextState := transitionStateIdentifier; + transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassDigit) + 1].action := transition_action_accumulate; + 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].NextState := transitionStateIdentifier; + transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassAlpha) + 1].action := transition_action_accumulate; + 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].NextState := transitionStateIdentifier; + transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassUnderscore) + 1].action := transition_action_accumulate; + 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].NextState := transitionStateIdentifier; + transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassHex) + 1].action := transition_action_accumulate; + 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].NextState := transitionStateIdentifier; + transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassZero) + 1].action := transition_action_accumulate; + 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].NextState := transitionStateIdentifier; + transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassX) + 1].action := transition_action_accumulate; + transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassX) + 1].next_state := transitionStateIdentifier; (* Decimal state. *) 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].NextState := transitionStateDecimal; + transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassDigit) + 1].action := transition_action_accumulate; + 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].NextState := transitionStateDecimalSuffix; + transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassAlpha) + 1].action := transition_action_accumulate; + 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].NextState := transitionStateEnd; + transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassUnderscore) + 1].action := NIL; + 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].NextState := transitionStateDecimalSuffix; + transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassHex) + 1].action := transition_action_accumulate; + 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].NextState := transitionStateDecimal; + transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassZero) + 1].action := transition_action_accumulate; + 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].NextState := transitionStateDecimalSuffix; + transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassX) + 1].action := transition_action_accumulate; + transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassX) + 1].next_state := transitionStateDecimalSuffix; (* Greater state. *) 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].NextState := transitionStateEnd; + transitions[ORD(transitionStateGreater) + 1][ORD(transitionClassEquals) + 1].action := transition_action_composite; + transitions[ORD(transitionStateGreater) + 1][ORD(transitionClassEquals) + 1].next_state := transitionStateEnd; (* Minus state. *) 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].NextState := transitionStateEnd; + transitions[ORD(transitionStateMinus) + 1][ORD(transitionClassGreater) + 1].action := transition_action_composite; + transitions[ORD(transitionStateMinus) + 1][ORD(transitionClassGreater) + 1].next_state := transitionStateEnd; (* Left paren state. *) 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].NextState := transitionStateComment; + transitions[ORD(transitionStateLeftParen) + 1][ORD(transitionClassAsterisk) + 1].action := transition_action_accumulate; + transitions[ORD(transitionStateLeftParen) + 1][ORD(transitionClassAsterisk) + 1].next_state := transitionStateComment; (* Less state. *) 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].NextState := transitionStateEnd; + transitions[ORD(transitionStateLess) + 1][ORD(transitionClassEquals) + 1].action := transition_action_composite; + 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].NextState := transitionStateEnd; + transitions[ORD(transitionStateLess) + 1][ORD(transitionClassGreater) + 1].action := transition_action_composite; + transitions[ORD(transitionStateLess) + 1][ORD(transitionClassGreater) + 1].next_state := transitionStateEnd; (* Hexadecimal after 0x. *) 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].NextState := transitionStateEnd; + transitions[ORD(transitionStateDot) + 1][ORD(transitionClassDot) + 1].action := transition_action_composite; + transitions[ORD(transitionStateDot) + 1][ORD(transitionClassDot) + 1].next_state := transitionStateEnd; (* Comment. *) 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].NextState := transitionStateClosingComment; + transitions[ORD(transitionStateComment) + 1][ORD(transitionClassAsterisk) + 1].action := transition_action_accumulate; + 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].NextState := transitionStateEnd; + transitions[ORD(transitionStateComment) + 1][ORD(transitionClassEof) + 1].action := NIL; + transitions[ORD(transitionStateComment) + 1][ORD(transitionClassEof) + 1].next_state := transitionStateEnd; (* Closing comment. *) set_default_transition(transitionStateClosingComment, transition_action_accumulate, transitionStateComment); - 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].action := NIL; + 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].NextState := transitionStateEnd; + transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassRightParen) + 1].action := transition_action_delimited; + 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].NextState := transitionStateClosingComment; + transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassAsterisk) + 1].action := transition_action_accumulate; + 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].NextState := transitionStateEnd; + transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassEof) + 1].action := NIL; + transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassEof) + 1].next_state := transitionStateEnd; (* Character. *) set_default_transition(transitionStateCharacter, transition_action_accumulate, transitionStateCharacter); - 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].action := NIL; + 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].NextState := transitionStateEnd; + transitions[ORD(transitionStateCharacter) + 1][ORD(transitionClassEof) + 1].action := NIL; + 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].NextState := transitionStateEnd; + transitions[ORD(transitionStateCharacter) + 1][ORD(transitionClassSingleQuote) + 1].action := transition_action_delimited; + transitions[ORD(transitionStateCharacter) + 1][ORD(transitionClassSingleQuote) + 1].next_state := transitionStateEnd; (* String. *) set_default_transition(transitionStateString, transition_action_accumulate, transitionStateString); - 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].action := NIL; + 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].NextState := transitionStateEnd; + transitions[ORD(transitionStateString) + 1][ORD(transitionClassEof) + 1].action := NIL; + 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].NextState := transitionStateEnd; + transitions[ORD(transitionStateString) + 1][ORD(transitionClassDoubleQuote) + 1].action := transition_action_delimited; + transitions[ORD(transitionStateString) + 1][ORD(transitionClassDoubleQuote) + 1].next_state := transitionStateEnd; (* Leading zero. *) set_default_transition(transitionStateLeadingZero, transition_action_integer, transitionStateEnd); - 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].action := NIL; + 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].NextState := transitionStateEnd; + transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassAlpha) + 1].action := NIL; + 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].NextState := transitionStateEnd; + transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassUnderscore) + 1].action := NIL; + 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].NextState := transitionStateEnd; + transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassHex) + 1].action := NIL; + 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].NextState := transitionStateEnd; + transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassZero) + 1].action := NIL; + 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].NextState := transitionStateEnd; + transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassX) + 1].action := NIL; + transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassX) + 1].next_state := transitionStateEnd; (* Digit with a character suffix. *) set_default_transition(transitionStateDecimalSuffix, transition_action_integer, transitionStateEnd); - 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].action := NIL; + 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].NextState := transitionStateEnd; + transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassDigit) + 1].action := NIL; + 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].NextState := transitionStateEnd; + transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassHex) + 1].action := NIL; + 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].NextState := transitionStateEnd; + transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassZero) + 1].action := NIL; + 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].NextState := transitionStateEnd + transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassX) + 1].action := NIL; + transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassX) + 1].next_state := transitionStateEnd END initialize_transitions; -PROCEDURE lexer_initialize(lexer: PLexer; Input: File); +PROCEDURE lexer_initialize(lexer: PLexer; input: File); BEGIN - lexer^.Input := Input; - lexer^.Length := 0; + lexer^.input := input; + lexer^.length := 0; - ALLOCATE(lexer^.Buffer, CHUNK_SIZE); - MemZero(lexer^.Buffer, CHUNK_SIZE); - lexer^.Size := CHUNK_SIZE + ALLOCATE(lexer^.buffer, CHUNK_SIZE); + MemZero(lexer^.buffer, CHUNK_SIZE); + lexer^.size := CHUNK_SIZE END lexer_initialize; PROCEDURE lexer_current(lexer: PLexer): LexerToken; VAR - CurrentClass: TransitionClass; - CurrentState: TransitionState; - CurrentTransition: Transition; + current_class: TransitionClass; + current_state: TransitionState; + current_transition: Transition; result: LexerToken; BEGIN - lexer^.Current := lexer^.Start; - CurrentState := transitionStateStart; + lexer^.current := lexer^.start; + current_state := transitionStateStart; - WHILE CurrentState <> transitionStateEnd DO - CurrentClass := classification[ORD(lexer^.Current^) + 1]; + WHILE current_state <> transitionStateEnd DO + current_class := classification[ORD(lexer^.current^) + 1]; - CurrentTransition := transitions[ORD(CurrentState) + 1][ORD(CurrentClass) + 1]; - IF CurrentTransition.Action <> NIL THEN - CurrentTransition.Action(lexer, ADR(result)) + current_transition := transitions[ORD(current_state) + 1][ORD(current_class) + 1]; + IF current_transition.action <> NIL THEN + current_transition.action(lexer, ADR(result)) END; - CurrentState := CurrentTransition.NextState + current_state := current_transition.next_state END; RETURN result END lexer_current; @@ -798,18 +806,18 @@ PROCEDURE lexer_lex(lexer: PLexer): LexerToken; VAR result: LexerToken; BEGIN - IF lexer^.Length = 0 THEN - lexer^.Length := ReadNBytes(lexer^.Input, CHUNK_SIZE, lexer^.Buffer); - lexer^.Current := lexer^.Buffer + IF lexer^.length = 0 THEN + lexer^.length := ReadNBytes(lexer^.input, CHUNK_SIZE, lexer^.buffer); + lexer^.current := lexer^.buffer END; - lexer^.Start := lexer^.Current; + lexer^.start := lexer^.current; result := lexer_current(lexer); RETURN result END lexer_lex; PROCEDURE lexer_destroy(lexer: PLexer); BEGIN - DEALLOCATE(lexer^.Buffer, lexer^.Size) + DEALLOCATE(lexer^.buffer, lexer^.size) END lexer_destroy; BEGIN initialize_classification(); diff --git a/source/Parser.def b/source/Parser.def index 65e58cd..a763bcb 100644 --- a/source/Parser.def +++ b/source/Parser.def @@ -7,21 +7,42 @@ TYPE AstLiteralKind = ( astLiteralKindInteger, astLiteralKindString, - astLiteralKindNull + astLiteralKindNull, + astLiteralKindBoolean ); AstLiteral = RECORD CASE kind: AstLiteralKind OF astLiteralKindInteger: integer: INTEGER | astLiteralKindString: string: ShortString | - astLiteralKindNull: + astLiteralKindNull: | + astLiteralKindBoolean: boolean: BOOLEAN END END; PAstLiteral = POINTER TO AstLiteral; AstUnaryOperator = ( + astUnaryOperatorReference, astUnaryOperatorNot, astUnaryOperatorMinus ); + AstBinaryOperator = ( + astBinaryOperatorSum, + astBinaryOperatorSubtraction, + astBinaryOperatorMultiplication, + astBinaryOperatorDivision, + astBinaryOperatorRemainder, + astBinaryOperatorEquals, + astBinaryOperatorNotEquals, + astBinaryOperatorLess, + astBinaryOperatorGreater, + astBinaryOperatorLessEqual, + astBinaryOperatorGreaterEqual, + astBinaryOperatorDisjunction, + astBinaryOperatorConjunction, + astBinaryOperatorExclusiveDisjunction, + astBinaryOperatorShiftLeft, + astBinaryOperatorShiftRight + ); AstExpressionKind = ( astExpressionKindLiteral, @@ -29,7 +50,9 @@ TYPE astExpressionKindArrayAccess, astExpressionKindDereference, astExpressionKindFieldAccess, - astExpressionKindUnary + astExpressionKindUnary, + astExpressionKindBinary, + astExpressionKindCall ); AstExpression = RECORD CASE kind: AstExpressionKind OF @@ -44,7 +67,15 @@ TYPE field: Identifier | astExpressionKindUnary: 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; PAstExpression = POINTER TO AstExpression; @@ -121,5 +152,6 @@ PROCEDURE parse_variable_part(lexer: PLexer): PPAstVariableDeclaration; PROCEDURE parse_constant_part(lexer: PLexer): PPAstConstantDeclaration; PROCEDURE parse_import_part(lexer: PLexer): PPAstImportStatement; PROCEDURE parse_designator(lexer: PLexer): PAstExpression; +PROCEDURE parse_expression(lexer: PLexer): PAstExpression; END Parser. diff --git a/source/Parser.mod b/source/Parser.mod index 22c5f3b..cf34695 100644 --- a/source/Parser.mod +++ b/source/Parser.mod @@ -5,7 +5,7 @@ FROM SYSTEM IMPORT TSIZE; FROM MemUtils IMPORT MemZero; 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. *) PROCEDURE transpiler_lex(lexer: PLexer): LexerToken; @@ -459,7 +459,7 @@ BEGIN literal^.kind := astLiteralKindInteger; literal^.integer := token.integerKind; END; - IF token.kind = lexerKindCharacter THEN + IF (token.kind = lexerKindCharacter) OR (token.kind = lexerKindString) THEN NEW(literal); literal^.kind := astLiteralKindString; @@ -470,6 +470,12 @@ BEGIN literal^.kind := astLiteralKindNull; END; + IF token.kind = lexerKindBoolean THEN + NEW(literal); + + literal^.kind := astLiteralKindBoolean; + literal^.boolean := token.booleanKind + END; IF literal <> NIL THEN token := transpiler_lex(lexer) END; @@ -525,6 +531,7 @@ VAR next_token: LexerToken; inner_expression: PAstExpression; designator: PAstExpression; + arguments: PPAstExpression; handled: BOOLEAN; BEGIN designator := parse_factor(lexer); @@ -563,6 +570,38 @@ BEGIN designator^.aggregate := inner_expression; designator^.field := next_token.identifierKind; + next_token := transpiler_lex(lexer); + handled := TRUE + END; + IF ~handled AND (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); handled := TRUE END @@ -570,4 +609,67 @@ BEGIN RETURN designator END parse_designator; +PROCEDURE 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 parse_binary_expression; +PROCEDURE 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) AND (result = NIL) AND (next_token.kind = lexerKindNotEqual) THEN + result := parse_binary_expression(lexer, left, astBinaryOperatorNotEquals) + END; + IF (left <> NIL) AND (result = NIL) AND (next_token.kind = lexerKindEqual) THEN + result := parse_binary_expression(lexer, left, astBinaryOperatorEquals) + END; + IF (left <> NIL) AND (result = NIL) AND (next_token.kind = lexerKindGreaterThan) THEN + result := parse_binary_expression(lexer, left, astBinaryOperatorGreater) + END; + IF (left <> NIL) AND (result = NIL) AND (next_token.kind = lexerKindLessThan) THEN + result := parse_binary_expression(lexer, left, astBinaryOperatorLess) + END; + IF (left <> NIL) AND (result = NIL) AND (next_token.kind = lexerKindGreaterEqual) THEN + result := parse_binary_expression(lexer, left, astBinaryOperatorGreaterEqual) + END; + IF (left <> NIL) AND (result = NIL) AND (next_token.kind = lexerKindLessEqual) THEN + result := parse_binary_expression(lexer, left, astBinaryOperatorLessEqual) + END; + IF (left <> NIL) AND (result = NIL) AND (next_token.kind = lexerKindAnd) THEN + result := parse_binary_expression(lexer, left, astBinaryOperatorConjunction) + END; + IF (left <> NIL) AND (result = NIL) AND (next_token.kind = lexerKindOr) THEN + result := parse_binary_expression(lexer, left, astBinaryOperatorDisjunction) + END; + IF (result = NIL) AND (left <> NIL) THEN + result := left; + lexer^ := saved + END; + + RETURN result +END parse_expression; END Parser. diff --git a/source/Transpiler.mod b/source/Transpiler.mod index f81fdc0..68ba2ea 100644 --- a/source/Transpiler.mod +++ b/source/Transpiler.mod @@ -9,14 +9,14 @@ FROM MemUtils IMPORT MemCopy, MemZero; FROM Common IMPORT Identifier, PIdentifier, ShortString; FROM Lexer IMPORT Lexer, LexerToken, lexer_current, lexer_lex, LexerKind; -FROM Parser IMPORT AstTypeExpressionKind, AstExpressionKind, AstLiteralKind, AstUnaryOperator, - AstModule, PAstModule, AstExpression, PAstExpression, PAstLiteral, +FROM Parser IMPORT AstTypeExpressionKind, AstExpressionKind, AstLiteralKind, AstUnaryOperator, AstBinaryOperator, + AstModule, PAstModule, AstExpression, PPAstExpression, PAstExpression, PAstLiteral, PAstConstantDeclaration, PPAstConstantDeclaration, AstTypeDeclaration, PAstTypeDeclaration, PPAstTypeDeclaration, PAstVariableDeclaration, PPAstVariableDeclaration, PAstImportStatement, PPAstImportStatement, PAstTypeExpression, PPAstTypeExpression, AstFieldDeclaration, PAstFieldDeclaration, 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. *) PROCEDURE transpiler_lex(lexer: PLexer): LexerToken; @@ -41,7 +41,7 @@ PROCEDURE write_current(lexer: PLexer; output: File); VAR written_bytes: CARDINAL; BEGIN - written_bytes := WriteNBytes(output, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start) + written_bytes := WriteNBytes(output, ADDRESS(lexer^.current - lexer^.start), lexer^.start) END write_current; PROCEDURE transpile_import_statement(context: PTranspilerContext; import_statement: PAstImportStatement); VAR @@ -425,19 +425,6 @@ BEGIN token := transpiler_lex(context^.lexer) END END transpile_unchanged; -PROCEDURE 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 parse_expression; PROCEDURE transpile_unary_operator(context: PTranspilerContext; operator: AstUnaryOperator); BEGIN IF operator = astUnaryOperatorMinus THEN @@ -447,11 +434,49 @@ BEGIN WriteChar(context^.output, '~') END END transpile_unary_operator; +PROCEDURE 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 transpile_binary_operator; PROCEDURE transpile_expression(context: PTranspilerContext; expression: PAstExpression); VAR literal: PAstLiteral; buffer: ARRAY[1..20] OF CHAR; written_bytes: CARDINAL; + argument_index: CARDINAL; + current_argument: PPAstExpression; BEGIN IF expression^.kind = astExpressionKindLiteral THEN literal := expression^.literal; @@ -462,7 +487,16 @@ BEGIN END; IF literal^.kind = astLiteralKindString THEN WriteString(context^.output, literal^.string) - END + END; + IF literal^.kind = astLiteralKindNull THEN + WriteString(context^.output, 'NIL') + END; + IF (literal^.kind = astLiteralKindBoolean) AND literal^.boolean THEN + WriteString(context^.output, 'TRUE') + END; + IF (literal^.kind = astLiteralKindBoolean) AND (literal^.boolean = FALSE) THEN + WriteString(context^.output, 'FALSE') + END END; IF expression^.kind = astExpressionKindIdentifier THEN written_bytes := WriteNBytes(context^.output, ORD(expression^.identifier[1]), ADR(expression^.identifier[2])) @@ -485,6 +519,35 @@ BEGIN IF expression^.kind = astExpressionKindUnary THEN transpile_unary_operator(context, expression^.unary_operator); 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 transpile_expression; PROCEDURE transpile_if_statement(context: PTranspilerContext); @@ -492,11 +555,12 @@ VAR token: LexerToken; expression: PAstExpression; lexer: Lexer; + written_bytes: CARDINAL; BEGIN WriteString(context^.output, ' IF '); + token := transpiler_lex(context^.lexer); lexer := context^.lexer^; - token := transpiler_lex(ADR(lexer)); expression := parse_expression(ADR(lexer)); IF expression <> NIL THEN @@ -504,8 +568,10 @@ BEGIN transpile_expression(context, expression); WriteChar(context^.output, ' ') END; - IF expression = NIL THEN - token := transpiler_lex(context^.lexer) + token := lexer_current(context^.lexer); + IF token.kind <> lexerKindThen THEN + written_bytes := WriteNBytes(StdErr, 10, context^.lexer^.start); + WriteLine(StdErr) END; transpile_unchanged(context, lexerKindThen);