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

Shorten the array syntax

Browse Source
This commit is contained in:
Eugen Wissner
2025-05-30 12:57:04 +02:00
parent bd41736697
commit 3ece536414
4 changed files with 547 additions and 545 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
Rakefile
View File

@ -111,9 +111,12 @@ task :backport do
.gsub(/^from ([[:alnum:]]+) import/, 'FROM \1 IMPORT')
.gsub(/ \^([[:alnum:]])/, ' POINTER TO \1')
.gsub(/(then|do)$/) { |match| match.upcase }
.gsub(/(:|=) \[([[:digit:]]+)\]/, '\1 ARRAY[1..\2] OF ')
.each_line do |line|
if line.start_with? 'PROCEDURE'
current_procedure = line[10...line.index('(')]
line.gsub! ',', ';'
elsif line.start_with?('END;') && !current_procedure.nil?
line = "END #{current_procedure};"
current_proceure = nil

8
source/Compiler.elna
View File

@ -7,12 +7,12 @@ from Lexer import Lexer, lexer_destroy, lexer_initialize;
from Transpiler import transpile;
var
ALexer: Lexer;
lexer: Lexer;
begin
lexer_initialize(ADR(ALexer), StdIn);
lexer_initialize(ADR(lexer), StdIn);
transpile(ADR(ALexer));
transpile(ADR(lexer));
lexer_destroy(ADR(ALexer))
lexer_destroy(ADR(lexer))
end Compiler.

599
source/Lexer.elna
View File

