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

Shorten the array syntax

Browse Source
This commit is contained in:
Eugen Wissner
2025-05-30 12:56:11 +02:00
parent 273e26b119
commit 35d2b5ef2b
3 changed files with 544 additions and 545 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
source/Compiler.mod
View File

@ -7,12 +7,12 @@ FROM Lexer IMPORT Lexer, lexer_destroy, lexer_initialize;
FROM Transpiler IMPORT transpile;
VAR
ALexer: Lexer;
lexer: Lexer;
BEGIN
lexer_initialize(ADR(ALexer), StdIn);
lexer_initialize(ADR(lexer), StdIn);
transpile(ADR(ALexer));
transpile(ADR(lexer));
lexer_destroy(ADR(ALexer))
lexer_destroy(ADR(lexer))
END Compiler.

599
source/Lexer.mod
View File

@ -9,7 +9,7 @@ FROM MemUtils IMPORT MemCopy, MemZero;
FROM StrCase IMPORT Lower;
CONST
ChunkSize = 65536;
CHUNK_SIZE = 65536;
TYPE
(*
@ -65,143 +65,144 @@ TYPE
Action: TransitionAction;
NextState: TransitionState
END;
TransitionClasses = ARRAY[1..22] OF Transition;
VAR
Classification: ARRAY[1..128] OF TransitionClass;
Transitions: ARRAY[0..15] OF ARRAY[0..21] OF Transition;
classification: ARRAY[1..128] OF TransitionClass;
transitions: ARRAY[1..16] OF TransitionClasses;
PROCEDURE initialize_classification();
BEGIN
Classification[1] := transitionClassEof; (* NUL *)
Classification[2] := transitionClassInvalid; (* SOH *)
Classification[3] := transitionClassInvalid; (* STX *)
Classification[4] := transitionClassInvalid; (* ETX *)
Classification[5] := transitionClassInvalid; (* EOT *)
Classification[6] := transitionClassInvalid; (* EMQ *)
Classification[7] := transitionClassInvalid; (* ACK *)
Classification[8] := transitionClassInvalid; (* BEL *)
Classification[9] := transitionClassInvalid; (* BS *)
Classification[10] := transitionClassSpace; (* HT *)
Classification[11] := transitionClassSpace; (* LF *)
Classification[12] := transitionClassInvalid; (* VT *)
Classification[13] := transitionClassInvalid; (* FF *)
Classification[14] := transitionClassSpace; (* CR *)
Classification[15] := transitionClassInvalid; (* SO *)
Classification[16] := transitionClassInvalid; (* SI *)
Classification[17] := transitionClassInvalid; (* DLE *)
Classification[18] := transitionClassInvalid; (* DC1 *)
Classification[19] := transitionClassInvalid; (* DC2 *)
Classification[20] := transitionClassInvalid; (* DC3 *)
Classification[21] := transitionClassInvalid; (* DC4 *)
Classification[22] := transitionClassInvalid; (* NAK *)
Classification[23] := transitionClassInvalid; (* SYN *)
Classification[24] := transitionClassInvalid; (* ETB *)
Classification[25] := transitionClassInvalid; (* CAN *)
Classification[26] := transitionClassInvalid; (* EM *)
Classification[27] := transitionClassInvalid; (* SUB *)
Classification[28] := transitionClassInvalid; (* ESC *)
Classification[29] := transitionClassInvalid; (* FS *)
Classification[30] := transitionClassInvalid; (* GS *)
Classification[31] := transitionClassInvalid; (* RS *)
Classification[32] := transitionClassInvalid; (* US *)
Classification[33] := transitionClassSpace; (* Space *)
Classification[34] := transitionClassSingle; (* ! *)
Classification[35] := transitionClassDoubleQuote; (* " *)
Classification[36] := transitionClassOther; (* # *)
Classification[37] := transitionClassOther; (* $ *)
Classification[38] := transitionClassSingle; (* % *)
Classification[39] := transitionClassSingle; (* & *)
Classification[40] := transitionClassSingleQuote; (* ' *)
Classification[41] := transitionClassLeftParen; (* ( *)
Classification[42] := transitionClassRightParen; (* ) *)
Classification[43] := transitionClassAsterisk; (* * *)
Classification[44] := transitionClassSingle; (* + *)
Classification[45] := transitionClassSingle; (* , *)
Classification[46] := transitionClassMinus; (* - *)
Classification[47] := transitionClassDot; (* . *)
Classification[48] := transitionClassSingle; (* / *)
Classification[49] := transitionClassZero; (* 0 *)
Classification[50] := transitionClassDigit; (* 1 *)
Classification[51] := transitionClassDigit; (* 2 *)
Classification[52] := transitionClassDigit; (* 3 *)
Classification[53] := transitionClassDigit; (* 4 *)
Classification[54] := transitionClassDigit; (* 5 *)
Classification[55] := transitionClassDigit; (* 6 *)
Classification[56] := transitionClassDigit; (* 7 *)
Classification[57] := transitionClassDigit; (* 8 *)
Classification[58] := transitionClassDigit; (* 9 *)
Classification[59] := transitionClassColon; (* : *)
Classification[60] := transitionClassSingle; (* ; *)
Classification[61] := transitionClassLess; (* < *)
Classification[62] := transitionClassEquals; (* = *)
Classification[63] := transitionClassGreater; (* > *)
Classification[64] := transitionClassOther; (* ? *)
Classification[65] := transitionClassSingle; (* @ *)
Classification[66] := transitionClassAlpha; (* A *)
Classification[67] := transitionClassAlpha; (* B *)
Classification[68] := transitionClassAlpha; (* C *)
Classification[69] := transitionClassAlpha; (* D *)
Classification[70] := transitionClassAlpha; (* E *)
Classification[71] := transitionClassAlpha; (* F *)
Classification[72] := transitionClassAlpha; (* G *)
Classification[73] := transitionClassAlpha; (* H *)
Classification[74] := transitionClassAlpha; (* I *)
Classification[75] := transitionClassAlpha; (* J *)
Classification[76] := transitionClassAlpha; (* K *)
Classification[77] := transitionClassAlpha; (* L *)
Classification[78] := transitionClassAlpha; (* M *)
Classification[79] := transitionClassAlpha; (* N *)
Classification[80] := transitionClassAlpha; (* O *)
Classification[81] := transitionClassAlpha; (* P *)
Classification[82] := transitionClassAlpha; (* Q *)
Classification[83] := transitionClassAlpha; (* R *)
Classification[84] := transitionClassAlpha; (* S *)
Classification[85] := transitionClassAlpha; (* T *)
Classification[86] := transitionClassAlpha; (* U *)
Classification[87] := transitionClassAlpha; (* V *)
Classification[88] := transitionClassAlpha; (* W *)
Classification[89] := transitionClassAlpha; (* X *)
Classification[90] := transitionClassAlpha; (* Y *)
Classification[91] := transitionClassAlpha; (* Z *)
Classification[92] := transitionClassSingle; (* [ *)
Classification[93] := transitionClassOther; (* \ *)
Classification[94] := transitionClassSingle; (* ] *)
Classification[95] := transitionClassSingle; (* ^ *)
Classification[96] := transitionClassUnderscore; (* _ *)
Classification[97] := transitionClassOther; (* ` *)
Classification[98] := transitionClassHex; (* a *)
Classification[99] := transitionClassHex; (* b *)
Classification[100] := transitionClassHex; (* c *)
Classification[101] := transitionClassHex; (* d *)
Classification[102] := transitionClassHex; (* e *)
Classification[103] := transitionClassHex; (* f *)
Classification[104] := transitionClassAlpha; (* g *)
Classification[105] := transitionClassAlpha; (* h *)
Classification[106] := transitionClassAlpha; (* i *)
Classification[107] := transitionClassAlpha; (* j *)
Classification[108] := transitionClassAlpha; (* k *)
Classification[109] := transitionClassAlpha; (* l *)
Classification[110] := transitionClassAlpha; (* m *)
Classification[111] := transitionClassAlpha; (* n *)
Classification[112] := transitionClassAlpha; (* o *)
Classification[113] := transitionClassAlpha; (* p *)
Classification[114] := transitionClassAlpha; (* q *)
Classification[115] := transitionClassAlpha; (* r *)
Classification[116] := transitionClassAlpha; (* s *)
Classification[117] := transitionClassAlpha; (* t *)
Classification[118] := transitionClassAlpha; (* u *)
Classification[119] := transitionClassAlpha; (* v *)
Classification[120] := transitionClassAlpha; (* w *)
Classification[121] := transitionClassX; (* x *)
Classification[122] := transitionClassAlpha; (* y *)
Classification[123] := transitionClassAlpha; (* z *)
Classification[124] := transitionClassOther; (* { *)
Classification[125] := transitionClassSingle; (* | *)
Classification[126] := transitionClassOther; (* } *)
Classification[127] := transitionClassSingle; (* ~ *)
Classification[128] := transitionClassInvalid (* DEL *)
classification[1] := transitionClassEof; (* NUL *)
classification[2] := transitionClassInvalid; (* SOH *)
classification[3] := transitionClassInvalid; (* STX *)
classification[4] := transitionClassInvalid; (* ETX *)
classification[5] := transitionClassInvalid; (* EOT *)
classification[6] := transitionClassInvalid; (* EMQ *)
classification[7] := transitionClassInvalid; (* ACK *)
classification[8] := transitionClassInvalid; (* BEL *)
classification[9] := transitionClassInvalid; (* BS *)
classification[10] := transitionClassSpace; (* HT *)
classification[11] := transitionClassSpace; (* LF *)
classification[12] := transitionClassInvalid; (* VT *)
classification[13] := transitionClassInvalid; (* FF *)
classification[14] := transitionClassSpace; (* CR *)
classification[15] := transitionClassInvalid; (* SO *)
classification[16] := transitionClassInvalid; (* SI *)
classification[17] := transitionClassInvalid; (* DLE *)
classification[18] := transitionClassInvalid; (* DC1 *)
classification[19] := transitionClassInvalid; (* DC2 *)
classification[20] := transitionClassInvalid; (* DC3 *)
classification[21] := transitionClassInvalid; (* DC4 *)
classification[22] := transitionClassInvalid; (* NAK *)
classification[23] := transitionClassInvalid; (* SYN *)
classification[24] := transitionClassInvalid; (* ETB *)
classification[25] := transitionClassInvalid; (* CAN *)
classification[26] := transitionClassInvalid; (* EM *)
classification[27] := transitionClassInvalid; (* SUB *)
classification[28] := transitionClassInvalid; (* ESC *)
classification[29] := transitionClassInvalid; (* FS *)
classification[30] := transitionClassInvalid; (* GS *)
classification[31] := transitionClassInvalid; (* RS *)
classification[32] := transitionClassInvalid; (* US *)
classification[33] := transitionClassSpace; (* Space *)
classification[34] := transitionClassSingle; (* ! *)
classification[35] := transitionClassDoubleQuote; (* " *)
classification[36] := transitionClassOther; (* # *)
classification[37] := transitionClassOther; (* $ *)
classification[38] := transitionClassSingle; (* % *)
classification[39] := transitionClassSingle; (* & *)
classification[40] := transitionClassSingleQuote; (* ' *)
classification[41] := transitionClassLeftParen; (* ( *)
classification[42] := transitionClassRightParen; (* ) *)
classification[43] := transitionClassAsterisk; (* * *)
classification[44] := transitionClassSingle; (* + *)
classification[45] := transitionClassSingle; (* , *)
classification[46] := transitionClassMinus; (* - *)
classification[47] := transitionClassDot; (* . *)
classification[48] := transitionClassSingle; (* / *)
classification[49] := transitionClassZero; (* 0 *)
classification[50] := transitionClassDigit; (* 1 *)
classification[51] := transitionClassDigit; (* 2 *)
classification[52] := transitionClassDigit; (* 3 *)
classification[53] := transitionClassDigit; (* 4 *)
classification[54] := transitionClassDigit; (* 5 *)
classification[55] := transitionClassDigit; (* 6 *)
classification[56] := transitionClassDigit; (* 7 *)
classification[57] := transitionClassDigit; (* 8 *)
classification[58] := transitionClassDigit; (* 9 *)
classification[59] := transitionClassColon; (* : *)
classification[60] := transitionClassSingle; (* ; *)
classification[61] := transitionClassLess; (* < *)
classification[62] := transitionClassEquals; (* = *)
classification[63] := transitionClassGreater; (* > *)
classification[64] := transitionClassOther; (* ? *)
classification[65] := transitionClassSingle; (* @ *)
classification[66] := transitionClassAlpha; (* A *)
classification[67] := transitionClassAlpha; (* B *)
classification[68] := transitionClassAlpha; (* C *)
classification[69] := transitionClassAlpha; (* D *)
classification[70] := transitionClassAlpha; (* E *)
classification[71] := transitionClassAlpha; (* F *)
classification[72] := transitionClassAlpha; (* G *)
classification[73] := transitionClassAlpha; (* H *)
classification[74] := transitionClassAlpha; (* I *)
classification[75] := transitionClassAlpha; (* J *)
classification[76] := transitionClassAlpha; (* K *)
classification[77] := transitionClassAlpha; (* L *)
classification[78] := transitionClassAlpha; (* M *)
classification[79] := transitionClassAlpha; (* N *)
classification[80] := transitionClassAlpha; (* O *)
classification[81] := transitionClassAlpha; (* P *)
classification[82] := transitionClassAlpha; (* Q *)
classification[83] := transitionClassAlpha; (* R *)
classification[84] := transitionClassAlpha; (* S *)
classification[85] := transitionClassAlpha; (* T *)
classification[86] := transitionClassAlpha; (* U *)
classification[87] := transitionClassAlpha; (* V *)
classification[88] := transitionClassAlpha; (* W *)
classification[89] := transitionClassAlpha; (* X *)
classification[90] := transitionClassAlpha; (* Y *)
classification[91] := transitionClassAlpha; (* Z *)
classification[92] := transitionClassSingle; (* [ *)
classification[93] := transitionClassOther; (* \ *)
classification[94] := transitionClassSingle; (* ] *)
classification[95] := transitionClassSingle; (* ^ *)
classification[96] := transitionClassUnderscore; (* _ *)
classification[97] := transitionClassOther; (* ` *)
classification[98] := transitionClassHex; (* a *)
classification[99] := transitionClassHex; (* b *)
classification[100] := transitionClassHex; (* c *)
classification[101] := transitionClassHex; (* d *)
classification[102] := transitionClassHex; (* e *)
classification[103] := transitionClassHex; (* f *)
classification[104] := transitionClassAlpha; (* g *)
classification[105] := transitionClassAlpha; (* h *)
classification[106] := transitionClassAlpha; (* i *)
classification[107] := transitionClassAlpha; (* j *)
classification[108] := transitionClassAlpha; (* k *)
classification[109] := transitionClassAlpha; (* l *)
classification[110] := transitionClassAlpha; (* m *)
classification[111] := transitionClassAlpha; (* n *)
classification[112] := transitionClassAlpha; (* o *)
classification[113] := transitionClassAlpha; (* p *)
classification[114] := transitionClassAlpha; (* q *)
classification[115] := transitionClassAlpha; (* r *)
classification[116] := transitionClassAlpha; (* s *)
classification[117] := transitionClassAlpha; (* t *)
classification[118] := transitionClassAlpha; (* u *)
classification[119] := transitionClassAlpha; (* v *)
classification[120] := transitionClassAlpha; (* w *)
classification[121] := transitionClassX; (* x *)
classification[122] := transitionClassAlpha; (* y *)
classification[123] := transitionClassAlpha; (* z *)
classification[124] := transitionClassOther; (* { *)
classification[125] := transitionClassSingle; (* | *)
classification[126] := transitionClassOther; (* } *)
classification[127] := transitionClassSingle; (* ~ *)
classification[128] := transitionClassInvalid (* DEL *)
END initialize_classification;
PROCEDURE compare_keyword(Keyword: ARRAY OF CHAR; TokenStart: PLexerBuffer; TokenEnd: PLexerBuffer): BOOLEAN;
PROCEDURE compare_keyword(Keyword: ARRAY OF CHAR; TokenStart: PLexerBuffer; TokenEnd: PLexerBuffer): BOOLEAN;
VAR
Result: BOOLEAN;
Index: CARDINAL;
@ -218,18 +219,18 @@ BEGIN
RETURN Result
END compare_keyword;
(* Reached the end of file. *)
PROCEDURE transition_action_eof(ALexer: PLexer; AToken: PLexerToken);
PROCEDURE transition_action_eof(ALexer: PLexer; AToken: PLexerToken);
BEGIN
AToken^.Kind := lexerKindEof
END transition_action_eof;
(* Add the character to the token currently read and advance to the next character. *)
PROCEDURE transition_action_accumulate(ALexer: PLexer; AToken: PLexerToken);
PROCEDURE transition_action_accumulate(ALexer: PLexer; AToken: PLexerToken);
BEGIN
INC(ALexer^.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(ALexer: PLexer; AToken: PLexerToken);
PROCEDURE transition_action_finalize(ALexer: PLexer; AToken: PLexerToken);
BEGIN
IF ALexer^.Start^ = ':' THEN
AToken^.Kind := lexerKindColon
@ -251,7 +252,7 @@ BEGIN
END
END transition_action_finalize;
(* An action for tokens containing multiple characters. *)
PROCEDURE transition_action_composite(ALexer: PLexer; AToken: PLexerToken);
PROCEDURE transition_action_composite(ALexer: PLexer; AToken: PLexerToken);
BEGIN
IF ALexer^.Start^ = '<' THEN
IF ALexer^.Current^ = '>' THEN
@ -273,13 +274,13 @@ BEGIN
INC(ALexer^.Current)
END transition_action_composite;
(* Skip a space. *)
PROCEDURE transition_action_skip(ALexer: PLexer; AToken: PLexerToken);
PROCEDURE transition_action_skip(ALexer: PLexer; AToken: PLexerToken);
BEGIN
INC(ALexer^.Current);
INC(ALexer^.Start)
END transition_action_skip;
(* Delimited string action. *)
PROCEDURE transition_action_delimited(ALexer: PLexer; AToken: PLexerToken);
PROCEDURE transition_action_delimited(ALexer: PLexer; AToken: PLexerToken);
BEGIN
IF ALexer^.Start^ = '(' THEN
AToken^.Kind := lexerKindComment
@ -293,7 +294,7 @@ BEGIN
INC(ALexer^.Current)
END transition_action_delimited;
(* Finalize keyword or identifier. *)
PROCEDURE transition_action_key_id(ALexer: PLexer; AToken: PLexerToken);
PROCEDURE transition_action_key_id(ALexer: PLexer; AToken: PLexerToken);
BEGIN
AToken^.Kind := lexerKindIdentifier;
@ -398,7 +399,7 @@ BEGIN
END transition_action_key_id;
(* Action for tokens containing only one character. The character cannot be
* followed by other characters forming a composite token. *)
PROCEDURE transition_action_single(ALexer: PLexer; AToken: PLexerToken);
PROCEDURE transition_action_single(ALexer: PLexer; AToken: PLexerToken);
BEGIN
IF ALexer^.Current^ = '&' THEN
AToken^.Kind := lexerKindAnd
@ -445,39 +446,39 @@ BEGIN
INC(ALexer^.Current)
END transition_action_single;
(* Handle an integer literal. *)
PROCEDURE transition_action_integer(ALexer: PLexer; AToken: PLexerToken);
PROCEDURE transition_action_integer(ALexer: PLexer; AToken: PLexerToken);
BEGIN
AToken^.Kind := lexerKindInteger
END transition_action_integer;
PROCEDURE set_default_transition(CurrentState: TransitionState; DefaultAction: TransitionAction; NextState: TransitionState);
PROCEDURE set_default_transition(CurrentState: TransitionState; DefaultAction: TransitionAction; NextState: TransitionState);
VAR
DefaultTransition: Transition;
BEGIN
DefaultTransition.Action := DefaultAction;
DefaultTransition.NextState := NextState;
Transitions[ORD(CurrentState)][ORD(transitionClassInvalid)] := DefaultTransition;
Transitions[ORD(CurrentState)][ORD(transitionClassDigit)] := DefaultTransition;
Transitions[ORD(CurrentState)][ORD(transitionClassAlpha)] := DefaultTransition;
Transitions[ORD(CurrentState)][ORD(transitionClassSpace)] := DefaultTransition;
Transitions[ORD(CurrentState)][ORD(transitionClassColon)] := DefaultTransition;
Transitions[ORD(CurrentState)][ORD(transitionClassEquals)] := DefaultTransition;
Transitions[ORD(CurrentState)][ORD(transitionClassLeftParen)] := DefaultTransition;
Transitions[ORD(CurrentState)][ORD(transitionClassRightParen)] := DefaultTransition;
Transitions[ORD(CurrentState)][ORD(transitionClassAsterisk)] := DefaultTransition;
Transitions[ORD(CurrentState)][ORD(transitionClassUnderscore)] := DefaultTransition;
Transitions[ORD(CurrentState)][ORD(transitionClassSingle)] := DefaultTransition;
Transitions[ORD(CurrentState)][ORD(transitionClassHex)] := DefaultTransition;
Transitions[ORD(CurrentState)][ORD(transitionClassZero)] := DefaultTransition;
Transitions[ORD(CurrentState)][ORD(transitionClassX)] := DefaultTransition;
Transitions[ORD(CurrentState)][ORD(transitionClassEof)] := DefaultTransition;
Transitions[ORD(CurrentState)][ORD(transitionClassDot)] := DefaultTransition;
Transitions[ORD(CurrentState)][ORD(transitionClassMinus)] := DefaultTransition;
Transitions[ORD(CurrentState)][ORD(transitionClassSingleQuote)] := DefaultTransition;
Transitions[ORD(CurrentState)][ORD(transitionClassDoubleQuote)] := DefaultTransition;
Transitions[ORD(CurrentState)][ORD(transitionClassGreater)] := DefaultTransition;
Transitions[ORD(CurrentState)][ORD(transitionClassLess)] := DefaultTransition;
Transitions[ORD(CurrentState)][ORD(transitionClassOther)] := DefaultTransition
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
END set_default_transition;
(*
* The transition table describes transitions from one state to another, given
@ -498,248 +499,248 @@ END set_default_transition;
PROCEDURE initialize_transitions();
BEGIN
(* Start state. *)
Transitions[ORD(transitionStateStart)][ORD(transitionClassInvalid)].Action := NIL;
Transitions[ORD(transitionStateStart)][ORD(transitionClassInvalid)].NextState := transitionStateEnd;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassInvalid) + 1].Action := NIL;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassInvalid) + 1].NextState := transitionStateEnd;
Transitions[ORD(transitionStateStart)][ORD(transitionClassDigit)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateStart)][ORD(transitionClassDigit)].NextState := transitionStateDecimal;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassDigit) + 1].Action := transition_action_accumulate;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassDigit) + 1].NextState := transitionStateDecimal;
Transitions[ORD(transitionStateStart)][ORD(transitionClassAlpha)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateStart)][ORD(transitionClassAlpha)].NextState := transitionStateIdentifier;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassAlpha) + 1].Action := transition_action_accumulate;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassAlpha) + 1].NextState := transitionStateIdentifier;
Transitions[ORD(transitionStateStart)][ORD(transitionClassSpace)].Action := transition_action_skip;
Transitions[ORD(transitionStateStart)][ORD(transitionClassSpace)].NextState := transitionStateStart;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassSpace) + 1].Action := transition_action_skip;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassSpace) + 1].NextState := transitionStateStart;
Transitions[ORD(transitionStateStart)][ORD(transitionClassColon)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateStart)][ORD(transitionClassColon)].NextState := transitionStateColon;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassColon) + 1].Action := transition_action_accumulate;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassColon) + 1].NextState := transitionStateColon;
Transitions[ORD(transitionStateStart)][ORD(transitionClassEquals)].Action := transition_action_single;
Transitions[ORD(transitionStateStart)][ORD(transitionClassEquals)].NextState := transitionStateEnd;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassEquals) + 1].Action := transition_action_single;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassEquals) + 1].NextState := transitionStateEnd;
Transitions[ORD(transitionStateStart)][ORD(transitionClassLeftParen)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateStart)][ORD(transitionClassLeftParen)].NextState := transitionStateLeftParen;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassLeftParen) + 1].Action := transition_action_accumulate;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassLeftParen) + 1].NextState := transitionStateLeftParen;
Transitions[ORD(transitionStateStart)][ORD(transitionClassRightParen)].Action := transition_action_single;
Transitions[ORD(transitionStateStart)][ORD(transitionClassRightParen)].NextState := transitionStateEnd;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassRightParen) + 1].Action := transition_action_single;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassRightParen) + 1].NextState := transitionStateEnd;
Transitions[ORD(transitionStateStart)][ORD(transitionClassAsterisk)].Action := transition_action_single;
Transitions[ORD(transitionStateStart)][ORD(transitionClassAsterisk)].NextState := transitionStateEnd;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassAsterisk) + 1].Action := transition_action_single;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassAsterisk) + 1].NextState := transitionStateEnd;
Transitions[ORD(transitionStateStart)][ORD(transitionClassUnderscore)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateStart)][ORD(transitionClassUnderscore)].NextState := transitionStateIdentifier;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassUnderscore) + 1].Action := transition_action_accumulate;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassUnderscore) + 1].NextState := transitionStateIdentifier;
Transitions[ORD(transitionStateStart)][ORD(transitionClassSingle)].Action := transition_action_single;
Transitions[ORD(transitionStateStart)][ORD(transitionClassSingle)].NextState := transitionStateEnd;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassSingle) + 1].Action := transition_action_single;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassSingle) + 1].NextState := transitionStateEnd;
Transitions[ORD(transitionStateStart)][ORD(transitionClassHex)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateStart)][ORD(transitionClassHex)].NextState := transitionStateIdentifier;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassHex) + 1].Action := transition_action_accumulate;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassHex) + 1].NextState := transitionStateIdentifier;
Transitions[ORD(transitionStateStart)][ORD(transitionClassZero)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateStart)][ORD(transitionClassZero)].NextState := transitionStateLeadingZero;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassZero) + 1].Action := transition_action_accumulate;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassZero) + 1].NextState := transitionStateLeadingZero;
Transitions[ORD(transitionStateStart)][ORD(transitionClassX)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateStart)][ORD(transitionClassX)].NextState := transitionStateIdentifier;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassX) + 1].Action := transition_action_accumulate;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassX) + 1].NextState := transitionStateIdentifier;
Transitions[ORD(transitionStateStart)][ORD(transitionClassEof)].Action := transition_action_eof;
Transitions[ORD(transitionStateStart)][ORD(transitionClassEof)].NextState := transitionStateEnd;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassEof) + 1].Action := transition_action_eof;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassEof) + 1].NextState := transitionStateEnd;
Transitions[ORD(transitionStateStart)][ORD(transitionClassDot)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateStart)][ORD(transitionClassDot)].NextState := transitionStateDot;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassDot) + 1].Action := transition_action_accumulate;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassDot) + 1].NextState := transitionStateDot;
Transitions[ORD(transitionStateStart)][ORD(transitionClassMinus)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateStart)][ORD(transitionClassMinus)].NextState := transitionStateMinus;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassMinus) + 1].Action := transition_action_accumulate;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassMinus) + 1].NextState := transitionStateMinus;
Transitions[ORD(transitionStateStart)][ORD(transitionClassSingleQuote)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateStart)][ORD(transitionClassSingleQuote)].NextState := transitionStateCharacter;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassSingleQuote) + 1].Action := transition_action_accumulate;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassSingleQuote) + 1].NextState := transitionStateCharacter;
Transitions[ORD(transitionStateStart)][ORD(transitionClassDoubleQuote)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateStart)][ORD(transitionClassDoubleQuote)].NextState := transitionStateString;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassDoubleQuote) + 1].Action := transition_action_accumulate;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassDoubleQuote) + 1].NextState := transitionStateString;
Transitions[ORD(transitionStateStart)][ORD(transitionClassGreater)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateStart)][ORD(transitionClassGreater)].NextState := transitionStateGreater;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassGreater) + 1].Action := transition_action_accumulate;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassGreater) + 1].NextState := transitionStateGreater;
Transitions[ORD(transitionStateStart)][ORD(transitionClassLess)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateStart)][ORD(transitionClassLess)].NextState := transitionStateLess;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassLess) + 1].Action := transition_action_accumulate;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassLess) + 1].NextState := transitionStateLess;
Transitions[ORD(transitionStateStart)][ORD(transitionClassOther)].Action := NIL;
Transitions[ORD(transitionStateStart)][ORD(transitionClassOther)].NextState := transitionStateEnd;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassOther) + 1].Action := NIL;
transitions[ORD(transitionStateStart) + 1][ORD(transitionClassOther) + 1].NextState := transitionStateEnd;
(* Colon state. *)
set_default_transition(transitionStateColon, transition_action_finalize, transitionStateEnd);
Transitions[ORD(transitionStateColon)][ORD(transitionClassEquals)].Action := transition_action_composite;
Transitions[ORD(transitionStateColon)][ORD(transitionClassEquals)].NextState := transitionStateEnd;
transitions[ORD(transitionStateColon) + 1][ORD(transitionClassEquals) + 1].Action := transition_action_composite;
transitions[ORD(transitionStateColon) + 1][ORD(transitionClassEquals) + 1].NextState := transitionStateEnd;
(* Identifier state. *)
set_default_transition(transitionStateIdentifier, transition_action_key_id, transitionStateEnd);
Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassDigit)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassDigit)].NextState := transitionStateIdentifier;
transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassDigit) + 1].Action := transition_action_accumulate;
transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassDigit) + 1].NextState := transitionStateIdentifier;
Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassAlpha)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassAlpha)].NextState := transitionStateIdentifier;
transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassAlpha) + 1].Action := transition_action_accumulate;
transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassAlpha) + 1].NextState := transitionStateIdentifier;
Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassUnderscore)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassUnderscore)].NextState := transitionStateIdentifier;
transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassUnderscore) + 1].Action := transition_action_accumulate;
transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassUnderscore) + 1].NextState := transitionStateIdentifier;
Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassHex)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassHex)].NextState := transitionStateIdentifier;
transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassHex) + 1].Action := transition_action_accumulate;
transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassHex) + 1].NextState := transitionStateIdentifier;
Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassZero)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassZero)].NextState := transitionStateIdentifier;
transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassZero) + 1].Action := transition_action_accumulate;
transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassZero) + 1].NextState := transitionStateIdentifier;
Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassX)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassX)].NextState := transitionStateIdentifier;
transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassX) + 1].Action := transition_action_accumulate;
transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassX) + 1].NextState := transitionStateIdentifier;
(* Decimal state. *)
set_default_transition(transitionStateDecimal, transition_action_integer, transitionStateEnd);
Transitions[ORD(transitionStateDecimal)][ORD(transitionClassDigit)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateDecimal)][ORD(transitionClassDigit)].NextState := transitionStateDecimal;
transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassDigit) + 1].Action := transition_action_accumulate;
transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassDigit) + 1].NextState := transitionStateDecimal;
Transitions[ORD(transitionStateDecimal)][ORD(transitionClassAlpha)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateDecimal)][ORD(transitionClassAlpha)].NextState := transitionStateDecimalSuffix;
transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassAlpha) + 1].Action := transition_action_accumulate;
transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassAlpha) + 1].NextState := transitionStateDecimalSuffix;
Transitions[ORD(transitionStateDecimal)][ORD(transitionClassUnderscore)].Action := NIL;
Transitions[ORD(transitionStateDecimal)][ORD(transitionClassUnderscore)].NextState := transitionStateEnd;
transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassUnderscore) + 1].Action := NIL;
transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassUnderscore) + 1].NextState := transitionStateEnd;
Transitions[ORD(transitionStateDecimal)][ORD(transitionClassHex)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateDecimal)][ORD(transitionClassHex)].NextState := transitionStateDecimalSuffix;
transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassHex) + 1].Action := transition_action_accumulate;
transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassHex) + 1].NextState := transitionStateDecimalSuffix;
Transitions[ORD(transitionStateDecimal)][ORD(transitionClassZero)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateDecimal)][ORD(transitionClassZero)].NextState := transitionStateDecimal;
transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassZero) + 1].Action := transition_action_accumulate;
transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassZero) + 1].NextState := transitionStateDecimal;
Transitions[ORD(transitionStateDecimal)][ORD(transitionClassX)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateDecimal)][ORD(transitionClassX)].NextState := transitionStateDecimalSuffix;
transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassX) + 1].Action := transition_action_accumulate;
transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassX) + 1].NextState := transitionStateDecimalSuffix;
(* Greater state. *)
set_default_transition(transitionStateGreater, transition_action_finalize, transitionStateEnd);
Transitions[ORD(transitionStateGreater)][ORD(transitionClassEquals)].Action := transition_action_composite;
Transitions[ORD(transitionStateGreater)][ORD(transitionClassEquals)].NextState := transitionStateEnd;
transitions[ORD(transitionStateGreater) + 1][ORD(transitionClassEquals) + 1].Action := transition_action_composite;
transitions[ORD(transitionStateGreater) + 1][ORD(transitionClassEquals) + 1].NextState := transitionStateEnd;
(* Minus state. *)
set_default_transition(transitionStateMinus, transition_action_finalize, transitionStateEnd);
Transitions[ORD(transitionStateMinus)][ORD(transitionClassGreater)].Action := transition_action_composite;
Transitions[ORD(transitionStateMinus)][ORD(transitionClassGreater)].NextState := transitionStateEnd;
transitions[ORD(transitionStateMinus) + 1][ORD(transitionClassGreater) + 1].Action := transition_action_composite;
transitions[ORD(transitionStateMinus) + 1][ORD(transitionClassGreater) + 1].NextState := transitionStateEnd;
(* Left paren state. *)
set_default_transition(transitionStateLeftParen, transition_action_finalize, transitionStateEnd);
Transitions[ORD(transitionStateLeftParen)][ORD(transitionClassAsterisk)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateLeftParen)][ORD(transitionClassAsterisk)].NextState := transitionStateComment;
transitions[ORD(transitionStateLeftParen) + 1][ORD(transitionClassAsterisk) + 1].Action := transition_action_accumulate;
transitions[ORD(transitionStateLeftParen) + 1][ORD(transitionClassAsterisk) + 1].NextState := transitionStateComment;
(* Less state. *)
set_default_transition(transitionStateLess, transition_action_finalize, transitionStateEnd);
Transitions[ORD(transitionStateLess)][ORD(transitionClassEquals)].Action := transition_action_composite;
Transitions[ORD(transitionStateLess)][ORD(transitionClassEquals)].NextState := transitionStateEnd;
transitions[ORD(transitionStateLess) + 1][ORD(transitionClassEquals) + 1].Action := transition_action_composite;
transitions[ORD(transitionStateLess) + 1][ORD(transitionClassEquals) + 1].NextState := transitionStateEnd;
Transitions[ORD(transitionStateLess)][ORD(transitionClassGreater)].Action := transition_action_composite;
Transitions[ORD(transitionStateLess)][ORD(transitionClassGreater)].NextState := transitionStateEnd;
transitions[ORD(transitionStateLess) + 1][ORD(transitionClassGreater) + 1].Action := transition_action_composite;
transitions[ORD(transitionStateLess) + 1][ORD(transitionClassGreater) + 1].NextState := transitionStateEnd;
(* Hexadecimal after 0x. *)
set_default_transition(transitionStateDot, transition_action_finalize, transitionStateEnd);
Transitions[ORD(transitionStateDot)][ORD(transitionClassDot)].Action := transition_action_composite;
Transitions[ORD(transitionStateDot)][ORD(transitionClassDot)].NextState := transitionStateEnd;
transitions[ORD(transitionStateDot) + 1][ORD(transitionClassDot) + 1].Action := transition_action_composite;
transitions[ORD(transitionStateDot) + 1][ORD(transitionClassDot) + 1].NextState := transitionStateEnd;
(* Comment. *)
set_default_transition(transitionStateComment, transition_action_accumulate, transitionStateComment);
Transitions[ORD(transitionStateComment)][ORD(transitionClassAsterisk)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateComment)][ORD(transitionClassAsterisk)].NextState := transitionStateClosingComment;
transitions[ORD(transitionStateComment) + 1][ORD(transitionClassAsterisk) + 1].Action := transition_action_accumulate;
transitions[ORD(transitionStateComment) + 1][ORD(transitionClassAsterisk) + 1].NextState := transitionStateClosingComment;
Transitions[ORD(transitionStateComment)][ORD(transitionClassEof)].Action := NIL;
Transitions[ORD(transitionStateComment)][ORD(transitionClassEof)].NextState := transitionStateEnd;
transitions[ORD(transitionStateComment) + 1][ORD(transitionClassEof) + 1].Action := NIL;
transitions[ORD(transitionStateComment) + 1][ORD(transitionClassEof) + 1].NextState := transitionStateEnd;
(* Closing comment. *)
set_default_transition(transitionStateClosingComment, transition_action_accumulate, transitionStateComment);
Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassInvalid)].Action := NIL;
Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassInvalid)].NextState := transitionStateEnd;
transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassInvalid) + 1].Action := NIL;
transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassInvalid) + 1].NextState := transitionStateEnd;
Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassRightParen)].Action := transition_action_delimited;
Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassRightParen)].NextState := transitionStateEnd;
transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassRightParen) + 1].Action := transition_action_delimited;
transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassRightParen) + 1].NextState := transitionStateEnd;
Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassAsterisk)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassAsterisk)].NextState := transitionStateClosingComment;
transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassAsterisk) + 1].Action := transition_action_accumulate;
transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassAsterisk) + 1].NextState := transitionStateClosingComment;
Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassEof)].Action := NIL;
Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassEof)].NextState := transitionStateEnd;
transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassEof) + 1].Action := NIL;
transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassEof) + 1].NextState := transitionStateEnd;
(* Character. *)
set_default_transition(transitionStateCharacter, transition_action_accumulate, transitionStateCharacter);
Transitions[ORD(transitionStateCharacter)][ORD(transitionClassInvalid)].Action := NIL;
Transitions[ORD(transitionStateCharacter)][ORD(transitionClassInvalid)].NextState := transitionStateEnd;
transitions[ORD(transitionStateCharacter) + 1][ORD(transitionClassInvalid) + 1].Action := NIL;
transitions[ORD(transitionStateCharacter) + 1][ORD(transitionClassInvalid) + 1].NextState := transitionStateEnd;
Transitions[ORD(transitionStateCharacter)][ORD(transitionClassEof)].Action := NIL;
Transitions[ORD(transitionStateCharacter)][ORD(transitionClassEof)].NextState := transitionStateEnd;
transitions[ORD(transitionStateCharacter) + 1][ORD(transitionClassEof) + 1].Action := NIL;
transitions[ORD(transitionStateCharacter) + 1][ORD(transitionClassEof) + 1].NextState := transitionStateEnd;
Transitions[ORD(transitionStateCharacter)][ORD(transitionClassSingleQuote)].Action := transition_action_delimited;
Transitions[ORD(transitionStateCharacter)][ORD(transitionClassSingleQuote)].NextState := transitionStateEnd;
transitions[ORD(transitionStateCharacter) + 1][ORD(transitionClassSingleQuote) + 1].Action := transition_action_delimited;
transitions[ORD(transitionStateCharacter) + 1][ORD(transitionClassSingleQuote) + 1].NextState := transitionStateEnd;
(* String. *)
set_default_transition(transitionStateString, transition_action_accumulate, transitionStateString);
Transitions[ORD(transitionStateString)][ORD(transitionClassInvalid)].Action := NIL;
Transitions[ORD(transitionStateString)][ORD(transitionClassInvalid)].NextState := transitionStateEnd;
transitions[ORD(transitionStateString) + 1][ORD(transitionClassInvalid) + 1].Action := NIL;
transitions[ORD(transitionStateString) + 1][ORD(transitionClassInvalid) + 1].NextState := transitionStateEnd;
Transitions[ORD(transitionStateString)][ORD(transitionClassEof)].Action := NIL;
Transitions[ORD(transitionStateString)][ORD(transitionClassEof)].NextState := transitionStateEnd;
transitions[ORD(transitionStateString) + 1][ORD(transitionClassEof) + 1].Action := NIL;
transitions[ORD(transitionStateString) + 1][ORD(transitionClassEof) + 1].NextState := transitionStateEnd;
Transitions[ORD(transitionStateString)][ORD(transitionClassDoubleQuote)].Action := transition_action_delimited;
Transitions[ORD(transitionStateString)][ORD(transitionClassDoubleQuote)].NextState := transitionStateEnd;
transitions[ORD(transitionStateString) + 1][ORD(transitionClassDoubleQuote) + 1].Action := transition_action_delimited;
transitions[ORD(transitionStateString) + 1][ORD(transitionClassDoubleQuote) + 1].NextState := transitionStateEnd;
(* Leading zero. *)
set_default_transition(transitionStateLeadingZero, transition_action_integer, transitionStateEnd);
Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassDigit)].Action := NIL;
Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassDigit)].NextState := transitionStateEnd;
transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassDigit) + 1].Action := NIL;
transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassDigit) + 1].NextState := transitionStateEnd;
Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassAlpha)].Action := NIL;
Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassAlpha)].NextState := transitionStateEnd;
transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassAlpha) + 1].Action := NIL;
transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassAlpha) + 1].NextState := transitionStateEnd;
Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassUnderscore)].Action := NIL;
Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassUnderscore)].NextState := transitionStateEnd;
transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassUnderscore) + 1].Action := NIL;
transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassUnderscore) + 1].NextState := transitionStateEnd;
Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassHex)].Action := NIL;
Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassHex)].NextState := transitionStateEnd;
transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassHex) + 1].Action := NIL;
transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassHex) + 1].NextState := transitionStateEnd;
Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassZero)].Action := NIL;
Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassZero)].NextState := transitionStateEnd;
transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassZero) + 1].Action := NIL;
transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassZero) + 1].NextState := transitionStateEnd;
Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassX)].Action := NIL;
Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassX)].NextState := transitionStateEnd;
transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassX) + 1].Action := NIL;
transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassX) + 1].NextState := transitionStateEnd;
(* Digit with a character suffix. *)
set_default_transition(transitionStateDecimalSuffix, transition_action_integer, transitionStateEnd);
Transitions[ORD(transitionStateDecimalSuffix)][ORD(transitionClassAlpha)].Action := NIL;
Transitions[ORD(transitionStateDecimalSuffix)][ORD(transitionClassAlpha)].NextState := transitionStateEnd;
transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassAlpha) + 1].Action := NIL;
transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassAlpha) + 1].NextState := transitionStateEnd;
Transitions[ORD(transitionStateDecimalSuffix)][ORD(transitionClassDigit)].Action := NIL;
Transitions[ORD(transitionStateDecimalSuffix)][ORD(transitionClassDigit)].NextState := transitionStateEnd;
transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassDigit) + 1].Action := NIL;
transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassDigit) + 1].NextState := transitionStateEnd;
Transitions[ORD(transitionStateDecimalSuffix)][ORD(transitionClassHex)].Action := NIL;
Transitions[ORD(transitionStateDecimalSuffix)][ORD(transitionClassHex)].NextState := transitionStateEnd;
transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassHex) + 1].Action := NIL;
transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassHex) + 1].NextState := transitionStateEnd;
Transitions[ORD(transitionStateDecimalSuffix)][ORD(transitionClassZero)].Action := NIL;
Transitions[ORD(transitionStateDecimalSuffix)][ORD(transitionClassZero)].NextState := transitionStateEnd;
transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassZero) + 1].Action := NIL;
transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassZero) + 1].NextState := transitionStateEnd;
Transitions[ORD(transitionStateDecimalSuffix)][ORD(transitionClassX)].Action := NIL;
Transitions[ORD(transitionStateDecimalSuffix)][ORD(transitionClassX)].NextState := transitionStateEnd
transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassX) + 1].Action := NIL;
transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassX) + 1].NextState := transitionStateEnd
END initialize_transitions;
PROCEDURE lexer_initialize(ALexer: PLexer; Input: File);
PROCEDURE lexer_initialize(ALexer: PLexer; Input: File);
BEGIN
ALexer^.Input := Input;
ALexer^.Length := 0;
ALLOCATE(ALexer^.Buffer, ChunkSize);
MemZero(ALexer^.Buffer, ChunkSize);
ALexer^.Size := ChunkSize
ALLOCATE(ALexer^.Buffer, CHUNK_SIZE);
MemZero(ALexer^.Buffer, CHUNK_SIZE);
ALexer^.Size := CHUNK_SIZE
END lexer_initialize;
PROCEDURE lexer_current(ALexer: PLexer): LexerToken;
VAR
@ -752,9 +753,9 @@ BEGIN
CurrentState := transitionStateStart;
WHILE CurrentState <> transitionStateEnd DO
CurrentClass := Classification[ORD(ALexer^.Current^) + 1];
CurrentClass := classification[ORD(ALexer^.Current^) + 1];
CurrentTransition := Transitions[ORD(CurrentState)][ORD(CurrentClass)];
CurrentTransition := transitions[ORD(CurrentState) + 1][ORD(CurrentClass) + 1];
IF CurrentTransition.Action <> NIL THEN
CurrentTransition.Action(ALexer, ADR(Result))
END;
@ -767,7 +768,7 @@ VAR
Result: LexerToken;
BEGIN
IF ALexer^.Length = 0 THEN
ALexer^.Length := ReadNBytes(ALexer^.Input, ChunkSize, ALexer^.Buffer);
ALexer^.Length := ReadNBytes(ALexer^.Input, CHUNK_SIZE, ALexer^.Buffer);
ALexer^.Current := ALexer^.Buffer
END;
ALexer^.Start := ALexer^.Current;

