Make procedure name after the end

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

View File

@ -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

View File

@ -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.

View File

@ -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.

View File

@ -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.

View File

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

View File

@ -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.