From bd41736697cbbf136c1b9c86898642e428320ffb Mon Sep 17 00:00:00 2001 From: Eugen Wissner Date: Thu, 29 May 2025 14:59:56 +0200 Subject: [PATCH] Make procedure name after the end --- Rakefile | 32 ++- source/Compiler.elna | 14 +- source/Lexer.def | 11 +- source/Lexer.elna | 259 ++++++++++++----------- source/Transpiler.def | 2 +- source/Transpiler.elna | 469 +++++++++++++++++++++-------------------- 6 files changed, 410 insertions(+), 377 deletions(-) diff --git a/Rakefile b/Rakefile index 82260a3..7c75556 100644 --- a/Rakefile +++ b/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 diff --git a/source/Compiler.elna b/source/Compiler.elna index 23e700f..9af3bca 100644 --- a/source/Compiler.elna +++ b/source/Compiler.elna @@ -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. diff --git a/source/Lexer.def b/source/Lexer.def index a6ba01f..6557849 100644 --- a/source/Lexer.def +++ b/source/Lexer.def @@ -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. diff --git a/source/Lexer.elna b/source/Lexer.elna index cd4f99a..756c499 100644 --- a/source/Lexer.elna +++ b/source/Lexer.elna @@ -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. diff --git a/source/Transpiler.def b/source/Transpiler.def index a19ad37..c3cd8a7 100644 --- a/source/Transpiler.def +++ b/source/Transpiler.def @@ -2,6 +2,6 @@ DEFINITION MODULE Transpiler; FROM Lexer IMPORT PLexer; -PROCEDURE Transpile(ALexer: PLexer); +PROCEDURE transpile(ALexer: PLexer); END Transpiler. diff --git a/source/Transpiler.elna b/source/Transpiler.elna index 080b790..0ece102 100644 --- a/source/Transpiler.elna +++ b/source/Transpiler.elna @@ -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.