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

Make procedure name after the end

Browse Source
This commit is contained in:
Eugen Wissner 2025-05-29 14:59:56 +02:00
parent 192e7e40c8
commit bd41736697
Signed by: belka
GPG Key ID: A27FDC1E8EE902C0
6 changed files with 410 additions and 377 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
Rakefile
View File

@ -15,11 +15,11 @@ CLEAN.include 'build'
rule(/build\/stage1\/.+\.o$/ => ->(file) { rule(/build\/stage1\/.+\.o$/ => ->(file) {
path = Pathname.new('boot/stage1/source') + Pathname.new(file).basename path = Pathname.new('boot/stage1/source') + Pathname.new(file).basename
['build/stage1', path.sub_ext('.def'), path.sub_ext('.elna')] ['build/stage1', path.sub_ext('.def'), path.sub_ext('.mod')]
}) do |t| }) do |t|
sources = t.prerequisites.filter { |f| f.end_with? '.elna' } sources = t.prerequisites.filter { |f| f.end_with? '.mod' }
sh M2C, '-fmod=.elna', '-c', '-I', 'boot/stage1/source', '-o', t.name, *sources sh M2C, '-c', '-I', 'boot/stage1/source', '-o', t.name, *sources
end end
file 'build/stage1/elna' => FileList['boot/stage1/source/*'].map { |file| file 'build/stage1/elna' => FileList['boot/stage1/source/*'].map { |file|
@ -28,10 +28,10 @@ file 'build/stage1/elna' => FileList['boot/stage1/source/*'].map { |file|
sh M2C, '-o', t.name, *t.prerequisites sh M2C, '-o', t.name, *t.prerequisites
end end
file 'build/stage1/Compiler.o' => ['build/stage1', 'boot/stage1/source/Compiler.elna'] do |t| file 'build/stage1/Compiler.o' => ['build/stage1', 'boot/stage1/source/Compiler.mod'] do |t|
sources = t.prerequisites.filter { |f| f.end_with? '.elna' } sources = t.prerequisites.filter { |f| f.end_with? '.mod' }
sh M2C, '-fscaffold-main', '-fmod=.elna', '-c', '-I', 'boot/stage1/source', '-o', t.name, *sources sh M2C, '-fscaffold-main', '-c', '-I', 'boot/stage1/source', '-o', t.name, *sources
end end
['source', 'self'].each do |sub| ['source', 'self'].each do |sub|
@ -98,8 +98,10 @@ task :backport do
FileList['source/*.elna'].each do |file| FileList['source/*.elna'].each do |file|
source_path = Pathname.new file source_path = Pathname.new file
source = File.read source_path source = File.read source_path
current_procedure = nil
target = ''
target = source source
.gsub(/^(var|type|const|begin)/) { |match| match.upcase } .gsub(/^(var|type|const|begin)/) { |match| match.upcase }
.gsub(/^[[:alnum:]]* ?module/) { |match| match.upcase } .gsub(/^[[:alnum:]]* ?module/) { |match| match.upcase }
.gsub(/\brecord\b/) { |match| match.upcase } .gsub(/\brecord\b/) { |match| match.upcase }
@ -109,8 +111,22 @@ 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 }
.each_line do |line|
if line.start_with? 'PROCEDURE'
current_procedure = line[10...line.index('(')]
elsif line.start_with?('END;') && !current_procedure.nil?
line = "END #{current_procedure};"
current_proceure = nil
elsif line.start_with?('end')
line = 'END ' + line[4..]
end
target += line
end
target_path = Pathname.new('boot/stage1/source') + source_path.basename target_path = Pathname.new('boot/stage1/source') + source_path.basename.sub_ext('.mod')
File.write target_path, target File.write target_path, target
end end
FileList['source/*.def'].each do |file|
cp file, File.join('boot/stage1/source', Pathname.new(file).basename)
end
end end

14
source/Compiler.elna
View File

@ -3,16 +3,16 @@ module Compiler;
from FIO import StdIn; from FIO import StdIn;
from SYSTEM import ADR; from SYSTEM import ADR;
from Lexer import Lexer, LexerDestroy, LexerInitialize; from Lexer import Lexer, lexer_destroy, lexer_initialize;
from Transpiler import Transpile; from Transpiler import transpile;
var var
ALexer: Lexer; ALexer: Lexer;
BEGIN begin
LexerInitialize(ADR(ALexer), StdIn); lexer_initialize(ADR(ALexer), StdIn);
Transpile(ADR(ALexer)); transpile(ADR(ALexer));
LexerDestroy(ADR(ALexer)) lexer_destroy(ADR(ALexer))
END Compiler. end Compiler.

11
source/Lexer.def
View File

@ -80,16 +80,17 @@ TYPE
); );
LexerToken = RECORD LexerToken = RECORD
CASE Kind: LexerKind OF CASE Kind: LexerKind OF
lexerKindBoolean: booleanKind: BOOLEAN lexerKindBoolean: booleanKind: BOOLEAN |
lexerKindIdentifier: identifierKind: ARRAY[1..256] OF CHAR
END END
END; END;
PLexerToken = POINTER TO LexerToken; PLexerToken = POINTER TO LexerToken;
PROCEDURE LexerInitialize(ALexer: PLexer; Input: File); PROCEDURE lexer_initialize(ALexer: PLexer; Input: File);
PROCEDURE LexerDestroy(ALexer: PLexer); PROCEDURE lexer_destroy(ALexer: PLexer);
(* Returns the last read token. *) (* Returns the last read token. *)
PROCEDURE LexerCurrent(ALexer: PLexer): LexerToken; PROCEDURE lexer_current(ALexer: PLexer): LexerToken;
(* Read and return the next token. *) (* Read and return the next token. *)
PROCEDURE LexerLex(ALexer: PLexer): LexerToken; PROCEDURE lexer_lex(ALexer: PLexer): LexerToken;
END Lexer. END Lexer.

259
source/Lexer.elna
View File