482
source/Transpiler.mod
View File

@ -13,17 +13,17 @@ TYPE
END;
(* Calls lexer_lex() but skips the comments. *)
PROCEDURE transpiler_lex(ALexer: PLexer): LexerToken;
PROCEDURE transpiler_lex(lexer: PLexer): LexerToken;
VAR
Result: LexerToken;
result: LexerToken;
BEGIN
Result := lexer_lex(ALexer);
result := lexer_lex(lexer);
WHILE Result.Kind = lexerKindComment DO
Result := lexer_lex(ALexer)
WHILE result.Kind = lexerKindComment DO
result := lexer_lex(lexer)
END;
RETURN Result
RETURN result
END transpiler_lex;
(* Write a semicolon followed by a newline. *)
PROCEDURE write_semicolon();
@ -31,527 +31,525 @@ BEGIN
WriteString(';');
WriteLn()
END write_semicolon;
PROCEDURE transpile_import(AContext: PTranspilerContext; ALexer: PLexer);
PROCEDURE transpile_import(context: PTranspilerContext; lexer: PLexer);
VAR
Token: LexerToken;
WrittenBytes: CARDINAL;
token: LexerToken;
written_bytes: CARDINAL;
BEGIN
WriteString('FROM ');
Token := transpiler_lex(ALexer);
token := transpiler_lex(lexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(ALexer);
token := transpiler_lex(lexer);
WriteString(' IMPORT ');
Token := transpiler_lex(ALexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
token := transpiler_lex(lexer);
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(ALexer);
WHILE Token.Kind <> lexerKindSemicolon DO
token := transpiler_lex(lexer);
WHILE token.Kind <> lexerKindSemicolon DO
WriteString(', ');
Token := transpiler_lex(ALexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := transpiler_lex(ALexer)
token := transpiler_lex(lexer);
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
token := transpiler_lex(lexer)
END;
write_semicolon();
Token := transpiler_lex(ALexer)
token := transpiler_lex(lexer)
END transpile_import;
PROCEDURE transpile_import_part(AContext: PTranspilerContext; ALexer: PLexer);
PROCEDURE transpile_import_part(context: PTranspilerContext; lexer: PLexer);
VAR
Token: LexerToken;
token: LexerToken;
BEGIN
Token := lexer_current(ALexer);
token := lexer_current(lexer);
WHILE Token.Kind = lexerKindFrom DO
transpile_import(AContext, ALexer);
Token := lexer_current(ALexer)
WHILE token.Kind = lexerKindFrom DO
transpile_import(context, lexer);
token := lexer_current(lexer)
END;
WriteLn()
END transpile_import_part;
PROCEDURE transpile_constant(AContext: PTranspilerContext; ALexer: PLexer);
PROCEDURE transpile_constant(context: PTranspilerContext; lexer: PLexer);
VAR
Token: LexerToken;
WrittenBytes: CARDINAL;
written_bytes: CARDINAL;
BEGIN
WriteString(' ');
Token := lexer_current(ALexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := lexer_current(lexer);
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(ALexer);
Token := transpiler_lex(lexer);
WriteString(' = ');
Token := transpiler_lex(ALexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := transpiler_lex(lexer);
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(ALexer);
Token := transpiler_lex(lexer);
write_semicolon()
END transpile_constant;
PROCEDURE transpile_constant_part(AContext: PTranspilerContext; ALexer: PLexer): BOOLEAN;
PROCEDURE transpile_constant_part(context: PTranspilerContext; lexer: PLexer): BOOLEAN;
VAR
Token: LexerToken;
Result: BOOLEAN;
result: BOOLEAN;
BEGIN
Token := lexer_current(ALexer);
Result := Token.Kind = lexerKindConst;
Token := lexer_current(lexer);
result := Token.Kind = lexerKindConst;
IF Result THEN
IF result THEN
WriteString('CONST');
WriteLn();
Token := transpiler_lex(ALexer);
Token := transpiler_lex(lexer);
WHILE Token.Kind = lexerKindIdentifier DO
transpile_constant(AContext, ALexer);
Token := transpiler_lex(ALexer)
transpile_constant(context, lexer);
Token := transpiler_lex(lexer)
END
END;
RETURN Result
RETURN result
END transpile_constant_part;
PROCEDURE transpile_module(AContext: PTranspilerContext; ALexer: PLexer);
PROCEDURE transpile_module(context: PTranspilerContext; lexer: PLexer);
VAR
Token: LexerToken;
WrittenBytes: CARDINAL;
written_bytes: CARDINAL;
BEGIN
Token := transpiler_lex(ALexer);
Token := transpiler_lex(lexer);
IF Token.Kind = lexerKindDefinition THEN
WriteString('DEFINITION ');
Token := transpiler_lex(ALexer)
Token := transpiler_lex(lexer)
END;
IF Token.Kind = lexerKindImplementation THEN
WriteString('IMPLEMENTATION ');
Token := transpiler_lex(ALexer)
Token := transpiler_lex(lexer)
END;
WriteString('MODULE ');
(* Write the module name and end the line with a semicolon and newline. *)
Token := transpiler_lex(ALexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := transpiler_lex(lexer);
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(ALexer);
Token := transpiler_lex(lexer);
write_semicolon();
WriteLn();
(* Write the module body. *)
Token := transpiler_lex(ALexer);
transpile_import_part(AContext, ALexer);
IF transpile_constant_part(AContext, ALexer) THEN
Token := transpiler_lex(lexer);
transpile_import_part(context, lexer);
IF transpile_constant_part(context, lexer) THEN
WriteLn()
END;
transpile_type_part(AContext, ALexer);
IF transpile_variable_part(AContext, ALexer) THEN
transpile_type_part(context, lexer);
IF transpile_variable_part(context, lexer) THEN
WriteLn()
END;
transpile_procedure_part(AContext, ALexer);
transpile_statement_part(AContext, ALexer);
transpile_procedure_part(context, lexer);
transpile_statement_part(context, lexer);
WriteString('END ');
Token := transpiler_lex(ALexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := transpiler_lex(lexer);
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(ALexer);
Token := transpiler_lex(lexer);
Write('.');
Token := transpiler_lex(ALexer);
Token := transpiler_lex(lexer);
WriteLn()
END transpile_module;
PROCEDURE transpile_type_fields(AContext: PTranspilerContext; ALexer: PLexer);
PROCEDURE transpile_type_fields(context: PTranspilerContext; lexer: PLexer);
VAR
Token: LexerToken;
WrittenBytes: CARDINAL;
written_bytes: CARDINAL;
BEGIN
Token := transpiler_lex(ALexer);
Token := transpiler_lex(lexer);
WHILE Token.Kind <> lexerKindEnd DO
WriteString(' ');
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := transpiler_lex(ALexer);
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(lexer);
WriteString(': ');
transpile_type_expression(AContext, ALexer);
Token := transpiler_lex(ALexer);
transpile_type_expression(context, lexer);
Token := transpiler_lex(lexer);
IF Token.Kind = lexerKindSemicolon THEN
Token := transpiler_lex(ALexer);
Token := transpiler_lex(lexer);
Write(';')
END;
WriteLn()
END
END transpile_type_fields;
PROCEDURE transpile_record_type(AContext: PTranspilerContext; ALexer: PLexer);
PROCEDURE transpile_record_type(context: PTranspilerContext; lexer: PLexer);
VAR
Token: LexerToken;
BEGIN
WriteString('RECORD');
WriteLn();
transpile_type_fields(AContext, ALexer);
transpile_type_fields(context, lexer);
WriteString(' END')
END transpile_record_type;
PROCEDURE transpile_pointer_type(AContext: PTranspilerContext; ALexer: PLexer);
PROCEDURE transpile_pointer_type(context: PTranspilerContext; lexer: PLexer);
VAR
Token: LexerToken;
WrittenBytes: CARDINAL;
written_bytes: CARDINAL;
BEGIN
Token := lexer_current(ALexer);
Token := lexer_current(lexer);
WriteString('POINTER TO ');
IF Token.Kind = lexerKindPointer THEN
Token := transpiler_lex(ALexer)
Token := transpiler_lex(lexer)
END;
transpile_type_expression(AContext, ALexer)
transpile_type_expression(context, lexer)
END transpile_pointer_type;
PROCEDURE transpile_array_type(AContext: PTranspilerContext; ALexer: PLexer);
PROCEDURE transpile_array_type(context: PTranspilerContext; lexer: PLexer);
VAR
Token: LexerToken;
WrittenBytes: CARDINAL;
written_bytes: CARDINAL;
BEGIN
WriteString('ARRAY');
Token := transpiler_lex(ALexer);
Token := lexer_current(lexer);
IF Token.Kind = lexerKindArray THEN
Token := transpiler_lex(lexer)
END;
IF Token.Kind <> lexerKindOf THEN
Write('[');
Token := transpiler_lex(ALexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := transpiler_lex(ALexer);
WriteString('..');
Token := transpiler_lex(ALexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := transpiler_lex(ALexer);
Write(']');
Token := transpiler_lex(ALexer)
WriteString('[1..');
Token := transpiler_lex(lexer);
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(lexer);
Write(']')
END;
WriteString(' OF ');
transpile_type_expression(AContext, ALexer)
transpile_type_expression(context, lexer)
END transpile_array_type;
PROCEDURE transpile_enumeration_type(AContext: PTranspilerContext; ALexer: PLexer);
PROCEDURE transpile_enumeration_type(context: PTranspilerContext; lexer: PLexer);
VAR
Token: LexerToken;
WrittenBytes: CARDINAL;
written_bytes: CARDINAL;
BEGIN
WriteString('(');
WriteLn();
WriteString(' ');
Token := transpiler_lex(ALexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := transpiler_lex(lexer);
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(ALexer);
Token := transpiler_lex(lexer);
WHILE Token.Kind = lexerKindComma DO
Write(',');
WriteLn();
WriteString(' ');
Token := transpiler_lex(ALexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := transpiler_lex(lexer);
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(ALexer)
Token := transpiler_lex(lexer)
END;
WriteLn();
WriteString(' )')
END transpile_enumeration_type;
PROCEDURE transpile_union_type(AContext: PTranspilerContext; ALexer: PLexer);
PROCEDURE transpile_union_type(context: PTranspilerContext; lexer: PLexer);
VAR
Token: LexerToken;
END transpile_union_type;
PROCEDURE transpile_procedure_type(AContext: PTranspilerContext; ALexer: PLexer);
PROCEDURE transpile_procedure_type(context: PTranspilerContext; lexer: PLexer);
VAR
Token: LexerToken;
WrittenBytes: CARDINAL;
written_bytes: CARDINAL;
BEGIN
Token := transpiler_lex(ALexer);
Token := transpiler_lex(lexer);
WriteString('PROCEDURE(');
Token := transpiler_lex(ALexer);
Token := transpiler_lex(lexer);
WHILE Token.Kind <> lexerKindRightParen DO
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(ALexer);
Token := transpiler_lex(lexer);
IF Token.Kind = lexerKindComma THEN
Token := transpiler_lex(ALexer);
Token := transpiler_lex(lexer);
WriteString(', ')
END
END;
Write(')')
END transpile_procedure_type;
PROCEDURE transpile_type_expression(AContext: PTranspilerContext; ALexer: PLexer);
PROCEDURE transpile_type_expression(context: PTranspilerContext; lexer: PLexer);
VAR
Token: LexerToken;
WrittenBytes: CARDINAL;
written_bytes: CARDINAL;
BEGIN
Token := transpiler_lex(ALexer);
Token := transpiler_lex(lexer);
IF Token.Kind = lexerKindRecord THEN
transpile_record_type(AContext, ALexer)
transpile_record_type(context, lexer)
END;
IF Token.Kind = lexerKindLeftParen THEN
transpile_enumeration_type(AContext, ALexer)
transpile_enumeration_type(context, lexer)
END;
IF Token.Kind = lexerKindArray THEN
transpile_array_type(AContext, ALexer)
IF (Token.Kind = lexerKindArray) OR (Token.Kind = lexerKindLeftSquare) THEN
transpile_array_type(context, lexer)
END;
IF (Token.Kind = lexerKindPointer) OR (Token.Kind = lexerKindHat) THEN
transpile_pointer_type(AContext, ALexer)
IF Token.Kind = lexerKindHat THEN
transpile_pointer_type(context, lexer)
END;
IF Token.Kind = lexerKindProc THEN
transpile_procedure_type(AContext, ALexer)
transpile_procedure_type(context, lexer)
END;
IF Token.Kind = lexerKindIdentifier THEN
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start)
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start)
END
END transpile_type_expression;
PROCEDURE transpile_type_declaration(AContext: PTranspilerContext; ALexer: PLexer);
PROCEDURE transpile_type_declaration(context: PTranspilerContext; lexer: PLexer);
VAR
Token: LexerToken;
WrittenBytes: CARDINAL;
written_bytes: CARDINAL;
BEGIN
WriteString(' ');
Token := lexer_current(ALexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := lexer_current(lexer);
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(ALexer);
Token := transpiler_lex(lexer);
WriteString(' = ');
transpile_type_expression(AContext, ALexer);
Token := transpiler_lex(ALexer);
transpile_type_expression(context, lexer);
Token := transpiler_lex(lexer);
write_semicolon();
END transpile_type_declaration;
PROCEDURE transpile_type_part(AContext: PTranspilerContext; ALexer: PLexer);
PROCEDURE transpile_type_part(context: PTranspilerContext; lexer: PLexer);
VAR
Token: LexerToken;
BEGIN
Token := lexer_current(ALexer);
Token := lexer_current(lexer);
IF Token.Kind = lexerKindType THEN
WriteString('TYPE');
WriteLn();
Token := transpiler_lex(ALexer);
Token := transpiler_lex(lexer);
WHILE Token.Kind = lexerKindIdentifier DO
transpile_type_declaration(AContext, ALexer);
Token := transpiler_lex(ALexer)
transpile_type_declaration(context, lexer);
Token := transpiler_lex(lexer)
END;
WriteLn()
END
END transpile_type_part;
PROCEDURE transpile_variable_declaration(AContext: PTranspilerContext; ALexer: PLexer);
PROCEDURE transpile_variable_declaration(context: PTranspilerContext; lexer: PLexer);
VAR
Token: LexerToken;
WrittenBytes: CARDINAL;
written_bytes: CARDINAL;
BEGIN
WriteString(' ');
Token := lexer_current(ALexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := lexer_current(lexer);
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(ALexer);
Token := transpiler_lex(lexer);
WriteString(': ');
transpile_type_expression(AContext, ALexer);
Token := transpiler_lex(ALexer);
transpile_type_expression(context, lexer);
Token := transpiler_lex(lexer);
write_semicolon()
END transpile_variable_declaration;
PROCEDURE transpile_variable_part(AContext: PTranspilerContext; ALexer: PLexer): BOOLEAN;
PROCEDURE transpile_variable_part(context: PTranspilerContext; lexer: PLexer): BOOLEAN;
VAR
Token: LexerToken;
Result: BOOLEAN;
result: BOOLEAN;
BEGIN
Token := lexer_current(ALexer);
Result := Token.Kind = lexerKindVar;
Token := lexer_current(lexer);
result := Token.Kind = lexerKindVar;
IF Result THEN
IF result THEN
WriteString('VAR');
WriteLn();
Token := transpiler_lex(ALexer);
Token := transpiler_lex(lexer);
WHILE Token.Kind = lexerKindIdentifier DO
transpile_variable_declaration(AContext, ALexer);
Token := transpiler_lex(ALexer)
transpile_variable_declaration(context, lexer);
Token := transpiler_lex(lexer)
END
END;
RETURN Result
RETURN result
END transpile_variable_part;
PROCEDURE transpile_procedure_heading(AContext: PTranspilerContext; ALexer: PLexer): LexerToken;
PROCEDURE transpile_procedure_heading(context: PTranspilerContext; lexer: PLexer): LexerToken;
VAR
Token: LexerToken;
Result: LexerToken;
WrittenBytes: CARDINAL;
token: LexerToken;
result: LexerToken;
written_bytes: CARDINAL;
BEGIN
WriteString('PROCEDURE ');
Result := transpiler_lex(ALexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
result := transpiler_lex(lexer);
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(ALexer);
token := transpiler_lex(lexer);
Write('(');
Token := transpiler_lex(ALexer);
WHILE Token.Kind <> lexerKindRightParen DO
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
token := transpiler_lex(lexer);
WHILE token.Kind <> lexerKindRightParen DO
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(ALexer);
token := transpiler_lex(lexer);
WriteString(': ');
transpile_type_expression(AContext, ALexer);
transpile_type_expression(context, lexer);
Token := transpiler_lex(ALexer);
IF Token.Kind = lexerKindSemicolon THEN
token := transpiler_lex(lexer);
IF (token.Kind = lexerKindSemicolon) OR (token.Kind = lexerKindComma) THEN
WriteString('; ');
Token := transpiler_lex(ALexer)
token := transpiler_lex(lexer)
END
END;
WriteString(')');
Token := transpiler_lex(ALexer);
token := transpiler_lex(lexer);
(* Check for the return type and write it. *)
IF Token.Kind = lexerKindColon THEN
IF token.Kind = lexerKindColon THEN
WriteString(': ');
Token := transpiler_lex(ALexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := transpiler_lex(ALexer)
token := transpiler_lex(lexer);
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
token := transpiler_lex(lexer)
END;
Token := transpiler_lex(ALexer);
token := transpiler_lex(lexer);
write_semicolon();
RETURN Result
RETURN result
END transpile_procedure_heading;
PROCEDURE transpile_expression(AContext: PTranspilerContext; ALexer: PLexer; TrailingToken: LexerKind);
PROCEDURE transpile_expression(context: PTranspilerContext; lexer: PLexer; TrailingToken: LexerKind);
VAR
Token: LexerToken;
WrittenBytes: CARDINAL;
written_bytes: CARDINAL;
BEGIN
Token := transpiler_lex(ALexer);
Token := transpiler_lex(lexer);
WHILE (Token.Kind <> TrailingToken) AND (Token.Kind <> lexerKindEnd) DO
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Write(' ');
Token := transpiler_lex(ALexer)
Token := transpiler_lex(lexer)
END
END transpile_expression;
PROCEDURE transpile_if_statement(AContext: PTranspilerContext; ALexer: PLexer);
PROCEDURE transpile_if_statement(context: PTranspilerContext; lexer: PLexer);
VAR
Token: LexerToken;
WrittenBytes: CARDINAL;
written_bytes: CARDINAL;
BEGIN
WriteString(' IF ');
transpile_expression(AContext, ALexer, lexerKindThen);
transpile_expression(context, lexer, lexerKindThen);
WriteString('THEN');
WriteLn();
transpile_statements(AContext, ALexer);
transpile_statements(context, lexer);
WriteString(' END');
Token := transpiler_lex(ALexer)
Token := transpiler_lex(lexer)
END transpile_if_statement;
PROCEDURE transpile_while_statement(AContext: PTranspilerContext; ALexer: PLexer);
PROCEDURE transpile_while_statement(context: PTranspilerContext; lexer: PLexer);
VAR
Token: LexerToken;
WrittenBytes: CARDINAL;
written_bytes: CARDINAL;
BEGIN
WriteString(' WHILE ');
transpile_expression(AContext, ALexer, lexerKindDo);
transpile_expression(context, lexer, lexerKindDo);
WriteString('DO');
WriteLn();
transpile_statements(AContext, ALexer);
transpile_statements(context, lexer);
WriteString(' END');
Token := transpiler_lex(ALexer)
Token := transpiler_lex(lexer)
END transpile_while_statement;
PROCEDURE transpile_assignment_statement(AContext: PTranspilerContext; ALexer: PLexer);
PROCEDURE transpile_assignment_statement(context: PTranspilerContext; lexer: PLexer);
BEGIN
WriteString(' := ');
transpile_expression(AContext, ALexer, lexerKindSemicolon);
transpile_expression(context, lexer, lexerKindSemicolon);
END transpile_assignment_statement;
PROCEDURE transpile_call_statement(AContext: PTranspilerContext; ALexer: PLexer);
PROCEDURE transpile_call_statement(context: PTranspilerContext; lexer: PLexer);
VAR
Token: LexerToken;
WrittenBytes: CARDINAL;
written_bytes: CARDINAL;
BEGIN
WriteString('(');
Token := transpiler_lex(ALexer);
Token := transpiler_lex(lexer);
WHILE (Token.Kind <> lexerKindSemicolon) AND (Token.Kind <> lexerKindEnd) DO
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := transpiler_lex(ALexer)
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(lexer)
END
END transpile_call_statement;
PROCEDURE transpile_return_statement(AContext: PTranspilerContext; ALexer: PLexer);
PROCEDURE transpile_return_statement(context: PTranspilerContext; lexer: PLexer);
VAR
Token: LexerToken;
WrittenBytes: CARDINAL;
written_bytes: CARDINAL;
BEGIN
WriteString(' RETURN ');
Token := transpiler_lex(ALexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := transpiler_lex(ALexer)
Token := transpiler_lex(lexer);
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(lexer)
END transpile_return_statement;
PROCEDURE transpile_statement(AContext: PTranspilerContext; ALexer: PLexer);
PROCEDURE transpile_statement(context: PTranspilerContext; lexer: PLexer);
VAR
Token: LexerToken;
WrittenBytes: CARDINAL;
written_bytes: CARDINAL;
BEGIN
Token := transpiler_lex(ALexer);
Token := transpiler_lex(lexer);
IF Token.Kind = lexerKindIf THEN
transpile_if_statement(AContext, ALexer)
transpile_if_statement(context, lexer)
END;
IF Token.Kind = lexerKindWhile THEN
transpile_while_statement(AContext, ALexer)
transpile_while_statement(context, lexer)
END;
IF Token.Kind = lexerKindReturn THEN
transpile_return_statement(AContext, ALexer)
transpile_return_statement(context, lexer)
END;
IF Token.Kind = lexerKindIdentifier THEN
WriteString(' ');
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := transpiler_lex(ALexer);
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(lexer);
WHILE Token.Kind = lexerKindLeftSquare DO
Write('[');
Token := transpiler_lex(ALexer);
Token := transpiler_lex(lexer);
WHILE Token.Kind <> lexerKindRightSquare DO
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := transpiler_lex(ALexer)
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(lexer)
END;
Write(']');
Token := transpiler_lex(ALexer);
Token := transpiler_lex(lexer);
END;
IF Token.Kind = lexerKindHat THEN
Write('^');
Token := transpiler_lex(ALexer)
Token := transpiler_lex(lexer)
END;
IF Token.Kind = lexerKindDot THEN
Write('.');
Token := transpiler_lex(ALexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := transpiler_lex(ALexer);
Token := transpiler_lex(lexer);
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(lexer);
END;
IF Token.Kind = lexerKindHat THEN
Write('^');
Token := transpiler_lex(ALexer)
Token := transpiler_lex(lexer)
END;
WHILE Token.Kind = lexerKindLeftSquare DO
Write('[');
Token := transpiler_lex(ALexer);
Token := transpiler_lex(lexer);
WHILE Token.Kind <> lexerKindRightSquare DO
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := transpiler_lex(ALexer)
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(lexer)
END;
Write(']');
Token := transpiler_lex(ALexer);
Token := transpiler_lex(lexer);
END;
IF Token.Kind = lexerKindAssignment THEN
transpile_assignment_statement(AContext, ALexer)
transpile_assignment_statement(context, lexer)
END;
IF Token.Kind = lexerKindLeftParen THEN
transpile_call_statement(AContext, ALexer)
transpile_call_statement(context, lexer)
END
END
END transpile_statement;
PROCEDURE transpile_statements(AContext: PTranspilerContext; ALexer: PLexer);
PROCEDURE transpile_statements(context: PTranspilerContext; lexer: PLexer);
VAR
Token: LexerToken;
BEGIN
Token := lexer_current(ALexer);
Token := lexer_current(lexer);
WHILE Token.Kind <> lexerKindEnd DO
transpile_statement(AContext, ALexer);
Token := lexer_current(ALexer);
transpile_statement(context, lexer);
Token := lexer_current(lexer);
IF Token.Kind = lexerKindSemicolon THEN
Write(';')
@ -559,53 +557,53 @@ BEGIN
WriteLn()
END
END transpile_statements;
PROCEDURE transpile_statement_part(AContext: PTranspilerContext; ALexer: PLexer);
PROCEDURE transpile_statement_part(context: PTranspilerContext; lexer: PLexer);
VAR
Token: LexerToken;
BEGIN
Token := lexer_current(ALexer);
Token := lexer_current(lexer);
IF Token.Kind = lexerKindBegin THEN
WriteString('BEGIN');
WriteLn();
transpile_statements(AContext, ALexer)
transpile_statements(context, lexer)
END
END transpile_statement_part;
PROCEDURE transpile_procedure_declaration(AContext: PTranspilerContext; ALexer: PLexer);
PROCEDURE transpile_procedure_declaration(context: PTranspilerContext; lexer: PLexer);
VAR
Token: LexerToken;
SeenPart: BOOLEAN;
WrittenBytes: CARDINAL;
seen_part: BOOLEAN;
written_bytes: CARDINAL;
BEGIN
Token := transpile_procedure_heading(AContext, ALexer);
SeenPart := transpile_constant_part(AContext, ALexer);
SeenPart := transpile_variable_part(AContext, ALexer);
transpile_statement_part(AContext, ALexer);
Token := transpile_procedure_heading(context, lexer);
seen_part := transpile_constant_part(context, lexer);
seen_part := transpile_variable_part(context, lexer);
transpile_statement_part(context, lexer);
WriteString('END ');
WrittenBytes := WriteNBytes(StdOut, ORD(Token.identifierKind[1]), ADR(Token.identifierKind[2]));
written_bytes := WriteNBytes(StdOut, ORD(Token.identifierKind[1]), ADR(Token.identifierKind[2]));
Token := transpiler_lex(ALexer);
Token := transpiler_lex(lexer);
write_semicolon();
Token := transpiler_lex(ALexer)
Token := transpiler_lex(lexer)
END transpile_procedure_declaration;
PROCEDURE transpile_procedure_part(AContext: PTranspilerContext; ALexer: PLexer);
PROCEDURE transpile_procedure_part(context: PTranspilerContext; lexer: PLexer);
VAR
Token: LexerToken;
BEGIN
Token := lexer_current(ALexer);
Token := lexer_current(lexer);
WHILE Token.Kind = lexerKindProc DO
transpile_procedure_declaration(AContext, ALexer);
Token := lexer_current(ALexer);
transpile_procedure_declaration(context, lexer);
Token := lexer_current(lexer);
WriteLn()
END
END transpile_procedure_part;
PROCEDURE transpile(ALexer: PLexer);
PROCEDURE transpile(lexer: PLexer);
VAR
Token: LexerToken;
WrittenBytes: CARDINAL;
written_bytes: CARDINAL;
Context: TranspilerContext;
BEGIN
transpile_module(ADR(Context), ALexer)
transpile_module(ADR(Context), lexer)
END transpile;
END Transpiler.