belka/elna
1
0
Fork 0
Code Issues 41 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; FROM Transpiler IMPORT transpile;
VAR VAR
ALexer: Lexer; lexer: Lexer;
BEGIN 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. END Compiler.

599
source/Lexer.mod
View File

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

482
source/Transpiler.mod
View File

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