@ -5,7 +5,7 @@ from SYSTEM import ADR;
from Storage import DEALLOCATE, ALLOCATE; from Storage import DEALLOCATE, ALLOCATE;
from Strings import Length; from Strings import Length;
from MemUtils import MemZero; from MemUtils import MemCopy, MemZero;
from StrCase import Lower; from StrCase import Lower;
const const
@ -70,7 +70,7 @@ var
Classification: ARRAY[1..128] OF TransitionClass; Classification: ARRAY[1..128] OF TransitionClass;
Transitions: ARRAY[0..15] OF ARRAY[0..21] OF Transition; Transitions: ARRAY[0..15] OF ARRAY[0..21] OF Transition;
proc InitializeClassification(); proc initialize_classification();
begin begin
Classification[1] := transitionClassEof; (* NUL *) Classification[1] := transitionClassEof; (* NUL *)
Classification[2] := transitionClassInvalid; (* SOH *) Classification[2] := transitionClassInvalid; (* SOH *)
@ -200,9 +200,9 @@ begin
Classification[126] := transitionClassOther; (* } *) Classification[126] := transitionClassOther; (* } *)
Classification[127] := transitionClassSingle; (* ~ *) Classification[127] := transitionClassSingle; (* ~ *)
Classification[128] := transitionClassInvalid (* DEL *) Classification[128] := transitionClassInvalid (* DEL *)
END InitializeClassification; end;
proc CompareKeyword(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;
@ -217,23 +217,23 @@ begin
end; end;
Result := (Index = Length(Keyword)) AND (TokenStart = TokenEnd) AND Result; Result := (Index = Length(Keyword)) AND (TokenStart = TokenEnd) AND Result;
return Result return Result
END CompareKeyword; end;
(* Reached the end of file. *) (* Reached the end of file. *)
proc TransitionActionEof(ALexer: PLexer; AToken: PLexerToken); proc transition_action_eof(ALexer: PLexer; AToken: PLexerToken);
begin begin
AToken^.Kind := lexerKindEof AToken^.Kind := lexerKindEof
END TransitionActionEof; 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 TransitionActionAccumulate(ALexer: PLexer; AToken: PLexerToken); proc transition_action_accumulate(ALexer: PLexer; AToken: PLexerToken);
begin begin
INC(ALexer^.Current) INC(ALexer^.Current)
END TransitionActionAccumulate; 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 TransitionActionFinalize(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
@ -253,10 +253,10 @@ begin
if ALexer^.Start^ = '.' then if ALexer^.Start^ = '.' then
AToken^.Kind := lexerKindDot AToken^.Kind := lexerKindDot
end end
END TransitionActionFinalize; end;
(* An action for tokens containing multiple characters. *) (* An action for tokens containing multiple characters. *)
proc TransitionActionComposite(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
@ -276,17 +276,17 @@ begin
AToken^.Kind := lexerKindAssignment AToken^.Kind := lexerKindAssignment
end; end;
INC(ALexer^.Current) INC(ALexer^.Current)
END TransitionActionComposite; end;
(* Skip a space. *) (* Skip a space. *)
proc TransitionActionSkip(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 TransitionActionSkip; end;
(* Delimited string action. *) (* Delimited string action. *)
proc TransitionActionDelimited(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
@ -298,113 +298,116 @@ begin
AToken^.Kind := lexerKindString AToken^.Kind := lexerKindString
end; end;
INC(ALexer^.Current) INC(ALexer^.Current)
END TransitionActionDelimited; end;
(* Finalize keyword or identifier. *) (* Finalize keyword or identifier. *)
proc TransitionActionKeyId(ALexer: PLexer; AToken: PLexerToken); proc transition_action_key_id(ALexer: PLexer; AToken: PLexerToken);
begin begin
AToken^.Kind := lexerKindIdentifier; AToken^.Kind := lexerKindIdentifier;
if CompareKeyword('PROGRAM', ALexer^.Start, ALexer^.Current) then AToken^.identifierKind[1] := ALexer^.Current - ALexer^.Start;
MemCopy(ALexer^.Start, ORD(AToken^.identifierKind[1]), ADR(AToken^.identifierKind[2]));
if compare_keyword('PROGRAM', ALexer^.Start, ALexer^.Current) then
AToken^.Kind := lexerKindProgram AToken^.Kind := lexerKindProgram
end; end;
if CompareKeyword('IMPORT', ALexer^.Start, ALexer^.Current) then if compare_keyword('IMPORT', ALexer^.Start, ALexer^.Current) then
AToken^.Kind := lexerKindImport AToken^.Kind := lexerKindImport
end; end;
if CompareKeyword('CONST', ALexer^.Start, ALexer^.Current) then if compare_keyword('CONST', ALexer^.Start, ALexer^.Current) then
AToken^.Kind := lexerKindConst AToken^.Kind := lexerKindConst
end; end;
if CompareKeyword('VAR', ALexer^.Start, ALexer^.Current) then if compare_keyword('VAR', ALexer^.Start, ALexer^.Current) then
AToken^.Kind := lexerKindVar AToken^.Kind := lexerKindVar
end; end;
if CompareKeyword('IF', ALexer^.Start, ALexer^.Current) then if compare_keyword('IF', ALexer^.Start, ALexer^.Current) then
AToken^.Kind := lexerKindIf AToken^.Kind := lexerKindIf
end; end;
if CompareKeyword('THEN', ALexer^.Start, ALexer^.Current) then if compare_keyword('THEN', ALexer^.Start, ALexer^.Current) then
AToken^.Kind := lexerKindThen AToken^.Kind := lexerKindThen
end; end;
if CompareKeyword('ELSIF', ALexer^.Start, ALexer^.Current) then if compare_keyword('ELSIF', ALexer^.Start, ALexer^.Current) then
AToken^.Kind := lexerKindElsif AToken^.Kind := lexerKindElsif
end; end;
if CompareKeyword('ELSE', ALexer^.Start, ALexer^.Current) then if compare_keyword('ELSE', ALexer^.Start, ALexer^.Current) then
AToken^.Kind := lexerKindElse AToken^.Kind := lexerKindElse
end; end;
if CompareKeyword('WHILE', ALexer^.Start, ALexer^.Current) then if compare_keyword('WHILE', ALexer^.Start, ALexer^.Current) then
AToken^.Kind := lexerKindWhile AToken^.Kind := lexerKindWhile
end; end;
if CompareKeyword('DO', ALexer^.Start, ALexer^.Current) then if compare_keyword('DO', ALexer^.Start, ALexer^.Current) then
AToken^.Kind := lexerKindDo AToken^.Kind := lexerKindDo
end; end;
if CompareKeyword('proc', ALexer^.Start, ALexer^.Current) then if compare_keyword('proc', ALexer^.Start, ALexer^.Current) then
AToken^.Kind := lexerKindProc AToken^.Kind := lexerKindProc
end; end;
if CompareKeyword('BEGIN', ALexer^.Start, ALexer^.Current) then if compare_keyword('BEGIN', ALexer^.Start, ALexer^.Current) then
AToken^.Kind := lexerKindBegin AToken^.Kind := lexerKindBegin
end; end;
if CompareKeyword('END', ALexer^.Start, ALexer^.Current) then if compare_keyword('END', ALexer^.Start, ALexer^.Current) then
AToken^.Kind := lexerKindEnd AToken^.Kind := lexerKindEnd
end; end;
if CompareKeyword('TYPE', ALexer^.Start, ALexer^.Current) then if compare_keyword('TYPE', ALexer^.Start, ALexer^.Current) then
AToken^.Kind := lexerKindType AToken^.Kind := lexerKindType
end; end;
if CompareKeyword('RECORD', ALexer^.Start, ALexer^.Current) then if compare_keyword('RECORD', ALexer^.Start, ALexer^.Current) then
AToken^.Kind := lexerKindRecord AToken^.Kind := lexerKindRecord
end; end;
if CompareKeyword('UNION', ALexer^.Start, ALexer^.Current) then if compare_keyword('UNION', ALexer^.Start, ALexer^.Current) then
AToken^.Kind := lexerKindUnion AToken^.Kind := lexerKindUnion
end; end;
if CompareKeyword('NIL', ALexer^.Start, ALexer^.Current) then if compare_keyword('NIL', ALexer^.Start, ALexer^.Current) then
AToken^.Kind := lexerKindNull AToken^.Kind := lexerKindNull
end; end;
if CompareKeyword('AND', ALexer^.Start, ALexer^.Current) then if compare_keyword('AND', ALexer^.Start, ALexer^.Current) then
AToken^.Kind := lexerKindAnd AToken^.Kind := lexerKindAnd
end; end;
if CompareKeyword('OR', ALexer^.Start, ALexer^.Current) then if compare_keyword('OR', ALexer^.Start, ALexer^.Current) then
AToken^.Kind := lexerKindOr AToken^.Kind := lexerKindOr
end; end;
if CompareKeyword('RETURN', ALexer^.Start, ALexer^.Current) then if compare_keyword('RETURN', ALexer^.Start, ALexer^.Current) then
AToken^.Kind := lexerKindReturn AToken^.Kind := lexerKindReturn
end; end;
if CompareKeyword('DEFINITION', ALexer^.Start, ALexer^.Current) then if compare_keyword('DEFINITION', ALexer^.Start, ALexer^.Current) then
AToken^.Kind := lexerKindDefinition AToken^.Kind := lexerKindDefinition
end; end;
if CompareKeyword('TO', ALexer^.Start, ALexer^.Current) then if compare_keyword('TO', ALexer^.Start, ALexer^.Current) then
AToken^.Kind := lexerKindTo AToken^.Kind := lexerKindTo
end; end;
if CompareKeyword('CASE', ALexer^.Start, ALexer^.Current) then if compare_keyword('CASE', ALexer^.Start, ALexer^.Current) then
AToken^.Kind := lexerKindCase AToken^.Kind := lexerKindCase
end; end;
if CompareKeyword('OF', ALexer^.Start, ALexer^.Current) then if compare_keyword('OF', ALexer^.Start, ALexer^.Current) then
AToken^.Kind := lexerKindOf AToken^.Kind := lexerKindOf
end; end;
if CompareKeyword('FROM', ALexer^.Start, ALexer^.Current) then if compare_keyword('FROM', ALexer^.Start, ALexer^.Current) then
AToken^.Kind := lexerKindFrom AToken^.Kind := lexerKindFrom
end; end;
if CompareKeyword('MODULE', ALexer^.Start, ALexer^.Current) then if compare_keyword('MODULE', ALexer^.Start, ALexer^.Current) then
AToken^.Kind := lexerKindModule AToken^.Kind := lexerKindModule
end; end;
if CompareKeyword('IMPLEMENTATION', ALexer^.Start, ALexer^.Current) then if compare_keyword('IMPLEMENTATION', ALexer^.Start, ALexer^.Current) then
AToken^.Kind := lexerKindImplementation AToken^.Kind := lexerKindImplementation
end; end;
if CompareKeyword('POINTER', ALexer^.Start, ALexer^.Current) then if compare_keyword('POINTER', ALexer^.Start, ALexer^.Current) then
AToken^.Kind := lexerKindPointer AToken^.Kind := lexerKindPointer
end; end;
if CompareKeyword('ARRAY', ALexer^.Start, ALexer^.Current) then if compare_keyword('ARRAY', ALexer^.Start, ALexer^.Current) then
AToken^.Kind := lexerKindArray AToken^.Kind := lexerKindArray
end; end;
if CompareKeyword('TRUE', ALexer^.Start, ALexer^.Current) then if compare_keyword('TRUE', ALexer^.Start, ALexer^.Current) then
AToken^.Kind := lexerKindBoolean; AToken^.Kind := lexerKindBoolean;
AToken^.booleanKind := TRUE AToken^.booleanKind := TRUE
end; end;
if CompareKeyword('FALSE', ALexer^.Start, ALexer^.Current) then if compare_keyword('FALSE', ALexer^.Start, ALexer^.Current) then
AToken^.Kind := lexerKindBoolean; AToken^.Kind := lexerKindBoolean;
AToken^.booleanKind := FALSE AToken^.booleanKind := FALSE
end end
END TransitionActionKeyId; 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 TransitionActionSingle(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
@ -449,15 +452,15 @@ begin
AToken^.Kind := lexerKindPipe AToken^.Kind := lexerKindPipe
end; end;
INC(ALexer^.Current) INC(ALexer^.Current)
END TransitionActionSingle; end;
(* Handle an integer literal. *) (* Handle an integer literal. *)
proc TransitionActionInteger(ALexer: PLexer; AToken: PLexerToken); proc transition_action_integer(ALexer: PLexer; AToken: PLexerToken);
begin begin
AToken^.Kind := lexerKindInteger AToken^.Kind := lexerKindInteger
END TransitionActionInteger; end;
proc SetDefaultTransition(CurrentState: TransitionState; DefaultAction: TransitionAction; NextState: TransitionState); proc set_default_transition(CurrentState: TransitionState; DefaultAction: TransitionAction; NextState: TransitionState);
var var
DefaultTransition: Transition; DefaultTransition: Transition;
begin begin
@ -486,7 +489,7 @@ begin
Transitions[ORD(CurrentState)][ORD(transitionClassGreater)] := DefaultTransition; Transitions[ORD(CurrentState)][ORD(transitionClassGreater)] := DefaultTransition;
Transitions[ORD(CurrentState)][ORD(transitionClassLess)] := DefaultTransition; Transitions[ORD(CurrentState)][ORD(transitionClassLess)] := DefaultTransition;
Transitions[ORD(CurrentState)][ORD(transitionClassOther)] := DefaultTransition Transitions[ORD(CurrentState)][ORD(transitionClassOther)] := DefaultTransition
END SetDefaultTransition; end;
(* (*
* The transition table describes transitions from one state to another, given * The transition table describes transitions from one state to another, given
@ -504,182 +507,182 @@ END SetDefaultTransition;
* For the meaning of actions see labels in the lex_next function, which * For the meaning of actions see labels in the lex_next function, which
* handles each action. * handles each action.
*) *)
proc InitializeTransitions(); proc initialize_transitions();
begin begin
(* Start state. *) (* Start state. *)
Transitions[ORD(transitionStateStart)][ORD(transitionClassInvalid)].Action := NIL; Transitions[ORD(transitionStateStart)][ORD(transitionClassInvalid)].Action := NIL;
Transitions[ORD(transitionStateStart)][ORD(transitionClassInvalid)].NextState := transitionStateEnd; Transitions[ORD(transitionStateStart)][ORD(transitionClassInvalid)].NextState := transitionStateEnd;
Transitions[ORD(transitionStateStart)][ORD(transitionClassDigit)].Action := TransitionActionAccumulate; Transitions[ORD(transitionStateStart)][ORD(transitionClassDigit)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateStart)][ORD(transitionClassDigit)].NextState := transitionStateDecimal; Transitions[ORD(transitionStateStart)][ORD(transitionClassDigit)].NextState := transitionStateDecimal;
Transitions[ORD(transitionStateStart)][ORD(transitionClassAlpha)].Action := TransitionActionAccumulate; Transitions[ORD(transitionStateStart)][ORD(transitionClassAlpha)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateStart)][ORD(transitionClassAlpha)].NextState := transitionStateIdentifier; Transitions[ORD(transitionStateStart)][ORD(transitionClassAlpha)].NextState := transitionStateIdentifier;
Transitions[ORD(transitionStateStart)][ORD(transitionClassSpace)].Action := TransitionActionSkip; Transitions[ORD(transitionStateStart)][ORD(transitionClassSpace)].Action := transition_action_skip;
Transitions[ORD(transitionStateStart)][ORD(transitionClassSpace)].NextState := transitionStateStart; Transitions[ORD(transitionStateStart)][ORD(transitionClassSpace)].NextState := transitionStateStart;
Transitions[ORD(transitionStateStart)][ORD(transitionClassColon)].Action := TransitionActionAccumulate; Transitions[ORD(transitionStateStart)][ORD(transitionClassColon)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateStart)][ORD(transitionClassColon)].NextState := transitionStateColon; Transitions[ORD(transitionStateStart)][ORD(transitionClassColon)].NextState := transitionStateColon;
Transitions[ORD(transitionStateStart)][ORD(transitionClassEquals)].Action := TransitionActionSingle; Transitions[ORD(transitionStateStart)][ORD(transitionClassEquals)].Action := transition_action_single;
Transitions[ORD(transitionStateStart)][ORD(transitionClassEquals)].NextState := transitionStateEnd; Transitions[ORD(transitionStateStart)][ORD(transitionClassEquals)].NextState := transitionStateEnd;
Transitions[ORD(transitionStateStart)][ORD(transitionClassLeftParen)].Action := TransitionActionAccumulate; Transitions[ORD(transitionStateStart)][ORD(transitionClassLeftParen)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateStart)][ORD(transitionClassLeftParen)].NextState := transitionStateLeftParen; Transitions[ORD(transitionStateStart)][ORD(transitionClassLeftParen)].NextState := transitionStateLeftParen;
Transitions[ORD(transitionStateStart)][ORD(transitionClassRightParen)].Action := TransitionActionSingle; Transitions[ORD(transitionStateStart)][ORD(transitionClassRightParen)].Action := transition_action_single;
Transitions[ORD(transitionStateStart)][ORD(transitionClassRightParen)].NextState := transitionStateEnd; Transitions[ORD(transitionStateStart)][ORD(transitionClassRightParen)].NextState := transitionStateEnd;
Transitions[ORD(transitionStateStart)][ORD(transitionClassAsterisk)].Action := TransitionActionSingle; Transitions[ORD(transitionStateStart)][ORD(transitionClassAsterisk)].Action := transition_action_single;
Transitions[ORD(transitionStateStart)][ORD(transitionClassAsterisk)].NextState := transitionStateEnd; Transitions[ORD(transitionStateStart)][ORD(transitionClassAsterisk)].NextState := transitionStateEnd;
Transitions[ORD(transitionStateStart)][ORD(transitionClassUnderscore)].Action := TransitionActionAccumulate; Transitions[ORD(transitionStateStart)][ORD(transitionClassUnderscore)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateStart)][ORD(transitionClassUnderscore)].NextState := transitionStateIdentifier; Transitions[ORD(transitionStateStart)][ORD(transitionClassUnderscore)].NextState := transitionStateIdentifier;
Transitions[ORD(transitionStateStart)][ORD(transitionClassSingle)].Action := TransitionActionSingle; Transitions[ORD(transitionStateStart)][ORD(transitionClassSingle)].Action := transition_action_single;
Transitions[ORD(transitionStateStart)][ORD(transitionClassSingle)].NextState := transitionStateEnd; Transitions[ORD(transitionStateStart)][ORD(transitionClassSingle)].NextState := transitionStateEnd;
Transitions[ORD(transitionStateStart)][ORD(transitionClassHex)].Action := TransitionActionAccumulate; Transitions[ORD(transitionStateStart)][ORD(transitionClassHex)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateStart)][ORD(transitionClassHex)].NextState := transitionStateIdentifier; Transitions[ORD(transitionStateStart)][ORD(transitionClassHex)].NextState := transitionStateIdentifier;
Transitions[ORD(transitionStateStart)][ORD(transitionClassZero)].Action := TransitionActionAccumulate; Transitions[ORD(transitionStateStart)][ORD(transitionClassZero)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateStart)][ORD(transitionClassZero)].NextState := transitionStateLeadingZero; Transitions[ORD(transitionStateStart)][ORD(transitionClassZero)].NextState := transitionStateLeadingZero;
Transitions[ORD(transitionStateStart)][ORD(transitionClassX)].Action := TransitionActionAccumulate; Transitions[ORD(transitionStateStart)][ORD(transitionClassX)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateStart)][ORD(transitionClassX)].NextState := transitionStateIdentifier; Transitions[ORD(transitionStateStart)][ORD(transitionClassX)].NextState := transitionStateIdentifier;
Transitions[ORD(transitionStateStart)][ORD(transitionClassEof)].Action := TransitionActionEof; Transitions[ORD(transitionStateStart)][ORD(transitionClassEof)].Action := transition_action_eof;
Transitions[ORD(transitionStateStart)][ORD(transitionClassEof)].NextState := transitionStateEnd; Transitions[ORD(transitionStateStart)][ORD(transitionClassEof)].NextState := transitionStateEnd;
Transitions[ORD(transitionStateStart)][ORD(transitionClassDot)].Action := TransitionActionAccumulate; Transitions[ORD(transitionStateStart)][ORD(transitionClassDot)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateStart)][ORD(transitionClassDot)].NextState := transitionStateDot; Transitions[ORD(transitionStateStart)][ORD(transitionClassDot)].NextState := transitionStateDot;
Transitions[ORD(transitionStateStart)][ORD(transitionClassMinus)].Action := TransitionActionAccumulate; Transitions[ORD(transitionStateStart)][ORD(transitionClassMinus)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateStart)][ORD(transitionClassMinus)].NextState := transitionStateMinus; Transitions[ORD(transitionStateStart)][ORD(transitionClassMinus)].NextState := transitionStateMinus;
Transitions[ORD(transitionStateStart)][ORD(transitionClassSingleQuote)].Action := TransitionActionAccumulate; Transitions[ORD(transitionStateStart)][ORD(transitionClassSingleQuote)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateStart)][ORD(transitionClassSingleQuote)].NextState := transitionStateCharacter; Transitions[ORD(transitionStateStart)][ORD(transitionClassSingleQuote)].NextState := transitionStateCharacter;
Transitions[ORD(transitionStateStart)][ORD(transitionClassDoubleQuote)].Action := TransitionActionAccumulate; Transitions[ORD(transitionStateStart)][ORD(transitionClassDoubleQuote)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateStart)][ORD(transitionClassDoubleQuote)].NextState := transitionStateString; Transitions[ORD(transitionStateStart)][ORD(transitionClassDoubleQuote)].NextState := transitionStateString;
Transitions[ORD(transitionStateStart)][ORD(transitionClassGreater)].Action := TransitionActionAccumulate; Transitions[ORD(transitionStateStart)][ORD(transitionClassGreater)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateStart)][ORD(transitionClassGreater)].NextState := transitionStateGreater; Transitions[ORD(transitionStateStart)][ORD(transitionClassGreater)].NextState := transitionStateGreater;
Transitions[ORD(transitionStateStart)][ORD(transitionClassLess)].Action := TransitionActionAccumulate; Transitions[ORD(transitionStateStart)][ORD(transitionClassLess)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateStart)][ORD(transitionClassLess)].NextState := transitionStateLess; Transitions[ORD(transitionStateStart)][ORD(transitionClassLess)].NextState := transitionStateLess;
Transitions[ORD(transitionStateStart)][ORD(transitionClassOther)].Action := NIL; Transitions[ORD(transitionStateStart)][ORD(transitionClassOther)].Action := NIL;
Transitions[ORD(transitionStateStart)][ORD(transitionClassOther)].NextState := transitionStateEnd; Transitions[ORD(transitionStateStart)][ORD(transitionClassOther)].NextState := transitionStateEnd;
(* Colon state. *) (* Colon state. *)
SetDefaultTransition(transitionStateColon, TransitionActionFinalize, transitionStateEnd); set_default_transition(transitionStateColon, transition_action_finalize, transitionStateEnd);
Transitions[ORD(transitionStateColon)][ORD(transitionClassEquals)].Action := TransitionActionComposite; Transitions[ORD(transitionStateColon)][ORD(transitionClassEquals)].Action := transition_action_composite;
Transitions[ORD(transitionStateColon)][ORD(transitionClassEquals)].NextState := transitionStateEnd; Transitions[ORD(transitionStateColon)][ORD(transitionClassEquals)].NextState := transitionStateEnd;
(* Identifier state. *) (* Identifier state. *)
SetDefaultTransition(transitionStateIdentifier, TransitionActionKeyId, transitionStateEnd); set_default_transition(transitionStateIdentifier, transition_action_key_id, transitionStateEnd);
Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassDigit)].Action := TransitionActionAccumulate; Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassDigit)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassDigit)].NextState := transitionStateIdentifier; Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassDigit)].NextState := transitionStateIdentifier;
Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassAlpha)].Action := TransitionActionAccumulate; Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassAlpha)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassAlpha)].NextState := transitionStateIdentifier; Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassAlpha)].NextState := transitionStateIdentifier;
Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassUnderscore)].Action := TransitionActionAccumulate; Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassUnderscore)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassUnderscore)].NextState := transitionStateIdentifier; Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassUnderscore)].NextState := transitionStateIdentifier;
Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassHex)].Action := TransitionActionAccumulate; Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassHex)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassHex)].NextState := transitionStateIdentifier; Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassHex)].NextState := transitionStateIdentifier;
Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassZero)].Action := TransitionActionAccumulate; Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassZero)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassZero)].NextState := transitionStateIdentifier; Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassZero)].NextState := transitionStateIdentifier;
Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassX)].Action := TransitionActionAccumulate; Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassX)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassX)].NextState := transitionStateIdentifier; Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassX)].NextState := transitionStateIdentifier;
(* Decimal state. *) (* Decimal state. *)
SetDefaultTransition(transitionStateDecimal, TransitionActionInteger, transitionStateEnd); set_default_transition(transitionStateDecimal, transition_action_integer, transitionStateEnd);
Transitions[ORD(transitionStateDecimal)][ORD(transitionClassDigit)].Action := TransitionActionAccumulate; Transitions[ORD(transitionStateDecimal)][ORD(transitionClassDigit)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateDecimal)][ORD(transitionClassDigit)].NextState := transitionStateDecimal; Transitions[ORD(transitionStateDecimal)][ORD(transitionClassDigit)].NextState := transitionStateDecimal;
Transitions[ORD(transitionStateDecimal)][ORD(transitionClassAlpha)].Action := TransitionActionAccumulate; Transitions[ORD(transitionStateDecimal)][ORD(transitionClassAlpha)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateDecimal)][ORD(transitionClassAlpha)].NextState := transitionStateDecimalSuffix; Transitions[ORD(transitionStateDecimal)][ORD(transitionClassAlpha)].NextState := transitionStateDecimalSuffix;
Transitions[ORD(transitionStateDecimal)][ORD(transitionClassUnderscore)].Action := NIL; Transitions[ORD(transitionStateDecimal)][ORD(transitionClassUnderscore)].Action := NIL;
Transitions[ORD(transitionStateDecimal)][ORD(transitionClassUnderscore)].NextState := transitionStateEnd; Transitions[ORD(transitionStateDecimal)][ORD(transitionClassUnderscore)].NextState := transitionStateEnd;
Transitions[ORD(transitionStateDecimal)][ORD(transitionClassHex)].Action := TransitionActionAccumulate; Transitions[ORD(transitionStateDecimal)][ORD(transitionClassHex)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateDecimal)][ORD(transitionClassHex)].NextState := transitionStateDecimalSuffix; Transitions[ORD(transitionStateDecimal)][ORD(transitionClassHex)].NextState := transitionStateDecimalSuffix;
Transitions[ORD(transitionStateDecimal)][ORD(transitionClassZero)].Action := TransitionActionAccumulate; Transitions[ORD(transitionStateDecimal)][ORD(transitionClassZero)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateDecimal)][ORD(transitionClassZero)].NextState := transitionStateDecimal; Transitions[ORD(transitionStateDecimal)][ORD(transitionClassZero)].NextState := transitionStateDecimal;
Transitions[ORD(transitionStateDecimal)][ORD(transitionClassX)].Action := TransitionActionAccumulate; Transitions[ORD(transitionStateDecimal)][ORD(transitionClassX)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateDecimal)][ORD(transitionClassX)].NextState := transitionStateDecimalSuffix; Transitions[ORD(transitionStateDecimal)][ORD(transitionClassX)].NextState := transitionStateDecimalSuffix;
(* Greater state. *) (* Greater state. *)
SetDefaultTransition(transitionStateGreater, TransitionActionFinalize, transitionStateEnd); set_default_transition(transitionStateGreater, transition_action_finalize, transitionStateEnd);
Transitions[ORD(transitionStateGreater)][ORD(transitionClassEquals)].Action := TransitionActionComposite; Transitions[ORD(transitionStateGreater)][ORD(transitionClassEquals)].Action := transition_action_composite;
Transitions[ORD(transitionStateGreater)][ORD(transitionClassEquals)].NextState := transitionStateEnd; Transitions[ORD(transitionStateGreater)][ORD(transitionClassEquals)].NextState := transitionStateEnd;
(* Minus state. *) (* Minus state. *)
SetDefaultTransition(transitionStateMinus, TransitionActionFinalize, transitionStateEnd); set_default_transition(transitionStateMinus, transition_action_finalize, transitionStateEnd);
Transitions[ORD(transitionStateMinus)][ORD(transitionClassGreater)].Action := TransitionActionComposite; Transitions[ORD(transitionStateMinus)][ORD(transitionClassGreater)].Action := transition_action_composite;
Transitions[ORD(transitionStateMinus)][ORD(transitionClassGreater)].NextState := transitionStateEnd; Transitions[ORD(transitionStateMinus)][ORD(transitionClassGreater)].NextState := transitionStateEnd;
(* Left paren state. *) (* Left paren state. *)
SetDefaultTransition(transitionStateLeftParen, TransitionActionFinalize, transitionStateEnd); set_default_transition(transitionStateLeftParen, transition_action_finalize, transitionStateEnd);
Transitions[ORD(transitionStateLeftParen)][ORD(transitionClassAsterisk)].Action := TransitionActionAccumulate; Transitions[ORD(transitionStateLeftParen)][ORD(transitionClassAsterisk)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateLeftParen)][ORD(transitionClassAsterisk)].NextState := transitionStateComment; Transitions[ORD(transitionStateLeftParen)][ORD(transitionClassAsterisk)].NextState := transitionStateComment;
(* Less state. *) (* Less state. *)
SetDefaultTransition(transitionStateLess, TransitionActionFinalize, transitionStateEnd); set_default_transition(transitionStateLess, transition_action_finalize, transitionStateEnd);
Transitions[ORD(transitionStateLess)][ORD(transitionClassEquals)].Action := TransitionActionComposite; Transitions[ORD(transitionStateLess)][ORD(transitionClassEquals)].Action := transition_action_composite;
Transitions[ORD(transitionStateLess)][ORD(transitionClassEquals)].NextState := transitionStateEnd; Transitions[ORD(transitionStateLess)][ORD(transitionClassEquals)].NextState := transitionStateEnd;
Transitions[ORD(transitionStateLess)][ORD(transitionClassGreater)].Action := TransitionActionComposite; Transitions[ORD(transitionStateLess)][ORD(transitionClassGreater)].Action := transition_action_composite;
Transitions[ORD(transitionStateLess)][ORD(transitionClassGreater)].NextState := transitionStateEnd; Transitions[ORD(transitionStateLess)][ORD(transitionClassGreater)].NextState := transitionStateEnd;
(* Hexadecimal after 0x. *) (* Hexadecimal after 0x. *)
SetDefaultTransition(transitionStateDot, TransitionActionFinalize, transitionStateEnd); set_default_transition(transitionStateDot, transition_action_finalize, transitionStateEnd);
Transitions[ORD(transitionStateDot)][ORD(transitionClassDot)].Action := TransitionActionComposite; Transitions[ORD(transitionStateDot)][ORD(transitionClassDot)].Action := transition_action_composite;
Transitions[ORD(transitionStateDot)][ORD(transitionClassDot)].NextState := transitionStateEnd; Transitions[ORD(transitionStateDot)][ORD(transitionClassDot)].NextState := transitionStateEnd;
(* Comment. *) (* Comment. *)
SetDefaultTransition(transitionStateComment, TransitionActionAccumulate, transitionStateComment); set_default_transition(transitionStateComment, transition_action_accumulate, transitionStateComment);
Transitions[ORD(transitionStateComment)][ORD(transitionClassAsterisk)].Action := TransitionActionAccumulate; Transitions[ORD(transitionStateComment)][ORD(transitionClassAsterisk)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateComment)][ORD(transitionClassAsterisk)].NextState := transitionStateClosingComment; Transitions[ORD(transitionStateComment)][ORD(transitionClassAsterisk)].NextState := transitionStateClosingComment;
Transitions[ORD(transitionStateComment)][ORD(transitionClassEof)].Action := NIL; Transitions[ORD(transitionStateComment)][ORD(transitionClassEof)].Action := NIL;
Transitions[ORD(transitionStateComment)][ORD(transitionClassEof)].NextState := transitionStateEnd; Transitions[ORD(transitionStateComment)][ORD(transitionClassEof)].NextState := transitionStateEnd;
(* Closing comment. *) (* Closing comment. *)
SetDefaultTransition(transitionStateClosingComment, TransitionActionAccumulate, transitionStateComment); set_default_transition(transitionStateClosingComment, transition_action_accumulate, transitionStateComment);
Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassInvalid)].Action := NIL; Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassInvalid)].Action := NIL;
Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassInvalid)].NextState := transitionStateEnd; Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassInvalid)].NextState := transitionStateEnd;
Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassRightParen)].Action := TransitionActionDelimited; Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassRightParen)].Action := transition_action_delimited;
Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassRightParen)].NextState := transitionStateEnd; Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassRightParen)].NextState := transitionStateEnd;
Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassAsterisk)].Action := TransitionActionAccumulate; Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassAsterisk)].Action := transition_action_accumulate;
Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassAsterisk)].NextState := transitionStateClosingComment; Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassAsterisk)].NextState := transitionStateClosingComment;
Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassEof)].Action := NIL; Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassEof)].Action := NIL;
Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassEof)].NextState := transitionStateEnd; Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassEof)].NextState := transitionStateEnd;
(* Character. *) (* Character. *)
SetDefaultTransition(transitionStateCharacter, TransitionActionAccumulate, transitionStateCharacter); set_default_transition(transitionStateCharacter, transition_action_accumulate, transitionStateCharacter);
Transitions[ORD(transitionStateCharacter)][ORD(transitionClassInvalid)].Action := NIL; Transitions[ORD(transitionStateCharacter)][ORD(transitionClassInvalid)].Action := NIL;
Transitions[ORD(transitionStateCharacter)][ORD(transitionClassInvalid)].NextState := transitionStateEnd; Transitions[ORD(transitionStateCharacter)][ORD(transitionClassInvalid)].NextState := transitionStateEnd;
@ -687,11 +690,11 @@ begin
Transitions[ORD(transitionStateCharacter)][ORD(transitionClassEof)].Action := NIL; Transitions[ORD(transitionStateCharacter)][ORD(transitionClassEof)].Action := NIL;
Transitions[ORD(transitionStateCharacter)][ORD(transitionClassEof)].NextState := transitionStateEnd; Transitions[ORD(transitionStateCharacter)][ORD(transitionClassEof)].NextState := transitionStateEnd;
Transitions[ORD(transitionStateCharacter)][ORD(transitionClassSingleQuote)].Action := TransitionActionDelimited; Transitions[ORD(transitionStateCharacter)][ORD(transitionClassSingleQuote)].Action := transition_action_delimited;
Transitions[ORD(transitionStateCharacter)][ORD(transitionClassSingleQuote)].NextState := transitionStateEnd; Transitions[ORD(transitionStateCharacter)][ORD(transitionClassSingleQuote)].NextState := transitionStateEnd;
(* String. *) (* String. *)
SetDefaultTransition(transitionStateString, TransitionActionAccumulate, transitionStateString); set_default_transition(transitionStateString, transition_action_accumulate, transitionStateString);
Transitions[ORD(transitionStateString)][ORD(transitionClassInvalid)].Action := NIL; Transitions[ORD(transitionStateString)][ORD(transitionClassInvalid)].Action := NIL;
Transitions[ORD(transitionStateString)][ORD(transitionClassInvalid)].NextState := transitionStateEnd; Transitions[ORD(transitionStateString)][ORD(transitionClassInvalid)].NextState := transitionStateEnd;
@ -699,11 +702,11 @@ begin
Transitions[ORD(transitionStateString)][ORD(transitionClassEof)].Action := NIL; Transitions[ORD(transitionStateString)][ORD(transitionClassEof)].Action := NIL;
Transitions[ORD(transitionStateString)][ORD(transitionClassEof)].NextState := transitionStateEnd; Transitions[ORD(transitionStateString)][ORD(transitionClassEof)].NextState := transitionStateEnd;
Transitions[ORD(transitionStateString)][ORD(transitionClassDoubleQuote)].Action := TransitionActionDelimited; Transitions[ORD(transitionStateString)][ORD(transitionClassDoubleQuote)].Action := transition_action_delimited;
Transitions[ORD(transitionStateString)][ORD(transitionClassDoubleQuote)].NextState := transitionStateEnd; Transitions[ORD(transitionStateString)][ORD(transitionClassDoubleQuote)].NextState := transitionStateEnd;
(* Leading zero. *) (* Leading zero. *)
SetDefaultTransition(transitionStateLeadingZero, TransitionActionInteger, transitionStateEnd); set_default_transition(transitionStateLeadingZero, transition_action_integer, transitionStateEnd);
Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassDigit)].Action := NIL; Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassDigit)].Action := NIL;
Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassDigit)].NextState := transitionStateEnd; Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassDigit)].NextState := transitionStateEnd;
@ -724,7 +727,7 @@ begin
Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassX)].NextState := transitionStateEnd; Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassX)].NextState := transitionStateEnd;
(* Digit with a character suffix. *) (* Digit with a character suffix. *)
SetDefaultTransition(transitionStateDecimalSuffix, TransitionActionInteger, transitionStateEnd); set_default_transition(transitionStateDecimalSuffix, transition_action_integer, transitionStateEnd);
Transitions[ORD(transitionStateDecimalSuffix)][ORD(transitionClassAlpha)].Action := NIL; Transitions[ORD(transitionStateDecimalSuffix)][ORD(transitionClassAlpha)].Action := NIL;
Transitions[ORD(transitionStateDecimalSuffix)][ORD(transitionClassAlpha)].NextState := transitionStateEnd; Transitions[ORD(transitionStateDecimalSuffix)][ORD(transitionClassAlpha)].NextState := transitionStateEnd;
@ -740,9 +743,9 @@ begin
Transitions[ORD(transitionStateDecimalSuffix)][ORD(transitionClassX)].Action := NIL; Transitions[ORD(transitionStateDecimalSuffix)][ORD(transitionClassX)].Action := NIL;
Transitions[ORD(transitionStateDecimalSuffix)][ORD(transitionClassX)].NextState := transitionStateEnd Transitions[ORD(transitionStateDecimalSuffix)][ORD(transitionClassX)].NextState := transitionStateEnd
END InitializeTransitions; end;
proc LexerInitialize(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;
@ -750,9 +753,9 @@ begin
ALLOCATE(ALexer^.Buffer, ChunkSize); ALLOCATE(ALexer^.Buffer, ChunkSize);
MemZero(ALexer^.Buffer, ChunkSize); MemZero(ALexer^.Buffer, ChunkSize);
ALexer^.Size := ChunkSize ALexer^.Size := ChunkSize
END LexerInitialize; end;
proc LexerCurrent(ALexer: PLexer): LexerToken; proc lexer_current(ALexer: PLexer): LexerToken;
var var
CurrentClass: TransitionClass; CurrentClass: TransitionClass;
CurrentState: TransitionState; CurrentState: TransitionState;
@ -772,9 +775,9 @@ begin
CurrentState := CurrentTransition.NextState CurrentState := CurrentTransition.NextState
end; end;
return Result return Result
END LexerCurrent; end;
proc LexerLex(ALexer: PLexer): LexerToken; proc lexer_lex(ALexer: PLexer): LexerToken;
var var
Result: LexerToken; Result: LexerToken;
begin begin
@ -784,16 +787,16 @@ begin
end; end;
ALexer^.Start := ALexer^.Current; ALexer^.Start := ALexer^.Current;
Result := LexerCurrent(ALexer); Result := lexer_current(ALexer);
return Result return Result
END LexerLex; end;
proc LexerDestroy(ALexer: PLexer); proc lexer_destroy(ALexer: PLexer);
begin begin
DEALLOCATE(ALexer^.Buffer, ALexer^.Size) DEALLOCATE(ALexer^.Buffer, ALexer^.Size)
END LexerDestroy; end;
BEGIN begin
InitializeClassification(); initialize_classification();
InitializeTransitions() initialize_transitions()
END Lexer. end Lexer.

2
source/Transpiler.def
View File

@ -2,6 +2,6 @@ DEFINITION MODULE Transpiler;
FROM Lexer IMPORT PLexer; FROM Lexer IMPORT PLexer;
PROCEDURE Transpile(ALexer: PLexer); PROCEDURE transpile(ALexer: PLexer);
END Transpiler. END Transpiler.

469
source/Transpiler.elna
View File

@ -4,7 +4,7 @@ from FIO import WriteNBytes, StdOut;
from SYSTEM import ADR, ADDRESS; from SYSTEM import ADR, ADDRESS;
from Terminal import Write, WriteLn, WriteString; from Terminal import Write, WriteLn, WriteString;
from Lexer import Lexer, LexerToken, LexerCurrent, LexerLex, LexerKind; from Lexer import Lexer, LexerToken, lexer_current, lexer_lex, LexerKind;
type type
PTranspilerContext = ^TranspilerContext; PTranspilerContext = ^TranspilerContext;
@ -12,224 +12,228 @@ type
Indentation: CARDINAL Indentation: CARDINAL
end; end;
(* Calls LexerLex() but skips the comments. *) (* Calls lexer_lex() but skips the comments. *)
proc TranspilerLex(ALexer: PLexer): LexerToken; proc transpiler_lex(ALexer: PLexer): LexerToken;
var var
Result: LexerToken; Result: LexerToken;
begin begin
Result := LexerLex(ALexer); Result := lexer_lex(ALexer);
while Result.Kind = lexerKindComment do while Result.Kind = lexerKindComment do
Result := LexerLex(ALexer) Result := lexer_lex(ALexer)
end; end;
return Result return Result
END TranspilerLex; end;
(* Write a semicolon followed by a newline. *) (* Write a semicolon followed by a newline. *)
proc WriteSemicolon(); proc write_semicolon();
begin begin
WriteString(';'); WriteString(';');
WriteLn() WriteLn()
END WriteSemicolon; end;
proc TranspileImport(AContext: PTranspilerContext; ALexer: PLexer); proc transpile_import(AContext: PTranspilerContext; ALexer: PLexer);
var var
Token: LexerToken; Token: LexerToken;
WrittenBytes: CARDINAL; WrittenBytes: CARDINAL;
begin begin
WriteString('FROM '); WriteString('FROM ');
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
WriteString(' IMPORT '); WriteString(' IMPORT ');
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
while Token.Kind <> lexerKindSemicolon do while Token.Kind <> lexerKindSemicolon do
WriteString(', '); WriteString(', ');
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := TranspilerLex(ALexer) Token := transpiler_lex(ALexer)
end; end;
WriteSemicolon(); write_semicolon();
Token := TranspilerLex(ALexer) Token := transpiler_lex(ALexer)
END TranspileImport; end;
proc TranspileImportPart(AContext: PTranspilerContext; ALexer: PLexer); proc transpile_import_part(AContext: PTranspilerContext; ALexer: PLexer);
var var
Token: LexerToken; Token: LexerToken;
begin begin
Token := LexerCurrent(ALexer); Token := lexer_current(ALexer);
while Token.Kind = lexerKindFrom do while Token.Kind = lexerKindFrom do
TranspileImport(AContext, ALexer); transpile_import(AContext, ALexer);
Token := LexerCurrent(ALexer) Token := lexer_current(ALexer)
end; end;
WriteLn() WriteLn()
END TranspileImportPart; end;
proc TranspileConstant(AContext: PTranspilerContext; ALexer: PLexer); proc transpile_constant(AContext: PTranspilerContext; ALexer: PLexer);
var var
Token: LexerToken; Token: LexerToken;
WrittenBytes: CARDINAL; WrittenBytes: CARDINAL;
begin begin
WriteString(' '); WriteString(' ');
Token := LexerCurrent(ALexer); Token := lexer_current(ALexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
WriteString(' = '); WriteString(' = ');
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
WriteSemicolon() write_semicolon()
END TranspileConstant; end;
proc TranspileConstantPart(AContext: PTranspilerContext; ALexer: PLexer): BOOLEAN; proc transpile_constant_part(AContext: PTranspilerContext; ALexer: PLexer): BOOLEAN;
var var
Token: LexerToken; Token: LexerToken;
Result: BOOLEAN; Result: BOOLEAN;
begin begin
Token := LexerCurrent(ALexer); Token := lexer_current(ALexer);
Result := Token.Kind = lexerKindConst; Result := Token.Kind = lexerKindConst;
if Result then if Result then
WriteString('CONST'); WriteString('CONST');
WriteLn(); WriteLn();
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
while Token.Kind = lexerKindIdentifier do while Token.Kind = lexerKindIdentifier do
TranspileConstant(AContext, ALexer); transpile_constant(AContext, ALexer);
Token := TranspilerLex(ALexer) Token := transpiler_lex(ALexer)
end end
end; end;
return Result return Result
END TranspileConstantPart; end;
proc TranspileModule(AContext: PTranspilerContext; ALexer: PLexer); proc transpile_module(AContext: PTranspilerContext; ALexer: PLexer);
var var
Token: LexerToken; Token: LexerToken;
WrittenBytes: CARDINAL; WrittenBytes: CARDINAL;
begin begin
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
if Token.Kind = lexerKindDefinition then if Token.Kind = lexerKindDefinition then
WriteString('DEFINITION '); WriteString('DEFINITION ');
Token := TranspilerLex(ALexer) Token := transpiler_lex(ALexer)
end; end;
if Token.Kind = lexerKindImplementation then if Token.Kind = lexerKindImplementation then
WriteString('IMPLEMENTATION '); WriteString('IMPLEMENTATION ');
Token := TranspilerLex(ALexer) Token := transpiler_lex(ALexer)
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 := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
WriteSemicolon(); write_semicolon();
WriteLn(); WriteLn();
(* Write the module body. *) (* Write the module body. *)
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
TranspileImportPart(AContext, ALexer); transpile_import_part(AContext, ALexer);
if TranspileConstantPart(AContext, ALexer) then if transpile_constant_part(AContext, ALexer) then
WriteLn() WriteLn()
end; end;
TranspileTypePart(AContext, ALexer); transpile_type_part(AContext, ALexer);
if TranspileVariablePart(AContext, ALexer) then if transpile_variable_part(AContext, ALexer) then
WriteLn() WriteLn()
end; end;
TranspileProcedurePart(AContext, ALexer); transpile_procedure_part(AContext, ALexer);
transpile_statement_part(AContext, ALexer);
Token := LexerCurrent(ALexer); WriteString('END ');
while Token.Kind <> lexerKindEof do
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
WriteLn();
Token := TranspilerLex(ALexer) Token := transpiler_lex(ALexer);
end WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
END TranspileModule;
proc TranspileTypeFields(AContext: PTranspilerContext; ALexer: PLexer); Token := transpiler_lex(ALexer);
Write('.');
Token := transpiler_lex(ALexer);
WriteLn()
end;
proc transpile_type_fields(AContext: PTranspilerContext; ALexer: PLexer);
var var
Token: LexerToken; Token: LexerToken;
WrittenBytes: CARDINAL; WrittenBytes: CARDINAL;
begin begin
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
while Token.Kind <> lexerKindEnd do while Token.Kind <> lexerKindEnd do
WriteString(' '); WriteString(' ');
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
WriteString(': '); WriteString(': ');
TranspileTypeExpression(AContext, ALexer); transpile_type_expression(AContext, ALexer);
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
if Token.Kind = lexerKindSemicolon then if Token.Kind = lexerKindSemicolon then
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
Write(';') Write(';')
end; end;
WriteLn() WriteLn()
end end
END TranspileTypeFields; end;
proc TranspileRecordType(AContext: PTranspilerContext; ALexer: PLexer); proc transpile_record_type(AContext: PTranspilerContext; ALexer: PLexer);
var var
Token: LexerToken; Token: LexerToken;
begin begin
WriteString('RECORD'); WriteString('RECORD');
WriteLn(); WriteLn();
TranspileTypeFields(AContext, ALexer); transpile_type_fields(AContext, ALexer);
WriteString(' END') WriteString(' END')
END TranspileRecordType; end;
proc TranspilePointerType(AContext: PTranspilerContext; ALexer: PLexer); proc transpile_pointer_type(AContext: PTranspilerContext; ALexer: PLexer);
var var
Token: LexerToken; Token: LexerToken;
WrittenBytes: CARDINAL; WrittenBytes: CARDINAL;
begin begin
Token := LexerCurrent(ALexer); Token := lexer_current(ALexer);
WriteString('POINTER TO '); WriteString('POINTER TO ');
if Token.Kind = lexerKindPointer then if Token.Kind = lexerKindPointer then
Token := TranspilerLex(ALexer) Token := transpiler_lex(ALexer)
end; end;
TranspileTypeExpression(AContext, ALexer) transpile_type_expression(AContext, ALexer)
END TranspilePointerType; end;
proc TranspileArrayType(AContext: PTranspilerContext; ALexer: PLexer); proc transpile_array_type(AContext: PTranspilerContext; ALexer: PLexer);
var var
Token: LexerToken; Token: LexerToken;
WrittenBytes: CARDINAL; WrittenBytes: CARDINAL;
begin begin
WriteString('ARRAY'); WriteString('ARRAY');
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
if Token.Kind <> lexerKindOf then if Token.Kind <> lexerKindOf then
Write('['); Write('[');
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
WriteString('..'); WriteString('..');
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
Write(']'); Write(']');
Token := TranspilerLex(ALexer) Token := transpiler_lex(ALexer)
end; end;
WriteString(' OF '); WriteString(' OF ');
TranspileTypeExpression(AContext, ALexer) transpile_type_expression(AContext, ALexer)
END TranspileArrayType; end;
proc TranspileEnumerationType(AContext: PTranspilerContext; ALexer: PLexer); proc transpile_enumeration_type(AContext: PTranspilerContext; ALexer: PLexer);
var var
Token: LexerToken; Token: LexerToken;
WrittenBytes: CARDINAL; WrittenBytes: CARDINAL;
@ -238,393 +242,402 @@ begin
WriteLn(); WriteLn();
WriteString(' '); WriteString(' ');
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
while Token.Kind = lexerKindComma do while Token.Kind = lexerKindComma do
Write(','); Write(',');
WriteLn(); WriteLn();
WriteString(' '); WriteString(' ');
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := TranspilerLex(ALexer) Token := transpiler_lex(ALexer)
end; end;
WriteLn(); WriteLn();
WriteString(' )') WriteString(' )')
END TranspileEnumerationType; end;
proc TranspileUnionType(AContext: PTranspilerContext; ALexer: PLexer); proc transpile_union_type(AContext: PTranspilerContext; ALexer: PLexer);
var var
Token: LexerToken; Token: LexerToken;
END TranspileUnionType; end;
proc TranspileProcedureType(AContext: PTranspilerContext; ALexer: PLexer); proc transpile_procedure_type(AContext: PTranspilerContext; ALexer: PLexer);
var var
Token: LexerToken; Token: LexerToken;
WrittenBytes: CARDINAL; WrittenBytes: CARDINAL;
begin begin
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
WriteString('PROCEDURE('); WriteString('PROCEDURE(');
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
while Token.Kind <> lexerKindRightParen do while Token.Kind <> lexerKindRightParen do
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
if Token.Kind = lexerKindComma then if Token.Kind = lexerKindComma then
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
WriteString(', ') WriteString(', ')
end end
end; end;
Write(')') Write(')')
END TranspileProcedureType; end;
proc TranspileTypeExpression(AContext: PTranspilerContext; ALexer: PLexer); proc transpile_type_expression(AContext: PTranspilerContext; ALexer: PLexer);
var var
Token: LexerToken; Token: LexerToken;
WrittenBytes: CARDINAL; WrittenBytes: CARDINAL;
begin begin
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
if Token.Kind = lexerKindRecord then if Token.Kind = lexerKindRecord then
TranspileRecordType(AContext, ALexer) transpile_record_type(AContext, ALexer)
end; end;
if Token.Kind = lexerKindLeftParen then if Token.Kind = lexerKindLeftParen then
TranspileEnumerationType(AContext, ALexer) transpile_enumeration_type(AContext, ALexer)
end; end;
if Token.Kind = lexerKindArray then if Token.Kind = lexerKindArray then
TranspileArrayType(AContext, ALexer) transpile_array_type(AContext, ALexer)
end; end;
if (Token.Kind = lexerKindPointer) OR (Token.Kind = lexerKindHat) then if (Token.Kind = lexerKindPointer) OR (Token.Kind = lexerKindHat) then
TranspilePointerType(AContext, ALexer) transpile_pointer_type(AContext, ALexer)
end; end;
if Token.Kind = lexerKindProc then if Token.Kind = lexerKindProc then
TranspileProcedureType(AContext, ALexer) transpile_procedure_type(AContext, ALexer)
end; end;
if Token.Kind = lexerKindIdentifier then if Token.Kind = lexerKindIdentifier then
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start) WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start)
end end
END TranspileTypeExpression; end;
proc TranspileTypeDeclaration(AContext: PTranspilerContext; ALexer: PLexer); proc transpile_type_declaration(AContext: PTranspilerContext; ALexer: PLexer);
var var
Token: LexerToken; Token: LexerToken;
WrittenBytes: CARDINAL; WrittenBytes: CARDINAL;
begin begin
WriteString(' '); WriteString(' ');
Token := LexerCurrent(ALexer); Token := lexer_current(ALexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
WriteString(' = '); WriteString(' = ');
TranspileTypeExpression(AContext, ALexer); transpile_type_expression(AContext, ALexer);
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
WriteSemicolon(); write_semicolon();
END TranspileTypeDeclaration; end;
proc TranspileTypePart(AContext: PTranspilerContext; ALexer: PLexer); proc transpile_type_part(AContext: PTranspilerContext; ALexer: PLexer);
var var
Token: LexerToken; Token: LexerToken;
begin begin
Token := LexerCurrent(ALexer); Token := lexer_current(ALexer);
if Token.Kind = lexerKindType then if Token.Kind = lexerKindType then
WriteString('TYPE'); WriteString('TYPE');
WriteLn(); WriteLn();
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
while Token.Kind = lexerKindIdentifier do while Token.Kind = lexerKindIdentifier do
TranspileTypeDeclaration(AContext, ALexer); transpile_type_declaration(AContext, ALexer);
Token := TranspilerLex(ALexer) Token := transpiler_lex(ALexer)
end; end;
WriteLn() WriteLn()
end end
END TranspileTypePart; end;
proc TranspileVariableDeclaration(AContext: PTranspilerContext; ALexer: PLexer); proc transpile_variable_declaration(AContext: PTranspilerContext; ALexer: PLexer);
var var
Token: LexerToken; Token: LexerToken;
WrittenBytes: CARDINAL; WrittenBytes: CARDINAL;
begin begin
WriteString(' '); WriteString(' ');
Token := LexerCurrent(ALexer); Token := lexer_current(ALexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
WriteString(': '); WriteString(': ');
TranspileTypeExpression(AContext, ALexer); transpile_type_expression(AContext, ALexer);
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
WriteSemicolon() write_semicolon()
END TranspileVariableDeclaration; end;
proc TranspileVariablePart(AContext: PTranspilerContext; ALexer: PLexer): BOOLEAN; proc transpile_variable_part(AContext: PTranspilerContext; ALexer: PLexer): BOOLEAN;
var var
Token: LexerToken; Token: LexerToken;
Result: BOOLEAN; Result: BOOLEAN;
begin begin
Token := LexerCurrent(ALexer); Token := lexer_current(ALexer);
Result := Token.Kind = lexerKindVar; Result := Token.Kind = lexerKindVar;
if Result then if Result then
WriteString('VAR'); WriteString('VAR');
WriteLn(); WriteLn();
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
while Token.Kind = lexerKindIdentifier do while Token.Kind = lexerKindIdentifier do
TranspileVariableDeclaration(AContext, ALexer); transpile_variable_declaration(AContext, ALexer);
Token := TranspilerLex(ALexer) Token := transpiler_lex(ALexer)
end end
end; end;
return Result return Result
END TranspileVariablePart; end;
proc TranspileProcedureHeading(AContext: PTranspilerContext; ALexer: PLexer); proc transpile_procedure_heading(AContext: PTranspilerContext; ALexer: PLexer): LexerToken;
var var
Token: LexerToken; Token: LexerToken;
Result: LexerToken;
WrittenBytes: CARDINAL; WrittenBytes: CARDINAL;
begin begin
WriteString('PROCEDURE '); WriteString('PROCEDURE ');
Token := TranspilerLex(ALexer); Result := transpiler_lex(ALexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
Write('('); Write('(');
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
while Token.Kind <> lexerKindRightParen do while Token.Kind <> lexerKindRightParen do
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
WriteString(': '); WriteString(': ');
TranspileTypeExpression(AContext, ALexer); transpile_type_expression(AContext, ALexer);
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
if Token.Kind = lexerKindSemicolon then if Token.Kind = lexerKindSemicolon then
WriteString('; '); WriteString('; ');
Token := TranspilerLex(ALexer) Token := transpiler_lex(ALexer)
end end
end; end;
WriteString(')'); WriteString(')');
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
(* 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 := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := TranspilerLex(ALexer) Token := transpiler_lex(ALexer)
end; end;
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
WriteSemicolon() write_semicolon();
END TranspileProcedureHeading;
proc TranspileIfStatement(AContext: PTranspilerContext; ALexer: PLexer); return Result
end;
proc transpile_expression(AContext: PTranspilerContext; ALexer: PLexer; TrailingToken: LexerKind);
var
Token: LexerToken;
WrittenBytes: CARDINAL;
begin
Token := transpiler_lex(ALexer);
while (Token.Kind <> TrailingToken) AND (Token.Kind <> lexerKindEnd) do
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Write(' ');
Token := transpiler_lex(ALexer)
end
end;
proc transpile_if_statement(AContext: PTranspilerContext; ALexer: PLexer);
var var
Token: LexerToken; Token: LexerToken;
WrittenBytes: CARDINAL; WrittenBytes: CARDINAL;
begin begin
WriteString(' IF '); WriteString(' IF ');
Token := TranspilerLex(ALexer); transpile_expression(AContext, ALexer, lexerKindThen);
while Token.Kind <> lexerKindThen do
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Write(' ');
Token := TranspilerLex(ALexer)
end;
WriteString('THEN'); WriteString('THEN');
WriteLn(); WriteLn();
TranspileStatements(AContext, ALexer); transpile_statements(AContext, ALexer);
WriteString(' END'); WriteString(' END');
Token := TranspilerLex(ALexer) Token := transpiler_lex(ALexer)
END TranspileIfStatement; end;
proc TranspileWhileStatement(AContext: PTranspilerContext; ALexer: PLexer); proc transpile_while_statement(AContext: PTranspilerContext; ALexer: PLexer);
var var
Token: LexerToken; Token: LexerToken;
WrittenBytes: CARDINAL; WrittenBytes: CARDINAL;
begin begin
WriteString(' WHILE '); WriteString(' WHILE ');
Token := TranspilerLex(ALexer); transpile_expression(AContext, ALexer, lexerKindDo);
while Token.Kind <> lexerKindDo do
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Write(' ');
Token := TranspilerLex(ALexer)
end;
WriteString('DO'); WriteString('DO');
WriteLn(); WriteLn();
TranspileStatements(AContext, ALexer); transpile_statements(AContext, ALexer);
WriteString(' END'); WriteString(' END');
Token := TranspilerLex(ALexer) Token := transpiler_lex(ALexer)
END TranspileWhileStatement; end;
proc TranspileAssignmentStatement(AContext: PTranspilerContext; ALexer: PLexer); proc transpile_assignment_statement(AContext: PTranspilerContext; ALexer: PLexer);
var
Token: LexerToken;
WrittenBytes: CARDINAL;
begin begin
WriteString(' := '); WriteString(' := ');
Token := TranspilerLex(ALexer); transpile_expression(AContext, ALexer, lexerKindSemicolon);
end;
while (Token.Kind <> lexerKindSemicolon) AND (Token.Kind <> lexerKindEnd) do proc transpile_call_statement(AContext: PTranspilerContext; ALexer: PLexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Write(' ');
Token := TranspilerLex(ALexer)
end
END TranspileAssignmentStatement;
proc TranspileCallStatement(AContext: PTranspilerContext; ALexer: PLexer);
var var
Token: LexerToken; Token: LexerToken;
WrittenBytes: CARDINAL; WrittenBytes: CARDINAL;
begin begin
WriteString('('); WriteString('(');
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
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); WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := TranspilerLex(ALexer) Token := transpiler_lex(ALexer)
end end
END TranspileCallStatement; end;
proc TranspileReturnStatement(AContext: PTranspilerContext; ALexer: PLexer); proc transpile_return_statement(AContext: PTranspilerContext; ALexer: PLexer);
var var
Token: LexerToken; Token: LexerToken;
WrittenBytes: CARDINAL; WrittenBytes: CARDINAL;
begin begin
WriteString(' RETURN '); WriteString(' RETURN ');
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := TranspilerLex(ALexer) Token := transpiler_lex(ALexer)
END TranspileReturnStatement; end;
proc TranspileStatement(AContext: PTranspilerContext; ALexer: PLexer); proc transpile_statement(AContext: PTranspilerContext; ALexer: PLexer);
var var
Token: LexerToken; Token: LexerToken;
WrittenBytes: CARDINAL; WrittenBytes: CARDINAL;
begin begin
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
if Token.Kind = lexerKindIf then if Token.Kind = lexerKindIf then
TranspileIfStatement(AContext, ALexer) transpile_if_statement(AContext, ALexer)
end; end;
if Token.Kind = lexerKindWhile then if Token.Kind = lexerKindWhile then
TranspileWhileStatement(AContext, ALexer) transpile_while_statement(AContext, ALexer)
end; end;
if Token.Kind = lexerKindReturn then if Token.Kind = lexerKindReturn then
TranspileReturnStatement(AContext, ALexer) transpile_return_statement(AContext, ALexer)
end; end;
if Token.Kind = lexerKindIdentifier then if Token.Kind = lexerKindIdentifier then
WriteString(' '); WriteString(' ');
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
while Token.Kind = lexerKindLeftSquare do while Token.Kind = lexerKindLeftSquare do
Write('['); Write('[');
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
while Token.Kind <> lexerKindRightSquare do while Token.Kind <> lexerKindRightSquare do
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := TranspilerLex(ALexer) Token := transpiler_lex(ALexer)
end; end;
Write(']'); Write(']');
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
end; end;
if Token.Kind = lexerKindHat then if Token.Kind = lexerKindHat then
Write('^'); Write('^');
Token := TranspilerLex(ALexer) Token := transpiler_lex(ALexer)
end; end;
if Token.Kind = lexerKindDot then if Token.Kind = lexerKindDot then
Write('.'); Write('.');
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := TranspilerLex(ALexer); Token := transpiler_lex(ALexer);
end; end;
if Token.Kind = lexerKindHat then if Token.Kind = lexerKindHat then
Write('^'); Write('^');
Token := TranspilerLex(ALexer) Token := transpiler_lex(ALexer)
end;
while Token.Kind = lexerKindLeftSquare do
Write('[');
Token := transpiler_lex(ALexer);
while Token.Kind <> lexerKindRightSquare do
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := transpiler_lex(ALexer)
end;
Write(']');
Token := transpiler_lex(ALexer);
end; end;
if Token.Kind = lexerKindAssignment then if Token.Kind = lexerKindAssignment then
TranspileAssignmentStatement(AContext, ALexer) transpile_assignment_statement(AContext, ALexer)
end; end;
if Token.Kind = lexerKindLeftParen then if Token.Kind = lexerKindLeftParen then
TranspileCallStatement(AContext, ALexer) transpile_call_statement(AContext, ALexer)
end end
end end
END TranspileStatement; end;
proc TranspileStatements(AContext: PTranspilerContext; ALexer: PLexer); proc transpile_statements(AContext: PTranspilerContext; ALexer: PLexer);
var var
Token: LexerToken; Token: LexerToken;
begin begin
Token := LexerCurrent(ALexer); Token := lexer_current(ALexer);
while Token.Kind <> lexerKindEnd do while Token.Kind <> lexerKindEnd do
TranspileStatement(AContext, ALexer); transpile_statement(AContext, ALexer);
Token := LexerCurrent(ALexer); Token := lexer_current(ALexer);
if Token.Kind = lexerKindSemicolon then if Token.Kind = lexerKindSemicolon then
Write(';') Write(';')
end; end;
WriteLn() WriteLn()
end end
END TranspileStatements; end;
proc TranspileStatementPart(AContext: PTranspilerContext; ALexer: PLexer); proc transpile_statement_part(AContext: PTranspilerContext; ALexer: PLexer);
var var
Token: LexerToken; Token: LexerToken;
begin begin
Token := LexerCurrent(ALexer); Token := lexer_current(ALexer);
if Token.Kind = lexerKindBegin then if Token.Kind = lexerKindBegin then
WriteString('BEGIN'); WriteString('BEGIN');
WriteLn(); WriteLn();
TranspileStatements(AContext, ALexer) transpile_statements(AContext, ALexer)
end end
END TranspileStatementPart; end;
proc TranspileProcedureDeclaration(AContext: PTranspilerContext; ALexer: PLexer); proc transpile_procedure_declaration(AContext: PTranspilerContext; ALexer: PLexer);
var var
Token: LexerToken; Token: LexerToken;
SeenPart: BOOLEAN; SeenPart: BOOLEAN;
WrittenBytes: CARDINAL; WrittenBytes: CARDINAL;
begin begin
TranspileProcedureHeading(AContext, ALexer); Token := transpile_procedure_heading(AContext, ALexer);
SeenPart := TranspileConstantPart(AContext, ALexer); SeenPart := transpile_constant_part(AContext, ALexer);
SeenPart := TranspileVariablePart(AContext, ALexer); SeenPart := transpile_variable_part(AContext, ALexer);
TranspileStatementPart(AContext, ALexer); transpile_statement_part(AContext, ALexer);
WriteString('END ');
Token := TranspilerLex(ALexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := TranspilerLex(ALexer);
WriteSemicolon();
Token := TranspilerLex(ALexer)
END TranspileProcedureDeclaration;
proc TranspileProcedurePart(AContext: PTranspilerContext; ALexer: PLexer); WriteString('END ');
WrittenBytes := WriteNBytes(StdOut, ORD(Token.identifierKind[1]), ADR(Token.identifierKind[2]));
Token := transpiler_lex(ALexer);
write_semicolon();
Token := transpiler_lex(ALexer)
end;
proc transpile_procedure_part(AContext: PTranspilerContext; ALexer: PLexer);
var var
Token: LexerToken; Token: LexerToken;
begin begin
Token := LexerCurrent(ALexer); Token := lexer_current(ALexer);
while Token.Kind = lexerKindProc do while Token.Kind = lexerKindProc do
TranspileProcedureDeclaration(AContext, ALexer); transpile_procedure_declaration(AContext, ALexer);
Token := LexerCurrent(ALexer); Token := lexer_current(ALexer);
WriteLn() WriteLn()
end end
END TranspileProcedurePart; end;
proc Transpile(ALexer: PLexer); proc transpile(ALexer: PLexer);
var var
Token: LexerToken; Token: LexerToken;
WrittenBytes: CARDINAL; WrittenBytes: CARDINAL;
Context: TranspilerContext; Context: TranspilerContext;
begin begin
TranspileModule(ADR(Context), ALexer) transpile_module(ADR(Context), ALexer)
END Transpile; end;
END Transpiler. end Transpiler.