@ -9,7 +9,7 @@ from MemUtils import MemCopy, MemZero;
from StrCase import Lower;
const
ChunkSize = 65536;
CHUNK_SIZE = 65536;
type
(*
@ -65,144 +65,145 @@ type
Action: TransitionAction;
NextState: TransitionState
end;
TransitionClasses = [22]Transition;
var
Classification: ARRAY[1..128] OF TransitionClass;
Transitions: ARRAY[0..15] OF ARRAY[0..21] OF Transition;
classification: [128]TransitionClass;
transitions: [16]TransitionClasses;
proc 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;
proc compare_keyword(Keyword: ARRAY OF CHAR; TokenStart: PLexerBuffer; TokenEnd: PLexerBuffer): BOOLEAN;
proc compare_keyword(Keyword: ARRAY OF CHAR, TokenStart: PLexerBuffer, TokenEnd: PLexerBuffer): BOOLEAN;
var
Result: BOOLEAN;
Index: CARDINAL;
@ -220,20 +221,20 @@ begin
end;
(* Reached the end of file. *)
proc transition_action_eof(ALexer: PLexer; AToken: PLexerToken);
proc transition_action_eof(ALexer: PLexer, AToken: PLexerToken);
begin
AToken^.Kind := lexerKindEof
end;
(* Add the character to the token currently read and advance to the next character. *)
proc transition_action_accumulate(ALexer: PLexer; AToken: PLexerToken);
proc transition_action_accumulate(ALexer: PLexer, AToken: PLexerToken);
begin
INC(ALexer^.Current)
end;
(* The current character is not a part of the token. Finish the token already
* read. Don't advance to the next character. *)
proc transition_action_finalize(ALexer: PLexer; AToken: PLexerToken);
proc transition_action_finalize(ALexer: PLexer, AToken: PLexerToken);
begin
if ALexer^.Start^ = ':' then
AToken^.Kind := lexerKindColon
@ -256,7 +257,7 @@ begin
end;
(* An action for tokens containing multiple characters. *)
proc transition_action_composite(ALexer: PLexer; AToken: PLexerToken);
proc transition_action_composite(ALexer: PLexer, AToken: PLexerToken);
begin
if ALexer^.Start^ = '<' then
if ALexer^.Current^ = '>' then
@ -279,14 +280,14 @@ begin
end;
(* Skip a space. *)
proc transition_action_skip(ALexer: PLexer; AToken: PLexerToken);
proc transition_action_skip(ALexer: PLexer, AToken: PLexerToken);
begin
INC(ALexer^.Current);
INC(ALexer^.Start)
end;
(* Delimited string action. *)
proc transition_action_delimited(ALexer: PLexer; AToken: PLexerToken);
proc transition_action_delimited(ALexer: PLexer, AToken: PLexerToken);
begin
if ALexer^.Start^ = '(' then
AToken^.Kind := lexerKindComment
@ -301,7 +302,7 @@ begin
end;
(* Finalize keyword or identifier. *)
proc transition_action_key_id(ALexer: PLexer; AToken: PLexerToken);
proc transition_action_key_id(ALexer: PLexer, AToken: PLexerToken);
begin
AToken^.Kind := lexerKindIdentifier;
@ -407,7 +408,7 @@ end;
(* Action for tokens containing only one character. The character cannot be
* followed by other characters forming a composite token. *)
proc transition_action_single(ALexer: PLexer; AToken: PLexerToken);
proc transition_action_single(ALexer: PLexer, AToken: PLexerToken);
begin
if ALexer^.Current^ = '&' then
AToken^.Kind := lexerKindAnd
@ -455,40 +456,40 @@ begin
end;
(* Handle an integer literal. *)
proc transition_action_integer(ALexer: PLexer; AToken: PLexerToken);
proc transition_action_integer(ALexer: PLexer, AToken: PLexerToken);
begin
AToken^.Kind := lexerKindInteger
end;
proc set_default_transition(CurrentState: TransitionState; DefaultAction: TransitionAction; NextState: TransitionState);
proc 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;
(*
@ -510,249 +511,249 @@ end;
proc 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;
proc lexer_initialize(ALexer: PLexer; Input: File);
proc 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;
proc lexer_current(ALexer: PLexer): LexerToken;
@ -766,9 +767,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;
@ -782,7 +783,7 @@ var
Result: LexerToken;
begin
if ALexer^.Length = 0 then
ALexer^.Length := ReadNBytes(ALexer^.Input, ChunkSize, ALexer^.Buffer);
ALexer^.Length := ReadNBytes(ALexer^.Input, CHUNK_SIZE, ALexer^.Buffer);
ALexer^.Current := ALexer^.Buffer
end;
ALexer^.Start := ALexer^.Current;

482
source/Transpiler.elna
View File

@ -13,17 +13,17 @@ type
end;
(* Calls lexer_lex() but skips the comments. *)
proc transpiler_lex(ALexer: PLexer): LexerToken;
proc 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;
(* Write a semicolon followed by a newline. *)
@ -33,552 +33,550 @@ begin
WriteLn()
end;
proc transpile_import(AContext: PTranspilerContext; ALexer: PLexer);
proc 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;
proc transpile_import_part(AContext: PTranspilerContext; ALexer: PLexer);
proc 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;
proc transpile_constant(AContext: PTranspilerContext; ALexer: PLexer);
proc 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;
proc transpile_constant_part(AContext: PTranspilerContext; ALexer: PLexer): BOOLEAN;
proc 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;
proc transpile_module(AContext: PTranspilerContext; ALexer: PLexer);
proc 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;
proc transpile_type_fields(AContext: PTranspilerContext; ALexer: PLexer);
proc 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;
proc transpile_record_type(AContext: PTranspilerContext; ALexer: PLexer);
proc 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;
proc transpile_pointer_type(AContext: PTranspilerContext; ALexer: PLexer);
proc 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;
proc transpile_array_type(AContext: PTranspilerContext; ALexer: PLexer);
proc 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;
proc transpile_enumeration_type(AContext: PTranspilerContext; ALexer: PLexer);
proc 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;
proc transpile_union_type(AContext: PTranspilerContext; ALexer: PLexer);
proc transpile_union_type(context: PTranspilerContext, lexer: PLexer);
var
Token: LexerToken;
end;
proc transpile_procedure_type(AContext: PTranspilerContext; ALexer: PLexer);
proc 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;
proc transpile_type_expression(AContext: PTranspilerContext; ALexer: PLexer);
proc 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;
proc transpile_type_declaration(AContext: PTranspilerContext; ALexer: PLexer);
proc 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;
proc transpile_type_part(AContext: PTranspilerContext; ALexer: PLexer);
proc 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;
proc transpile_variable_declaration(AContext: PTranspilerContext; ALexer: PLexer);
proc 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;
proc transpile_variable_part(AContext: PTranspilerContext; ALexer: PLexer): BOOLEAN;
proc 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;
proc transpile_procedure_heading(AContext: PTranspilerContext; ALexer: PLexer): LexerToken;
proc 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;
proc transpile_expression(AContext: PTranspilerContext; ALexer: PLexer; TrailingToken: LexerKind);
proc 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;
proc transpile_if_statement(AContext: PTranspilerContext; ALexer: PLexer);
proc 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;
proc transpile_while_statement(AContext: PTranspilerContext; ALexer: PLexer);
proc 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;
proc transpile_assignment_statement(AContext: PTranspilerContext; ALexer: PLexer);
proc transpile_assignment_statement(context: PTranspilerContext, lexer: PLexer);
begin
WriteString(' := ');
transpile_expression(AContext, ALexer, lexerKindSemicolon);
transpile_expression(context, lexer, lexerKindSemicolon);
end;
proc transpile_call_statement(AContext: PTranspilerContext; ALexer: PLexer);
proc 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;
proc transpile_return_statement(AContext: PTranspilerContext; ALexer: PLexer);
proc 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;
proc transpile_statement(AContext: PTranspilerContext; ALexer: PLexer);
proc 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;
proc transpile_statements(AContext: PTranspilerContext; ALexer: PLexer);
proc 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(';')
@ -587,57 +585,57 @@ begin
end
end;
proc transpile_statement_part(AContext: PTranspilerContext; ALexer: PLexer);
proc 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;
proc transpile_procedure_declaration(AContext: PTranspilerContext; ALexer: PLexer);
proc 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;
proc transpile_procedure_part(AContext: PTranspilerContext; ALexer: PLexer);
proc 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;
proc transpile(ALexer: PLexer);
proc 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;
end Transpiler.