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: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(/^from ([[:alnum:]]+) import/, 'FROM \1 IMPORT')
.gsub(/ \^([[:alnum:]])/, ' POINTER TO \1') .gsub(/ \^([[:alnum:]])/, ' POINTER TO \1')
.gsub(/(then|do)$/) { |match| match.upcase } .gsub(/(then|do)$/) { |match| match.upcase }
.gsub(/(:|=) \[([[:digit:]]+)\]/, '\1 ARRAY[1..\2] OF ')
.each_line do |line| .each_line do |line|
if line.start_with? 'PROCEDURE' if line.start_with? 'PROCEDURE'
current_procedure = line[10...line.index('(')] current_procedure = line[10...line.index('(')]
line.gsub! ',', ';'
elsif line.start_with?('END;') && !current_procedure.nil? elsif line.start_with?('END;') && !current_procedure.nil?
line = "END #{current_procedure};" line = "END #{current_procedure};"
current_proceure = nil 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; 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.elna
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,144 +65,145 @@ type
Action: TransitionAction; Action: TransitionAction;
NextState: TransitionState NextState: TransitionState
end; end;
TransitionClasses = [22]Transition;
var var
Classification: ARRAY[1..128] OF TransitionClass; classification: [128]TransitionClass;
Transitions: ARRAY[0..15] OF ARRAY[0..21] OF Transition; transitions: [16]TransitionClasses;
proc initialize_classification(); proc 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; 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 var
Result: BOOLEAN; Result: BOOLEAN;
Index: CARDINAL; Index: CARDINAL;
@@ -220,20 +221,20 @@ begin
end; end;
(* Reached the end of file. *) (* Reached the end of file. *)
proc transition_action_eof(ALexer: PLexer; AToken: PLexerToken); proc transition_action_eof(ALexer: PLexer, AToken: PLexerToken);
begin begin
AToken^.Kind := lexerKindEof AToken^.Kind := lexerKindEof
end; end;
(* 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. *)
proc transition_action_accumulate(ALexer: PLexer; AToken: PLexerToken); proc transition_action_accumulate(ALexer: PLexer, AToken: PLexerToken);
begin begin
INC(ALexer^.Current) INC(ALexer^.Current)
end; end;
(* 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. *)
proc transition_action_finalize(ALexer: PLexer; AToken: PLexerToken); proc transition_action_finalize(ALexer: PLexer, AToken: PLexerToken);
begin begin
if ALexer^.Start^ = ':' then if ALexer^.Start^ = ':' then
AToken^.Kind := lexerKindColon AToken^.Kind := lexerKindColon
@@ -256,7 +257,7 @@ begin
end; end;
(* An action for tokens containing multiple characters. *) (* An action for tokens containing multiple characters. *)
proc transition_action_composite(ALexer: PLexer; AToken: PLexerToken); proc 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
@@ -279,14 +280,14 @@ begin
end; end;
(* Skip a space. *) (* Skip a space. *)
proc transition_action_skip(ALexer: PLexer; AToken: PLexerToken); proc transition_action_skip(ALexer: PLexer, AToken: PLexerToken);
begin begin
INC(ALexer^.Current); INC(ALexer^.Current);
INC(ALexer^.Start) INC(ALexer^.Start)
end; end;
(* Delimited string action. *) (* Delimited string action. *)
proc transition_action_delimited(ALexer: PLexer; AToken: PLexerToken); proc transition_action_delimited(ALexer: PLexer, AToken: PLexerToken);
begin begin
if ALexer^.Start^ = '(' then if ALexer^.Start^ = '(' then
AToken^.Kind := lexerKindComment AToken^.Kind := lexerKindComment
@@ -301,7 +302,7 @@ begin
end; end;
(* Finalize keyword or identifier. *) (* Finalize keyword or identifier. *)
proc transition_action_key_id(ALexer: PLexer; AToken: PLexerToken); proc transition_action_key_id(ALexer: PLexer, AToken: PLexerToken);
begin begin
AToken^.Kind := lexerKindIdentifier; AToken^.Kind := lexerKindIdentifier;
@@ -407,7 +408,7 @@ end;
(* 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. *)
proc transition_action_single(ALexer: PLexer; AToken: PLexerToken); proc transition_action_single(ALexer: PLexer, AToken: PLexerToken);
begin begin
if ALexer^.Current^ = '&' then if ALexer^.Current^ = '&' then
AToken^.Kind := lexerKindAnd AToken^.Kind := lexerKindAnd
@@ -455,40 +456,40 @@ begin
end; end;
(* Handle an integer literal. *) (* Handle an integer literal. *)
proc transition_action_integer(ALexer: PLexer; AToken: PLexerToken); proc transition_action_integer(ALexer: PLexer, AToken: PLexerToken);
begin begin
AToken^.Kind := lexerKindInteger AToken^.Kind := lexerKindInteger
end; end;
proc set_default_transition(CurrentState: TransitionState; DefaultAction: TransitionAction; NextState: TransitionState); proc 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; end;
(* (*
@@ -510,249 +511,249 @@ end;
proc initialize_transitions(); proc 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; end;
proc lexer_initialize(ALexer: PLexer; Input: File); proc 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; end;
proc lexer_current(ALexer: PLexer): LexerToken; proc lexer_current(ALexer: PLexer): LexerToken;
@@ -766,9 +767,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;
@@ -782,7 +783,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.elna
View File

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