Make procedure name after the end
This commit is contained in:
32
Rakefile
32
Rakefile
@ -15,11 +15,11 @@ CLEAN.include 'build'
|
||||
rule(/build\/stage1\/.+\.o$/ => ->(file) {
|
||||
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|
|
||||
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
|
||||
|
||||
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
|
||||
end
|
||||
|
||||
file 'build/stage1/Compiler.o' => ['build/stage1', 'boot/stage1/source/Compiler.elna'] do |t|
|
||||
sources = t.prerequisites.filter { |f| f.end_with? '.elna' }
|
||||
file 'build/stage1/Compiler.o' => ['build/stage1', 'boot/stage1/source/Compiler.mod'] do |t|
|
||||
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
|
||||
|
||||
['source', 'self'].each do |sub|
|
||||
@ -98,8 +98,10 @@ task :backport do
|
||||
FileList['source/*.elna'].each do |file|
|
||||
source_path = Pathname.new file
|
||||
source = File.read source_path
|
||||
current_procedure = nil
|
||||
target = ''
|
||||
|
||||
target = source
|
||||
source
|
||||
.gsub(/^(var|type|const|begin)/) { |match| match.upcase }
|
||||
.gsub(/^[[:alnum:]]* ?module/) { |match| match.upcase }
|
||||
.gsub(/\brecord\b/) { |match| match.upcase }
|
||||
@ -109,8 +111,22 @@ task :backport do
|
||||
.gsub(/^from ([[:alnum:]]+) import/, 'FROM \1 IMPORT')
|
||||
.gsub(/ \^([[:alnum:]])/, ' POINTER TO \1')
|
||||
.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
|
||||
end
|
||||
FileList['source/*.def'].each do |file|
|
||||
cp file, File.join('boot/stage1/source', Pathname.new(file).basename)
|
||||
end
|
||||
end
|
||||
|
||||
@ -3,16 +3,16 @@ module Compiler;
|
||||
from FIO import StdIn;
|
||||
from SYSTEM import ADR;
|
||||
|
||||
from Lexer import Lexer, LexerDestroy, LexerInitialize;
|
||||
from Transpiler import Transpile;
|
||||
from Lexer import Lexer, lexer_destroy, lexer_initialize;
|
||||
from Transpiler import transpile;
|
||||
|
||||
var
|
||||
ALexer: Lexer;
|
||||
|
||||
BEGIN
|
||||
LexerInitialize(ADR(ALexer), StdIn);
|
||||
begin
|
||||
lexer_initialize(ADR(ALexer), StdIn);
|
||||
|
||||
Transpile(ADR(ALexer));
|
||||
transpile(ADR(ALexer));
|
||||
|
||||
LexerDestroy(ADR(ALexer))
|
||||
END Compiler.
|
||||
lexer_destroy(ADR(ALexer))
|
||||
end Compiler.
|
||||
|
||||
@ -80,16 +80,17 @@ TYPE
|
||||
);
|
||||
LexerToken = RECORD
|
||||
CASE Kind: LexerKind OF
|
||||
lexerKindBoolean: booleanKind: BOOLEAN
|
||||
lexerKindBoolean: booleanKind: BOOLEAN |
|
||||
lexerKindIdentifier: identifierKind: ARRAY[1..256] OF CHAR
|
||||
END
|
||||
END;
|
||||
PLexerToken = POINTER TO LexerToken;
|
||||
|
||||
PROCEDURE LexerInitialize(ALexer: PLexer; Input: File);
|
||||
PROCEDURE LexerDestroy(ALexer: PLexer);
|
||||
PROCEDURE lexer_initialize(ALexer: PLexer; Input: File);
|
||||
PROCEDURE lexer_destroy(ALexer: PLexer);
|
||||
(* Returns the last read token. *)
|
||||
PROCEDURE LexerCurrent(ALexer: PLexer): LexerToken;
|
||||
PROCEDURE lexer_current(ALexer: PLexer): LexerToken;
|
||||
(* Read and return the next token. *)
|
||||
PROCEDURE LexerLex(ALexer: PLexer): LexerToken;
|
||||
PROCEDURE lexer_lex(ALexer: PLexer): LexerToken;
|
||||
|
||||
END Lexer.
|
||||
|
||||
@ -5,7 +5,7 @@ from SYSTEM import ADR;
|
||||
|
||||
from Storage import DEALLOCATE, ALLOCATE;
|
||||
from Strings import Length;
|
||||
from MemUtils import MemZero;
|
||||
from MemUtils import MemCopy, MemZero;
|
||||
from StrCase import Lower;
|
||||
|
||||
const
|
||||
@ -70,7 +70,7 @@ var
|
||||
Classification: ARRAY[1..128] OF TransitionClass;
|
||||
Transitions: ARRAY[0..15] OF ARRAY[0..21] OF Transition;
|
||||
|
||||
proc InitializeClassification();
|
||||
proc initialize_classification();
|
||||
begin
|
||||
Classification[1] := transitionClassEof; (* NUL *)
|
||||
Classification[2] := transitionClassInvalid; (* SOH *)
|
||||
@ -200,9 +200,9 @@ begin
|
||||
Classification[126] := transitionClassOther; (* } *)
|
||||
Classification[127] := transitionClassSingle; (* ~ *)
|
||||
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
|
||||
Result: BOOLEAN;
|
||||
Index: CARDINAL;
|
||||
@ -217,23 +217,23 @@ begin
|
||||
end;
|
||||
Result := (Index = Length(Keyword)) AND (TokenStart = TokenEnd) AND Result;
|
||||
return Result
|
||||
END CompareKeyword;
|
||||
end;
|
||||
|
||||
(* Reached the end of file. *)
|
||||
proc TransitionActionEof(ALexer: PLexer; AToken: PLexerToken);
|
||||
proc transition_action_eof(ALexer: PLexer; AToken: PLexerToken);
|
||||
begin
|
||||
AToken^.Kind := lexerKindEof
|
||||
END TransitionActionEof;
|
||||
end;
|
||||
|
||||
(* 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
|
||||
INC(ALexer^.Current)
|
||||
END TransitionActionAccumulate;
|
||||
end;
|
||||
|
||||
(* The current character is not a part of the token. Finish the token already
|
||||
* read. Don't advance to the next character. *)
|
||||
proc TransitionActionFinalize(ALexer: PLexer; AToken: PLexerToken);
|
||||
proc transition_action_finalize(ALexer: PLexer; AToken: PLexerToken);
|
||||
begin
|
||||
if ALexer^.Start^ = ':' then
|
||||
AToken^.Kind := lexerKindColon
|
||||
@ -253,10 +253,10 @@ begin
|
||||
if ALexer^.Start^ = '.' then
|
||||
AToken^.Kind := lexerKindDot
|
||||
end
|
||||
END TransitionActionFinalize;
|
||||
end;
|
||||
|
||||
(* An action for tokens containing multiple characters. *)
|
||||
proc TransitionActionComposite(ALexer: PLexer; AToken: PLexerToken);
|
||||
proc transition_action_composite(ALexer: PLexer; AToken: PLexerToken);
|
||||
begin
|
||||
if ALexer^.Start^ = '<' then
|
||||
if ALexer^.Current^ = '>' then
|
||||
@ -276,17 +276,17 @@ begin
|
||||
AToken^.Kind := lexerKindAssignment
|
||||
end;
|
||||
INC(ALexer^.Current)
|
||||
END TransitionActionComposite;
|
||||
end;
|
||||
|
||||
(* Skip a space. *)
|
||||
proc TransitionActionSkip(ALexer: PLexer; AToken: PLexerToken);
|
||||
proc transition_action_skip(ALexer: PLexer; AToken: PLexerToken);
|
||||
begin
|
||||
INC(ALexer^.Current);
|
||||
INC(ALexer^.Start)
|
||||
END TransitionActionSkip;
|
||||
end;
|
||||
|
||||
(* Delimited string action. *)
|
||||
proc TransitionActionDelimited(ALexer: PLexer; AToken: PLexerToken);
|
||||
proc transition_action_delimited(ALexer: PLexer; AToken: PLexerToken);
|
||||
begin
|
||||
if ALexer^.Start^ = '(' then
|
||||
AToken^.Kind := lexerKindComment
|
||||
@ -298,113 +298,116 @@ begin
|
||||
AToken^.Kind := lexerKindString
|
||||
end;
|
||||
INC(ALexer^.Current)
|
||||
END TransitionActionDelimited;
|
||||
end;
|
||||
|
||||
(* Finalize keyword or identifier. *)
|
||||
proc TransitionActionKeyId(ALexer: PLexer; AToken: PLexerToken);
|
||||
proc transition_action_key_id(ALexer: PLexer; AToken: PLexerToken);
|
||||
begin
|
||||
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
|
||||
end;
|
||||
if CompareKeyword('IMPORT', ALexer^.Start, ALexer^.Current) then
|
||||
if compare_keyword('IMPORT', ALexer^.Start, ALexer^.Current) then
|
||||
AToken^.Kind := lexerKindImport
|
||||
end;
|
||||
if CompareKeyword('CONST', ALexer^.Start, ALexer^.Current) then
|
||||
if compare_keyword('CONST', ALexer^.Start, ALexer^.Current) then
|
||||
AToken^.Kind := lexerKindConst
|
||||
end;
|
||||
if CompareKeyword('VAR', ALexer^.Start, ALexer^.Current) then
|
||||
if compare_keyword('VAR', ALexer^.Start, ALexer^.Current) then
|
||||
AToken^.Kind := lexerKindVar
|
||||
end;
|
||||
if CompareKeyword('IF', ALexer^.Start, ALexer^.Current) then
|
||||
if compare_keyword('IF', ALexer^.Start, ALexer^.Current) then
|
||||
AToken^.Kind := lexerKindIf
|
||||
end;
|
||||
if CompareKeyword('THEN', ALexer^.Start, ALexer^.Current) then
|
||||
if compare_keyword('THEN', ALexer^.Start, ALexer^.Current) then
|
||||
AToken^.Kind := lexerKindThen
|
||||
end;
|
||||
if CompareKeyword('ELSIF', ALexer^.Start, ALexer^.Current) then
|
||||
if compare_keyword('ELSIF', ALexer^.Start, ALexer^.Current) then
|
||||
AToken^.Kind := lexerKindElsif
|
||||
end;
|
||||
if CompareKeyword('ELSE', ALexer^.Start, ALexer^.Current) then
|
||||
if compare_keyword('ELSE', ALexer^.Start, ALexer^.Current) then
|
||||
AToken^.Kind := lexerKindElse
|
||||
end;
|
||||
if CompareKeyword('WHILE', ALexer^.Start, ALexer^.Current) then
|
||||
if compare_keyword('WHILE', ALexer^.Start, ALexer^.Current) then
|
||||
AToken^.Kind := lexerKindWhile
|
||||
end;
|
||||
if CompareKeyword('DO', ALexer^.Start, ALexer^.Current) then
|
||||
if compare_keyword('DO', ALexer^.Start, ALexer^.Current) then
|
||||
AToken^.Kind := lexerKindDo
|
||||
end;
|
||||
if CompareKeyword('proc', ALexer^.Start, ALexer^.Current) then
|
||||
if compare_keyword('proc', ALexer^.Start, ALexer^.Current) then
|
||||
AToken^.Kind := lexerKindProc
|
||||
end;
|
||||
if CompareKeyword('BEGIN', ALexer^.Start, ALexer^.Current) then
|
||||
if compare_keyword('BEGIN', ALexer^.Start, ALexer^.Current) then
|
||||
AToken^.Kind := lexerKindBegin
|
||||
end;
|
||||
if CompareKeyword('END', ALexer^.Start, ALexer^.Current) then
|
||||
if compare_keyword('END', ALexer^.Start, ALexer^.Current) then
|
||||
AToken^.Kind := lexerKindEnd
|
||||
end;
|
||||
if CompareKeyword('TYPE', ALexer^.Start, ALexer^.Current) then
|
||||
if compare_keyword('TYPE', ALexer^.Start, ALexer^.Current) then
|
||||
AToken^.Kind := lexerKindType
|
||||
end;
|
||||
if CompareKeyword('RECORD', ALexer^.Start, ALexer^.Current) then
|
||||
if compare_keyword('RECORD', ALexer^.Start, ALexer^.Current) then
|
||||
AToken^.Kind := lexerKindRecord
|
||||
end;
|
||||
if CompareKeyword('UNION', ALexer^.Start, ALexer^.Current) then
|
||||
if compare_keyword('UNION', ALexer^.Start, ALexer^.Current) then
|
||||
AToken^.Kind := lexerKindUnion
|
||||
end;
|
||||
if CompareKeyword('NIL', ALexer^.Start, ALexer^.Current) then
|
||||
if compare_keyword('NIL', ALexer^.Start, ALexer^.Current) then
|
||||
AToken^.Kind := lexerKindNull
|
||||
end;
|
||||
if CompareKeyword('AND', ALexer^.Start, ALexer^.Current) then
|
||||
if compare_keyword('AND', ALexer^.Start, ALexer^.Current) then
|
||||
AToken^.Kind := lexerKindAnd
|
||||
end;
|
||||
if CompareKeyword('OR', ALexer^.Start, ALexer^.Current) then
|
||||
if compare_keyword('OR', ALexer^.Start, ALexer^.Current) then
|
||||
AToken^.Kind := lexerKindOr
|
||||
end;
|
||||
if CompareKeyword('RETURN', ALexer^.Start, ALexer^.Current) then
|
||||
if compare_keyword('RETURN', ALexer^.Start, ALexer^.Current) then
|
||||
AToken^.Kind := lexerKindReturn
|
||||
end;
|
||||
if CompareKeyword('DEFINITION', ALexer^.Start, ALexer^.Current) then
|
||||
if compare_keyword('DEFINITION', ALexer^.Start, ALexer^.Current) then
|
||||
AToken^.Kind := lexerKindDefinition
|
||||
end;
|
||||
if CompareKeyword('TO', ALexer^.Start, ALexer^.Current) then
|
||||
if compare_keyword('TO', ALexer^.Start, ALexer^.Current) then
|
||||
AToken^.Kind := lexerKindTo
|
||||
end;
|
||||
if CompareKeyword('CASE', ALexer^.Start, ALexer^.Current) then
|
||||
if compare_keyword('CASE', ALexer^.Start, ALexer^.Current) then
|
||||
AToken^.Kind := lexerKindCase
|
||||
end;
|
||||
if CompareKeyword('OF', ALexer^.Start, ALexer^.Current) then
|
||||
if compare_keyword('OF', ALexer^.Start, ALexer^.Current) then
|
||||
AToken^.Kind := lexerKindOf
|
||||
end;
|
||||
if CompareKeyword('FROM', ALexer^.Start, ALexer^.Current) then
|
||||
if compare_keyword('FROM', ALexer^.Start, ALexer^.Current) then
|
||||
AToken^.Kind := lexerKindFrom
|
||||
end;
|
||||
if CompareKeyword('MODULE', ALexer^.Start, ALexer^.Current) then
|
||||
if compare_keyword('MODULE', ALexer^.Start, ALexer^.Current) then
|
||||
AToken^.Kind := lexerKindModule
|
||||
end;
|
||||
if CompareKeyword('IMPLEMENTATION', ALexer^.Start, ALexer^.Current) then
|
||||
if compare_keyword('IMPLEMENTATION', ALexer^.Start, ALexer^.Current) then
|
||||
AToken^.Kind := lexerKindImplementation
|
||||
end;
|
||||
if CompareKeyword('POINTER', ALexer^.Start, ALexer^.Current) then
|
||||
if compare_keyword('POINTER', ALexer^.Start, ALexer^.Current) then
|
||||
AToken^.Kind := lexerKindPointer
|
||||
end;
|
||||
if CompareKeyword('ARRAY', ALexer^.Start, ALexer^.Current) then
|
||||
if compare_keyword('ARRAY', ALexer^.Start, ALexer^.Current) then
|
||||
AToken^.Kind := lexerKindArray
|
||||
end;
|
||||
if CompareKeyword('TRUE', ALexer^.Start, ALexer^.Current) then
|
||||
if compare_keyword('TRUE', ALexer^.Start, ALexer^.Current) then
|
||||
AToken^.Kind := lexerKindBoolean;
|
||||
AToken^.booleanKind := TRUE
|
||||
end;
|
||||
if CompareKeyword('FALSE', ALexer^.Start, ALexer^.Current) then
|
||||
if compare_keyword('FALSE', ALexer^.Start, ALexer^.Current) then
|
||||
AToken^.Kind := lexerKindBoolean;
|
||||
AToken^.booleanKind := FALSE
|
||||
end
|
||||
END TransitionActionKeyId;
|
||||
end;
|
||||
|
||||
(* Action for tokens containing only one character. The character cannot be
|
||||
* followed by other characters forming a composite token. *)
|
||||
proc TransitionActionSingle(ALexer: PLexer; AToken: PLexerToken);
|
||||
proc transition_action_single(ALexer: PLexer; AToken: PLexerToken);
|
||||
begin
|
||||
if ALexer^.Current^ = '&' then
|
||||
AToken^.Kind := lexerKindAnd
|
||||
@ -449,15 +452,15 @@ begin
|
||||
AToken^.Kind := lexerKindPipe
|
||||
end;
|
||||
INC(ALexer^.Current)
|
||||
END TransitionActionSingle;
|
||||
end;
|
||||
|
||||
(* Handle an integer literal. *)
|
||||
proc TransitionActionInteger(ALexer: PLexer; AToken: PLexerToken);
|
||||
proc transition_action_integer(ALexer: PLexer; AToken: PLexerToken);
|
||||
begin
|
||||
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
|
||||
DefaultTransition: Transition;
|
||||
begin
|
||||
@ -486,7 +489,7 @@ begin
|
||||
Transitions[ORD(CurrentState)][ORD(transitionClassGreater)] := DefaultTransition;
|
||||
Transitions[ORD(CurrentState)][ORD(transitionClassLess)] := DefaultTransition;
|
||||
Transitions[ORD(CurrentState)][ORD(transitionClassOther)] := DefaultTransition
|
||||
END SetDefaultTransition;
|
||||
end;
|
||||
|
||||
(*
|
||||
* 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
|
||||
* handles each action.
|
||||
*)
|
||||
proc InitializeTransitions();
|
||||
proc initialize_transitions();
|
||||
begin
|
||||
(* Start state. *)
|
||||
Transitions[ORD(transitionStateStart)][ORD(transitionClassInvalid)].Action := NIL;
|
||||
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(transitionClassAlpha)].Action := TransitionActionAccumulate;
|
||||
Transitions[ORD(transitionStateStart)][ORD(transitionClassAlpha)].Action := transition_action_accumulate;
|
||||
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(transitionClassColon)].Action := TransitionActionAccumulate;
|
||||
Transitions[ORD(transitionStateStart)][ORD(transitionClassColon)].Action := transition_action_accumulate;
|
||||
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(transitionClassLeftParen)].Action := TransitionActionAccumulate;
|
||||
Transitions[ORD(transitionStateStart)][ORD(transitionClassLeftParen)].Action := transition_action_accumulate;
|
||||
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(transitionClassAsterisk)].Action := TransitionActionSingle;
|
||||
Transitions[ORD(transitionStateStart)][ORD(transitionClassAsterisk)].Action := transition_action_single;
|
||||
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(transitionClassSingle)].Action := TransitionActionSingle;
|
||||
Transitions[ORD(transitionStateStart)][ORD(transitionClassSingle)].Action := transition_action_single;
|
||||
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(transitionClassZero)].Action := TransitionActionAccumulate;
|
||||
Transitions[ORD(transitionStateStart)][ORD(transitionClassZero)].Action := transition_action_accumulate;
|
||||
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(transitionClassEof)].Action := TransitionActionEof;
|
||||
Transitions[ORD(transitionStateStart)][ORD(transitionClassEof)].Action := transition_action_eof;
|
||||
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(transitionClassMinus)].Action := TransitionActionAccumulate;
|
||||
Transitions[ORD(transitionStateStart)][ORD(transitionClassMinus)].Action := transition_action_accumulate;
|
||||
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(transitionClassDoubleQuote)].Action := TransitionActionAccumulate;
|
||||
Transitions[ORD(transitionStateStart)][ORD(transitionClassDoubleQuote)].Action := transition_action_accumulate;
|
||||
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(transitionClassLess)].Action := TransitionActionAccumulate;
|
||||
Transitions[ORD(transitionStateStart)][ORD(transitionClassLess)].Action := transition_action_accumulate;
|
||||
Transitions[ORD(transitionStateStart)][ORD(transitionClassLess)].NextState := transitionStateLess;
|
||||
|
||||
Transitions[ORD(transitionStateStart)][ORD(transitionClassOther)].Action := NIL;
|
||||
Transitions[ORD(transitionStateStart)][ORD(transitionClassOther)].NextState := transitionStateEnd;
|
||||
|
||||
(* 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;
|
||||
|
||||
(* 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(transitionClassAlpha)].Action := TransitionActionAccumulate;
|
||||
Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassAlpha)].Action := transition_action_accumulate;
|
||||
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(transitionClassHex)].Action := TransitionActionAccumulate;
|
||||
Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassHex)].Action := transition_action_accumulate;
|
||||
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(transitionClassX)].Action := TransitionActionAccumulate;
|
||||
Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassX)].Action := transition_action_accumulate;
|
||||
Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassX)].NextState := transitionStateIdentifier;
|
||||
|
||||
(* 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(transitionClassAlpha)].Action := TransitionActionAccumulate;
|
||||
Transitions[ORD(transitionStateDecimal)][ORD(transitionClassAlpha)].Action := transition_action_accumulate;
|
||||
Transitions[ORD(transitionStateDecimal)][ORD(transitionClassAlpha)].NextState := transitionStateDecimalSuffix;
|
||||
|
||||
Transitions[ORD(transitionStateDecimal)][ORD(transitionClassUnderscore)].Action := NIL;
|
||||
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(transitionClassZero)].Action := TransitionActionAccumulate;
|
||||
Transitions[ORD(transitionStateDecimal)][ORD(transitionClassZero)].Action := transition_action_accumulate;
|
||||
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;
|
||||
|
||||
(* 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;
|
||||
|
||||
(* 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;
|
||||
|
||||
(* 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;
|
||||
|
||||
(* 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(transitionClassGreater)].Action := TransitionActionComposite;
|
||||
Transitions[ORD(transitionStateLess)][ORD(transitionClassGreater)].Action := transition_action_composite;
|
||||
Transitions[ORD(transitionStateLess)][ORD(transitionClassGreater)].NextState := transitionStateEnd;
|
||||
|
||||
(* 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;
|
||||
|
||||
(* 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(transitionClassEof)].Action := NIL;
|
||||
Transitions[ORD(transitionStateComment)][ORD(transitionClassEof)].NextState := transitionStateEnd;
|
||||
|
||||
(* 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)].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(transitionClassAsterisk)].Action := TransitionActionAccumulate;
|
||||
Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassAsterisk)].Action := transition_action_accumulate;
|
||||
Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassAsterisk)].NextState := transitionStateClosingComment;
|
||||
|
||||
Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassEof)].Action := NIL;
|
||||
Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassEof)].NextState := transitionStateEnd;
|
||||
|
||||
(* 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)].NextState := transitionStateEnd;
|
||||
@ -687,11 +690,11 @@ begin
|
||||
Transitions[ORD(transitionStateCharacter)][ORD(transitionClassEof)].Action := NIL;
|
||||
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;
|
||||
|
||||
(* 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)].NextState := transitionStateEnd;
|
||||
@ -699,11 +702,11 @@ begin
|
||||
Transitions[ORD(transitionStateString)][ORD(transitionClassEof)].Action := NIL;
|
||||
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;
|
||||
|
||||
(* 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)].NextState := transitionStateEnd;
|
||||
@ -724,7 +727,7 @@ begin
|
||||
Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassX)].NextState := transitionStateEnd;
|
||||
|
||||
(* 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)].NextState := transitionStateEnd;
|
||||
@ -740,9 +743,9 @@ begin
|
||||
|
||||
Transitions[ORD(transitionStateDecimalSuffix)][ORD(transitionClassX)].Action := NIL;
|
||||
Transitions[ORD(transitionStateDecimalSuffix)][ORD(transitionClassX)].NextState := transitionStateEnd
|
||||
END InitializeTransitions;
|
||||
end;
|
||||
|
||||
proc LexerInitialize(ALexer: PLexer; Input: File);
|
||||
proc lexer_initialize(ALexer: PLexer; Input: File);
|
||||
begin
|
||||
ALexer^.Input := Input;
|
||||
ALexer^.Length := 0;
|
||||
@ -750,9 +753,9 @@ begin
|
||||
ALLOCATE(ALexer^.Buffer, ChunkSize);
|
||||
MemZero(ALexer^.Buffer, ChunkSize);
|
||||
ALexer^.Size := ChunkSize
|
||||
END LexerInitialize;
|
||||
end;
|
||||
|
||||
proc LexerCurrent(ALexer: PLexer): LexerToken;
|
||||
proc lexer_current(ALexer: PLexer): LexerToken;
|
||||
var
|
||||
CurrentClass: TransitionClass;
|
||||
CurrentState: TransitionState;
|
||||
@ -772,9 +775,9 @@ begin
|
||||
CurrentState := CurrentTransition.NextState
|
||||
end;
|
||||
return Result
|
||||
END LexerCurrent;
|
||||
end;
|
||||
|
||||
proc LexerLex(ALexer: PLexer): LexerToken;
|
||||
proc lexer_lex(ALexer: PLexer): LexerToken;
|
||||
var
|
||||
Result: LexerToken;
|
||||
begin
|
||||
@ -784,16 +787,16 @@ begin
|
||||
end;
|
||||
ALexer^.Start := ALexer^.Current;
|
||||
|
||||
Result := LexerCurrent(ALexer);
|
||||
Result := lexer_current(ALexer);
|
||||
return Result
|
||||
END LexerLex;
|
||||
end;
|
||||
|
||||
proc LexerDestroy(ALexer: PLexer);
|
||||
proc lexer_destroy(ALexer: PLexer);
|
||||
begin
|
||||
DEALLOCATE(ALexer^.Buffer, ALexer^.Size)
|
||||
END LexerDestroy;
|
||||
end;
|
||||
|
||||
BEGIN
|
||||
InitializeClassification();
|
||||
InitializeTransitions()
|
||||
END Lexer.
|
||||
begin
|
||||
initialize_classification();
|
||||
initialize_transitions()
|
||||
end Lexer.
|
||||
|
||||
@ -2,6 +2,6 @@ DEFINITION MODULE Transpiler;
|
||||
|
||||
FROM Lexer IMPORT PLexer;
|
||||
|
||||
PROCEDURE Transpile(ALexer: PLexer);
|
||||
PROCEDURE transpile(ALexer: PLexer);
|
||||
|
||||
END Transpiler.
|
||||
|
||||
@ -4,7 +4,7 @@ from FIO import WriteNBytes, StdOut;
|
||||
from SYSTEM import ADR, ADDRESS;
|
||||
|
||||
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
|
||||
PTranspilerContext = ^TranspilerContext;
|
||||
@ -12,224 +12,228 @@ type
|
||||
Indentation: CARDINAL
|
||||
end;
|
||||
|
||||
(* Calls LexerLex() but skips the comments. *)
|
||||
proc TranspilerLex(ALexer: PLexer): LexerToken;
|
||||
(* Calls lexer_lex() but skips the comments. *)
|
||||
proc transpiler_lex(ALexer: PLexer): LexerToken;
|
||||
var
|
||||
Result: LexerToken;
|
||||
begin
|
||||
Result := LexerLex(ALexer);
|
||||
Result := lexer_lex(ALexer);
|
||||
|
||||
while Result.Kind = lexerKindComment do
|
||||
Result := LexerLex(ALexer)
|
||||
Result := lexer_lex(ALexer)
|
||||
end;
|
||||
|
||||
return Result
|
||||
END TranspilerLex;
|
||||
end;
|
||||
|
||||
(* Write a semicolon followed by a newline. *)
|
||||
proc WriteSemicolon();
|
||||
proc write_semicolon();
|
||||
begin
|
||||
WriteString(';');
|
||||
WriteLn()
|
||||
END WriteSemicolon;
|
||||
end;
|
||||
|
||||
proc TranspileImport(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_import(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
begin
|
||||
WriteString('FROM ');
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WriteString(' IMPORT ');
|
||||
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
while Token.Kind <> lexerKindSemicolon do
|
||||
WriteString(', ');
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := TranspilerLex(ALexer)
|
||||
Token := transpiler_lex(ALexer)
|
||||
end;
|
||||
WriteSemicolon();
|
||||
Token := TranspilerLex(ALexer)
|
||||
END TranspileImport;
|
||||
write_semicolon();
|
||||
Token := transpiler_lex(ALexer)
|
||||
end;
|
||||
|
||||
proc TranspileImportPart(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_import_part(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
begin
|
||||
Token := LexerCurrent(ALexer);
|
||||
Token := lexer_current(ALexer);
|
||||
|
||||
while Token.Kind = lexerKindFrom do
|
||||
TranspileImport(AContext, ALexer);
|
||||
Token := LexerCurrent(ALexer)
|
||||
transpile_import(AContext, ALexer);
|
||||
Token := lexer_current(ALexer)
|
||||
end;
|
||||
WriteLn()
|
||||
END TranspileImportPart;
|
||||
end;
|
||||
|
||||
proc TranspileConstant(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_constant(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
begin
|
||||
WriteString(' ');
|
||||
Token := LexerCurrent(ALexer);
|
||||
Token := lexer_current(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WriteString(' = ');
|
||||
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
|
||||
Token := TranspilerLex(ALexer);
|
||||
WriteSemicolon()
|
||||
END TranspileConstant;
|
||||
Token := transpiler_lex(ALexer);
|
||||
write_semicolon()
|
||||
end;
|
||||
|
||||
proc TranspileConstantPart(AContext: PTranspilerContext; ALexer: PLexer): BOOLEAN;
|
||||
proc transpile_constant_part(AContext: PTranspilerContext; ALexer: PLexer): BOOLEAN;
|
||||
var
|
||||
Token: LexerToken;
|
||||
Result: BOOLEAN;
|
||||
begin
|
||||
Token := LexerCurrent(ALexer);
|
||||
Token := lexer_current(ALexer);
|
||||
Result := Token.Kind = lexerKindConst;
|
||||
|
||||
if Result then
|
||||
WriteString('CONST');
|
||||
WriteLn();
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
|
||||
while Token.Kind = lexerKindIdentifier do
|
||||
TranspileConstant(AContext, ALexer);
|
||||
Token := TranspilerLex(ALexer)
|
||||
transpile_constant(AContext, ALexer);
|
||||
Token := transpiler_lex(ALexer)
|
||||
end
|
||||
end;
|
||||
return Result
|
||||
END TranspileConstantPart;
|
||||
end;
|
||||
|
||||
proc TranspileModule(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_module(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
begin
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
|
||||
if Token.Kind = lexerKindDefinition then
|
||||
WriteString('DEFINITION ');
|
||||
Token := TranspilerLex(ALexer)
|
||||
Token := transpiler_lex(ALexer)
|
||||
end;
|
||||
if Token.Kind = lexerKindImplementation then
|
||||
WriteString('IMPLEMENTATION ');
|
||||
Token := TranspilerLex(ALexer)
|
||||
Token := transpiler_lex(ALexer)
|
||||
end;
|
||||
WriteString('MODULE ');
|
||||
|
||||
(* 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);
|
||||
|
||||
Token := TranspilerLex(ALexer);
|
||||
WriteSemicolon();
|
||||
Token := transpiler_lex(ALexer);
|
||||
write_semicolon();
|
||||
WriteLn();
|
||||
|
||||
(* Write the module body. *)
|
||||
Token := TranspilerLex(ALexer);
|
||||
TranspileImportPart(AContext, ALexer);
|
||||
if TranspileConstantPart(AContext, ALexer) then
|
||||
Token := transpiler_lex(ALexer);
|
||||
transpile_import_part(AContext, ALexer);
|
||||
if transpile_constant_part(AContext, ALexer) then
|
||||
WriteLn()
|
||||
end;
|
||||
TranspileTypePart(AContext, ALexer);
|
||||
if TranspileVariablePart(AContext, ALexer) then
|
||||
transpile_type_part(AContext, ALexer);
|
||||
if transpile_variable_part(AContext, ALexer) then
|
||||
WriteLn()
|
||||
end;
|
||||
TranspileProcedurePart(AContext, ALexer);
|
||||
transpile_procedure_part(AContext, ALexer);
|
||||
transpile_statement_part(AContext, ALexer);
|
||||
|
||||
Token := LexerCurrent(ALexer);
|
||||
while Token.Kind <> lexerKindEof do
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
WriteLn();
|
||||
WriteString('END ');
|
||||
|
||||
Token := TranspilerLex(ALexer)
|
||||
end
|
||||
END TranspileModule;
|
||||
Token := transpiler_lex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
|
||||
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
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
begin
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
|
||||
while Token.Kind <> lexerKindEnd do
|
||||
WriteString(' ');
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WriteString(': ');
|
||||
TranspileTypeExpression(AContext, ALexer);
|
||||
Token := TranspilerLex(ALexer);
|
||||
transpile_type_expression(AContext, ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
|
||||
if Token.Kind = lexerKindSemicolon then
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
Write(';')
|
||||
end;
|
||||
WriteLn()
|
||||
end
|
||||
END TranspileTypeFields;
|
||||
end;
|
||||
|
||||
proc TranspileRecordType(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_record_type(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
begin
|
||||
WriteString('RECORD');
|
||||
WriteLn();
|
||||
TranspileTypeFields(AContext, ALexer);
|
||||
transpile_type_fields(AContext, ALexer);
|
||||
WriteString(' END')
|
||||
END TranspileRecordType;
|
||||
end;
|
||||
|
||||
proc TranspilePointerType(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_pointer_type(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
begin
|
||||
Token := LexerCurrent(ALexer);
|
||||
Token := lexer_current(ALexer);
|
||||
WriteString('POINTER TO ');
|
||||
if Token.Kind = lexerKindPointer then
|
||||
Token := TranspilerLex(ALexer)
|
||||
Token := transpiler_lex(ALexer)
|
||||
end;
|
||||
TranspileTypeExpression(AContext, ALexer)
|
||||
END TranspilePointerType;
|
||||
transpile_type_expression(AContext, ALexer)
|
||||
end;
|
||||
|
||||
proc TranspileArrayType(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_array_type(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
begin
|
||||
WriteString('ARRAY');
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
|
||||
if Token.Kind <> lexerKindOf then
|
||||
Write('[');
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WriteString('..');
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
Write(']');
|
||||
Token := TranspilerLex(ALexer)
|
||||
Token := transpiler_lex(ALexer)
|
||||
end;
|
||||
WriteString(' OF ');
|
||||
TranspileTypeExpression(AContext, ALexer)
|
||||
END TranspileArrayType;
|
||||
transpile_type_expression(AContext, ALexer)
|
||||
end;
|
||||
|
||||
proc TranspileEnumerationType(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_enumeration_type(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
@ -238,393 +242,402 @@ begin
|
||||
WriteLn();
|
||||
WriteString(' ');
|
||||
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
|
||||
while Token.Kind = lexerKindComma do
|
||||
Write(',');
|
||||
WriteLn();
|
||||
WriteString(' ');
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
|
||||
Token := TranspilerLex(ALexer)
|
||||
Token := transpiler_lex(ALexer)
|
||||
end;
|
||||
WriteLn();
|
||||
WriteString(' )')
|
||||
END TranspileEnumerationType;
|
||||
end;
|
||||
|
||||
proc TranspileUnionType(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_union_type(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
END TranspileUnionType;
|
||||
end;
|
||||
|
||||
proc TranspileProcedureType(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_procedure_type(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
begin
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WriteString('PROCEDURE(');
|
||||
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
|
||||
while Token.Kind <> lexerKindRightParen do
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
if Token.Kind = lexerKindComma then
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WriteString(', ')
|
||||
end
|
||||
end;
|
||||
Write(')')
|
||||
END TranspileProcedureType;
|
||||
end;
|
||||
|
||||
proc TranspileTypeExpression(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_type_expression(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
begin
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
if Token.Kind = lexerKindRecord then
|
||||
TranspileRecordType(AContext, ALexer)
|
||||
transpile_record_type(AContext, ALexer)
|
||||
end;
|
||||
if Token.Kind = lexerKindLeftParen then
|
||||
TranspileEnumerationType(AContext, ALexer)
|
||||
transpile_enumeration_type(AContext, ALexer)
|
||||
end;
|
||||
if Token.Kind = lexerKindArray then
|
||||
TranspileArrayType(AContext, ALexer)
|
||||
transpile_array_type(AContext, ALexer)
|
||||
end;
|
||||
if (Token.Kind = lexerKindPointer) OR (Token.Kind = lexerKindHat) then
|
||||
TranspilePointerType(AContext, ALexer)
|
||||
transpile_pointer_type(AContext, ALexer)
|
||||
end;
|
||||
if Token.Kind = lexerKindProc then
|
||||
TranspileProcedureType(AContext, ALexer)
|
||||
transpile_procedure_type(AContext, ALexer)
|
||||
end;
|
||||
if Token.Kind = lexerKindIdentifier then
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start)
|
||||
end
|
||||
END TranspileTypeExpression;
|
||||
end;
|
||||
|
||||
proc TranspileTypeDeclaration(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_type_declaration(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
begin
|
||||
WriteString(' ');
|
||||
Token := LexerCurrent(ALexer);
|
||||
Token := lexer_current(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WriteString(' = ');
|
||||
TranspileTypeExpression(AContext, ALexer);
|
||||
Token := TranspilerLex(ALexer);
|
||||
WriteSemicolon();
|
||||
END TranspileTypeDeclaration;
|
||||
transpile_type_expression(AContext, ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
write_semicolon();
|
||||
end;
|
||||
|
||||
proc TranspileTypePart(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_type_part(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
begin
|
||||
Token := LexerCurrent(ALexer);
|
||||
Token := lexer_current(ALexer);
|
||||
|
||||
if Token.Kind = lexerKindType then
|
||||
WriteString('TYPE');
|
||||
WriteLn();
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
|
||||
while Token.Kind = lexerKindIdentifier do
|
||||
TranspileTypeDeclaration(AContext, ALexer);
|
||||
Token := TranspilerLex(ALexer)
|
||||
transpile_type_declaration(AContext, ALexer);
|
||||
Token := transpiler_lex(ALexer)
|
||||
end;
|
||||
WriteLn()
|
||||
end
|
||||
END TranspileTypePart;
|
||||
end;
|
||||
|
||||
proc TranspileVariableDeclaration(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_variable_declaration(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
begin
|
||||
WriteString(' ');
|
||||
Token := LexerCurrent(ALexer);
|
||||
Token := lexer_current(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WriteString(': ');
|
||||
TranspileTypeExpression(AContext, ALexer);
|
||||
Token := TranspilerLex(ALexer);
|
||||
WriteSemicolon()
|
||||
END TranspileVariableDeclaration;
|
||||
transpile_type_expression(AContext, ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
write_semicolon()
|
||||
end;
|
||||
|
||||
proc TranspileVariablePart(AContext: PTranspilerContext; ALexer: PLexer): BOOLEAN;
|
||||
proc transpile_variable_part(AContext: PTranspilerContext; ALexer: PLexer): BOOLEAN;
|
||||
var
|
||||
Token: LexerToken;
|
||||
Result: BOOLEAN;
|
||||
begin
|
||||
Token := LexerCurrent(ALexer);
|
||||
Token := lexer_current(ALexer);
|
||||
Result := Token.Kind = lexerKindVar;
|
||||
|
||||
if Result then
|
||||
WriteString('VAR');
|
||||
WriteLn();
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
|
||||
while Token.Kind = lexerKindIdentifier do
|
||||
TranspileVariableDeclaration(AContext, ALexer);
|
||||
Token := TranspilerLex(ALexer)
|
||||
transpile_variable_declaration(AContext, ALexer);
|
||||
Token := transpiler_lex(ALexer)
|
||||
end
|
||||
end;
|
||||
return Result
|
||||
END TranspileVariablePart;
|
||||
end;
|
||||
|
||||
proc TranspileProcedureHeading(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_procedure_heading(AContext: PTranspilerContext; ALexer: PLexer): LexerToken;
|
||||
var
|
||||
Token: LexerToken;
|
||||
Result: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
begin
|
||||
WriteString('PROCEDURE ');
|
||||
|
||||
Token := TranspilerLex(ALexer);
|
||||
Result := transpiler_lex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
Write('(');
|
||||
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
while Token.Kind <> lexerKindRightParen do
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WriteString(': ');
|
||||
|
||||
TranspileTypeExpression(AContext, ALexer);
|
||||
transpile_type_expression(AContext, ALexer);
|
||||
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
if Token.Kind = lexerKindSemicolon then
|
||||
WriteString('; ');
|
||||
Token := TranspilerLex(ALexer)
|
||||
Token := transpiler_lex(ALexer)
|
||||
end
|
||||
end;
|
||||
WriteString(')');
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
|
||||
(* Check for the return type and write it. *)
|
||||
if Token.Kind = lexerKindColon then
|
||||
WriteString(': ');
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := TranspilerLex(ALexer)
|
||||
Token := transpiler_lex(ALexer)
|
||||
end;
|
||||
Token := TranspilerLex(ALexer);
|
||||
WriteSemicolon()
|
||||
END TranspileProcedureHeading;
|
||||
Token := transpiler_lex(ALexer);
|
||||
write_semicolon();
|
||||
|
||||
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
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
begin
|
||||
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');
|
||||
WriteLn();
|
||||
TranspileStatements(AContext, ALexer);
|
||||
transpile_statements(AContext, ALexer);
|
||||
WriteString(' END');
|
||||
Token := TranspilerLex(ALexer)
|
||||
END TranspileIfStatement;
|
||||
Token := transpiler_lex(ALexer)
|
||||
end;
|
||||
|
||||
proc TranspileWhileStatement(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_while_statement(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
begin
|
||||
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');
|
||||
WriteLn();
|
||||
TranspileStatements(AContext, ALexer);
|
||||
transpile_statements(AContext, ALexer);
|
||||
WriteString(' END');
|
||||
Token := TranspilerLex(ALexer)
|
||||
END TranspileWhileStatement;
|
||||
Token := transpiler_lex(ALexer)
|
||||
end;
|
||||
|
||||
proc TranspileAssignmentStatement(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
proc transpile_assignment_statement(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
begin
|
||||
WriteString(' := ');
|
||||
Token := TranspilerLex(ALexer);
|
||||
transpile_expression(AContext, ALexer, lexerKindSemicolon);
|
||||
end;
|
||||
|
||||
while (Token.Kind <> lexerKindSemicolon) AND (Token.Kind <> lexerKindEnd) do
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Write(' ');
|
||||
Token := TranspilerLex(ALexer)
|
||||
end
|
||||
END TranspileAssignmentStatement;
|
||||
|
||||
proc TranspileCallStatement(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_call_statement(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
begin
|
||||
WriteString('(');
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
|
||||
while (Token.Kind <> lexerKindSemicolon) AND (Token.Kind <> lexerKindEnd) do
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := TranspilerLex(ALexer)
|
||||
Token := transpiler_lex(ALexer)
|
||||
end
|
||||
END TranspileCallStatement;
|
||||
end;
|
||||
|
||||
proc TranspileReturnStatement(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_return_statement(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
begin
|
||||
WriteString(' RETURN ');
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := TranspilerLex(ALexer)
|
||||
END TranspileReturnStatement;
|
||||
Token := transpiler_lex(ALexer)
|
||||
end;
|
||||
|
||||
proc TranspileStatement(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_statement(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
begin
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
|
||||
if Token.Kind = lexerKindIf then
|
||||
TranspileIfStatement(AContext, ALexer)
|
||||
transpile_if_statement(AContext, ALexer)
|
||||
end;
|
||||
if Token.Kind = lexerKindWhile then
|
||||
TranspileWhileStatement(AContext, ALexer)
|
||||
transpile_while_statement(AContext, ALexer)
|
||||
end;
|
||||
if Token.Kind = lexerKindReturn then
|
||||
TranspileReturnStatement(AContext, ALexer)
|
||||
transpile_return_statement(AContext, ALexer)
|
||||
end;
|
||||
if Token.Kind = lexerKindIdentifier then
|
||||
WriteString(' ');
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
|
||||
while Token.Kind = lexerKindLeftSquare do
|
||||
Write('[');
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
while Token.Kind <> lexerKindRightSquare do
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := TranspilerLex(ALexer)
|
||||
Token := transpiler_lex(ALexer)
|
||||
end;
|
||||
Write(']');
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
end;
|
||||
if Token.Kind = lexerKindHat then
|
||||
Write('^');
|
||||
Token := TranspilerLex(ALexer)
|
||||
Token := transpiler_lex(ALexer)
|
||||
end;
|
||||
if Token.Kind = lexerKindDot then
|
||||
Write('.');
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
end;
|
||||
if Token.Kind = lexerKindHat then
|
||||
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;
|
||||
|
||||
if Token.Kind = lexerKindAssignment then
|
||||
TranspileAssignmentStatement(AContext, ALexer)
|
||||
transpile_assignment_statement(AContext, ALexer)
|
||||
end;
|
||||
if Token.Kind = lexerKindLeftParen then
|
||||
TranspileCallStatement(AContext, ALexer)
|
||||
transpile_call_statement(AContext, ALexer)
|
||||
end
|
||||
end
|
||||
END TranspileStatement;
|
||||
end;
|
||||
|
||||
proc TranspileStatements(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_statements(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
begin
|
||||
Token := LexerCurrent(ALexer);
|
||||
Token := lexer_current(ALexer);
|
||||
|
||||
while Token.Kind <> lexerKindEnd do
|
||||
TranspileStatement(AContext, ALexer);
|
||||
Token := LexerCurrent(ALexer);
|
||||
transpile_statement(AContext, ALexer);
|
||||
Token := lexer_current(ALexer);
|
||||
|
||||
if Token.Kind = lexerKindSemicolon then
|
||||
Write(';')
|
||||
end;
|
||||
WriteLn()
|
||||
end
|
||||
END TranspileStatements;
|
||||
end;
|
||||
|
||||
proc TranspileStatementPart(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_statement_part(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
begin
|
||||
Token := LexerCurrent(ALexer);
|
||||
Token := lexer_current(ALexer);
|
||||
if Token.Kind = lexerKindBegin then
|
||||
WriteString('BEGIN');
|
||||
WriteLn();
|
||||
TranspileStatements(AContext, ALexer)
|
||||
transpile_statements(AContext, ALexer)
|
||||
end
|
||||
END TranspileStatementPart;
|
||||
end;
|
||||
|
||||
proc TranspileProcedureDeclaration(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_procedure_declaration(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
SeenPart: BOOLEAN;
|
||||
WrittenBytes: CARDINAL;
|
||||
begin
|
||||
TranspileProcedureHeading(AContext, ALexer);
|
||||
SeenPart := TranspileConstantPart(AContext, ALexer);
|
||||
SeenPart := TranspileVariablePart(AContext, ALexer);
|
||||
TranspileStatementPart(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;
|
||||
Token := transpile_procedure_heading(AContext, ALexer);
|
||||
SeenPart := transpile_constant_part(AContext, ALexer);
|
||||
SeenPart := transpile_variable_part(AContext, ALexer);
|
||||
transpile_statement_part(AContext, ALexer);
|
||||
|
||||
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
|
||||
Token: LexerToken;
|
||||
begin
|
||||
Token := LexerCurrent(ALexer);
|
||||
Token := lexer_current(ALexer);
|
||||
|
||||
while Token.Kind = lexerKindProc do
|
||||
TranspileProcedureDeclaration(AContext, ALexer);
|
||||
Token := LexerCurrent(ALexer);
|
||||
transpile_procedure_declaration(AContext, ALexer);
|
||||
Token := lexer_current(ALexer);
|
||||
WriteLn()
|
||||
end
|
||||
END TranspileProcedurePart;
|
||||
end;
|
||||
|
||||
proc Transpile(ALexer: PLexer);
|
||||
proc transpile(ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
Context: TranspilerContext;
|
||||
begin
|
||||
TranspileModule(ADR(Context), ALexer)
|
||||
END Transpile;
|
||||
transpile_module(ADR(Context), ALexer)
|
||||
end;
|
||||
|
||||
END Transpiler.
|
||||
end Transpiler.
|
||||
|
||||
Reference in New Issue
Block a user