From 35d2b5ef2be806fb06e478abbe120c5319e3cf8e Mon Sep 17 00:00:00 2001 From: Eugen Wissner Date: Fri, 30 May 2025 12:56:11 +0200 Subject: [PATCH] Shorten the array syntax --- source/Compiler.mod | 8 +- source/Lexer.mod | 599 +++++++++++++++++++++--------------------- source/Transpiler.mod | 482 +++++++++++++++++---------------- 3 files changed, 544 insertions(+), 545 deletions(-) diff --git a/source/Compiler.mod b/source/Compiler.mod index 54b5f38..c6b3e09 100644 --- a/source/Compiler.mod +++ b/source/Compiler.mod @@ -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. diff --git a/source/Lexer.mod b/source/Lexer.mod index 09611ff..67622b4 100644 --- a/source/Lexer.mod +++ b/source/Lexer.mod @@ -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; diff --git a/source/Transpiler.mod b/source/Transpiler.mod index 500b219..fd56d3c 100644 --- a/source/Transpiler.mod +++ b/source/Transpiler.mod @@ -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.