diff --git a/README.md b/README.md index 0c73162..553df60 100644 --- a/README.md +++ b/README.md @@ -24,7 +24,7 @@ in the `boot/` directory. ## Build -The frontend requires GCC 14.2.0 (not tested with other versions). +The frontend requires GCC 15.1.0 (not tested with other versions). Download the GCC source. Copy the contents of this repository into `gcc/elna` inside GCC. Finally build GCC enabling the frontend with diff --git a/source/CommandLineInterface.def b/source/CommandLineInterface.def deleted file mode 100644 index e4688c4..0000000 --- a/source/CommandLineInterface.def +++ /dev/null @@ -1,16 +0,0 @@ -DEFINITION MODULE CommandLineInterface; - -FROM Common IMPORT ShortString; - -TYPE - CommandLine = RECORD - input: ShortString; - output: ShortString; - lex: BOOLEAN; - parse: BOOLEAN - END; - PCommandLine = POINTER TO CommandLine; - -PROCEDURE parse_command_line(): PCommandLine; - -END CommandLineInterface. diff --git a/source/CommandLineInterface.elna b/source/CommandLineInterface.elna index 22389dc..2d07fee 100644 --- a/source/CommandLineInterface.elna +++ b/source/CommandLineInterface.elna @@ -1,7 +1,8 @@ +(* This Source Code Form is subject to the terms of the Mozilla Public License, + v. 2.0. If a copy of the MPL was not distributed with this file, You can + obtain one at https://mozilla.org/MPL/2.0/. *) module; -from SYSTEM import ADR, TSIZE; - from Args import GetArg, Narg; from FIO import WriteString, WriteChar, WriteLine, StdErr; from Storage import ALLOCATE; @@ -10,18 +11,26 @@ from MemUtils import MemZero; from Common import ShortString; -proc parse_command_line() -> PCommandLine; +type + CommandLine = record + input: ShortString; + output: ShortString; + lex: Bool; + parse: Bool + end; + +proc parse_command_line*() -> ^CommandLine; var parameter: ShortString; - i: CARDINAL; - result: PCommandLine; - parsed: BOOLEAN; + i: Word; + result: ^CommandLine; + parsed: Bool; begin - i := 1; + i := 1u; NEW(result); result^.lex := false; result^.parse := false; - MemZero(ADR(result^.input), 256); + MemZero(@result^.input, 256); result^.output[1] := CHAR(0); while (i < Narg()) & (result <> nil) do @@ -37,7 +46,7 @@ begin result^.parse := true end; if CompareStr(parameter, '-o') = 0 then - INC(i); + i := i + 1u; if i = Narg() then WriteString(StdErr, 'Fatal error: expecting a file name following -o.'); diff --git a/source/Common.elna b/source/Common.elna index a3ab8cd..627c972 100644 --- a/source/Common.elna +++ b/source/Common.elna @@ -1,9 +1,11 @@ +(* This Source Code Form is subject to the terms of the Mozilla Public License, + v. 2.0. If a copy of the MPL was not distributed with this file, You can + obtain one at https://mozilla.org/MPL/2.0/. *) module; type ShortString = [256]Char; Identifier = [256]Char; - PIdentifier = ^Identifier; TextLocation* = record line: Word; column: Word diff --git a/source/Compiler.elna b/source/Compiler.elna index f72f091..4f2cc91 100644 --- a/source/Compiler.elna +++ b/source/Compiler.elna @@ -1,25 +1,27 @@ +(* This Source Code Form is subject to the terms of the Mozilla Public License, + v. 2.0. If a copy of the MPL was not distributed with this file, You can + obtain one at https://mozilla.org/MPL/2.0/. *) program; from FIO import Close, IsNoError, File, OpenToRead, OpenToWrite, StdErr, StdOut, WriteLine, WriteString; -from SYSTEM import ADR; from M2RTS import HALT, ExitOnHalt; from Lexer import Lexer, lexer_destroy, lexer_initialize; from Parser import Parser; from Transpiler import transpile; -from CommandLineInterface import PCommandLine, parse_command_line; -from Parser import PAstModule, parse; +from CommandLineInterface import CommandLine, parse_command_line; +from Parser import AstModule, parse; from Strings import Length; var - command_line: PCommandLine; + command_line: ^CommandLine; proc compile_from_stream(); var lexer: Lexer; source_input: File; source_output: File; - ast_module: PAstModule; + ast_module: ^AstModule; begin source_input := OpenToRead(command_line^.input); @@ -47,12 +49,12 @@ begin end; if IsNoError(source_input) then - lexer_initialize(ADR(lexer), source_input); + lexer_initialize(@lexer, source_input); - ast_module := parse(ADR(lexer)); + ast_module := parse(@lexer); transpile(ast_module, StdOut, source_output, command_line^.input); - lexer_destroy(ADR(lexer)); + lexer_destroy(@lexer); Close(source_output); Close(source_input) diff --git a/source/Lexer.elna b/source/Lexer.elna index 11df504..3a3eac5 100644 --- a/source/Lexer.elna +++ b/source/Lexer.elna @@ -1,3 +1,6 @@ +(* This Source Code Form is subject to the terms of the Mozilla Public License, + v. 2.0. If a copy of the MPL was not distributed with this file, You can + obtain one at https://mozilla.org/MPL/2.0/. *) module; import Common; @@ -13,46 +16,46 @@ type * Classification: *) TransitionClass = ( - transitionClassInvalid, - transitionClassDigit, - transitionClassAlpha, - transitionClassSpace, - transitionClassColon, - transitionClassEquals, - transitionClassLeftParen, - transitionClassRightParen, - transitionClassAsterisk, - transitionClassUnderscore, - transitionClassSingle, - transitionClassHex, - transitionClassZero, - transitionClassX, - transitionClassEof, - transitionClassDot, - transitionClassMinus, - transitionClassSingleQuote, - transitionClassDoubleQuote, - transitionClassGreater, - transitionClassLess, - transitionClassOther + invalid, + digit, + alpha, + space, + colon, + equals, + left_paren, + right_paren, + asterisk, + underscore, + single, + hex, + zero, + x, + eof, + dot, + minus, + single_quote, + double_quote, + greater, + less, + other ); TransitionState = ( - transitionStateStart, - transitionStateColon, - transitionStateIdentifier, - transitionStateDecimal, - transitionStateGreater, - transitionStateMinus, - transitionStateLeftParen, - transitionStateLess, - transitionStateDot, - transitionStateComment, - transitionStateClosingComment, - transitionStateCharacter, - transitionStateString, - transitionStateLeadingZero, - transitionStateDecimalSuffix, - transitionStateEnd + start, + colon, + identifier, + decimal, + greater, + minus, + left_paren, + less, + dot, + comment, + closing_comment, + character, + string, + leading_zero, + decimal_suffix, + finish ); LexerToken = record kind: LexerKind; @@ -85,69 +88,69 @@ type current: BufferPosition end; LexerKind* = ( - lexerKindEof, - lexerKindIdentifier, - lexerKindIf, - lexerKindThen, - lexerKindElse, - lexerKindElsif, - lexerKindWhile, - lexerKindDo, - lexerKindProc, - lexerKindBegin, - lexerKindEnd, - lexerKindXor, - lexerKindConst, - lexerKindVar, - lexerKindCase, - lexerKindOf, - lexerKindType, - lexerKindRecord, - lexerKindUnion, - lexerKindPipe, - lexerKindTo, - lexerKindBoolean, - lexerKindNull, - lexerKindAnd, - lexerKindOr, - lexerKindTilde, - lexerKindReturn, - lexerKindDefer, - lexerKindRange, - lexerKindLeftParen, - lexerKindRightParen, - lexerKindLeftSquare, - lexerKindRightSquare, - lexerKindGreaterEqual, - lexerKindLessEqual, - lexerKindGreaterThan, - lexerKindLessThan, - lexerKindNotEqual, - lexerKindEqual, - lexerKindSemicolon, - lexerKindDot, - lexerKindComma, - lexerKindPlus, - lexerKindMinus, - lexerKindAsterisk, - lexerKindDivision, - lexerKindRemainder, - lexerKindAssignment, - lexerKindColon, - lexerKindHat, - lexerKindAt, - lexerKindComment, - lexerKindInteger, - lexerKindWord, - lexerKindCharacter, - lexerKindString, - lexerKindFrom, - lexerKindPointer, - lexerKindArray, - lexerKindArrow, - lexerKindProgram, - lexerKindModule, - lexerKindImport + eof, + identifier, + _if, + _then, + _else, + _elsif, + _while, + _do, + _proc, + _begin, + _end, + _xor, + _const, + _var, + _case, + _of, + _type, + _record, + _union, + pipe, + to, + boolean, + null, + and, + _or, + tilde, + _return, + _defer, + range, + left_paren, + right_paren, + lefts_quare, + right_square, + greater_equal, + less_equal, + greater_than, + less_than, + not_equal, + equal, + semicolon, + dot, + comma, + plus, + minus, + asterisk, + division, + remainder, + assignment, + colon, + hat, + at, + comment, + integer, + word, + character, + string, + from, + pointer, + array, + arrow, + _program, + _module, + _import ); var @@ -158,139 +161,139 @@ proc initialize_classification(); var i: Word; begin - classification[1] := transitionClassEof; (* NUL *) - classification[2] := transitionClassInvalid; (* SOH *) - classification[3] := transitionClassInvalid; (* STX *) - classification[4] := transitionClassInvalid; (* ETX *) - classification[5] := transitionClassInvalid; (* EOT *) - classification[6] := transitionClassInvalid; (* EMQ *) - classification[7] := transitionClassInvalid; (* ACK *) - classification[8] := transitionClassInvalid; (* BEL *) - classification[9] := transitionClassInvalid; (* BS *) - classification[10] := transitionClassSpace; (* HT *) - classification[11] := transitionClassSpace; (* LF *) - classification[12] := transitionClassInvalid; (* VT *) - classification[13] := transitionClassInvalid; (* FF *) - classification[14] := transitionClassSpace; (* CR *) - classification[15] := transitionClassInvalid; (* SO *) - classification[16] := transitionClassInvalid; (* SI *) - classification[17] := transitionClassInvalid; (* DLE *) - classification[18] := transitionClassInvalid; (* DC1 *) - classification[19] := transitionClassInvalid; (* DC2 *) - classification[20] := transitionClassInvalid; (* DC3 *) - classification[21] := transitionClassInvalid; (* DC4 *) - classification[22] := transitionClassInvalid; (* NAK *) - classification[23] := transitionClassInvalid; (* SYN *) - classification[24] := transitionClassInvalid; (* ETB *) - classification[25] := transitionClassInvalid; (* CAN *) - classification[26] := transitionClassInvalid; (* EM *) - classification[27] := transitionClassInvalid; (* SUB *) - classification[28] := transitionClassInvalid; (* ESC *) - classification[29] := transitionClassInvalid; (* FS *) - classification[30] := transitionClassInvalid; (* GS *) - classification[31] := transitionClassInvalid; (* RS *) - classification[32] := transitionClassInvalid; (* US *) - classification[33] := transitionClassSpace; (* Space *) - classification[34] := transitionClassSingle; (* ! *) - classification[35] := transitionClassDoubleQuote; (* " *) - classification[36] := transitionClassOther; (* # *) - classification[37] := transitionClassOther; (* $ *) - classification[38] := transitionClassSingle; (* % *) - classification[39] := transitionClassSingle; (* & *) - classification[40] := transitionClassSingleQuote; (* ' *) - classification[41] := transitionClassLeftParen; (* ( *) - classification[42] := transitionClassRightParen; (* ) *) - classification[43] := transitionClassAsterisk; (* * *) - classification[44] := transitionClassSingle; (* + *) - classification[45] := transitionClassSingle; (* , *) - classification[46] := transitionClassMinus; (* - *) - classification[47] := transitionClassDot; (* . *) - classification[48] := transitionClassSingle; (* / *) - classification[49] := transitionClassZero; (* 0 *) - classification[50] := transitionClassDigit; (* 1 *) - classification[51] := transitionClassDigit; (* 2 *) - classification[52] := transitionClassDigit; (* 3 *) - classification[53] := transitionClassDigit; (* 4 *) - classification[54] := transitionClassDigit; (* 5 *) - classification[55] := transitionClassDigit; (* 6 *) - classification[56] := transitionClassDigit; (* 7 *) - classification[57] := transitionClassDigit; (* 8 *) - classification[58] := transitionClassDigit; (* 9 *) - classification[59] := transitionClassColon; (* : *) - classification[60] := transitionClassSingle; (* ; *) - classification[61] := transitionClassLess; (* < *) - classification[62] := transitionClassEquals; (* = *) - classification[63] := transitionClassGreater; (* > *) - classification[64] := transitionClassOther; (* ? *) - classification[65] := transitionClassSingle; (* @ *) - classification[66] := transitionClassAlpha; (* A *) - classification[67] := transitionClassAlpha; (* B *) - classification[68] := transitionClassAlpha; (* C *) - classification[69] := transitionClassAlpha; (* D *) - classification[70] := transitionClassAlpha; (* E *) - classification[71] := transitionClassAlpha; (* F *) - classification[72] := transitionClassAlpha; (* G *) - classification[73] := transitionClassAlpha; (* H *) - classification[74] := transitionClassAlpha; (* I *) - classification[75] := transitionClassAlpha; (* J *) - classification[76] := transitionClassAlpha; (* K *) - classification[77] := transitionClassAlpha; (* L *) - classification[78] := transitionClassAlpha; (* M *) - classification[79] := transitionClassAlpha; (* N *) - classification[80] := transitionClassAlpha; (* O *) - classification[81] := transitionClassAlpha; (* P *) - classification[82] := transitionClassAlpha; (* Q *) - classification[83] := transitionClassAlpha; (* R *) - classification[84] := transitionClassAlpha; (* S *) - classification[85] := transitionClassAlpha; (* T *) - classification[86] := transitionClassAlpha; (* U *) - classification[87] := transitionClassAlpha; (* V *) - classification[88] := transitionClassAlpha; (* W *) - classification[89] := transitionClassAlpha; (* X *) - classification[90] := transitionClassAlpha; (* Y *) - classification[91] := transitionClassAlpha; (* Z *) - classification[92] := transitionClassSingle; (* [ *) - classification[93] := transitionClassOther; (* \ *) - classification[94] := transitionClassSingle; (* ] *) - classification[95] := transitionClassSingle; (* ^ *) - classification[96] := transitionClassUnderscore; (* _ *) - classification[97] := transitionClassOther; (* ` *) - classification[98] := transitionClassHex; (* a *) - classification[99] := transitionClassHex; (* b *) - classification[100] := transitionClassHex; (* c *) - classification[101] := transitionClassHex; (* d *) - classification[102] := transitionClassHex; (* e *) - classification[103] := transitionClassHex; (* f *) - classification[104] := transitionClassAlpha; (* g *) - classification[105] := transitionClassAlpha; (* h *) - classification[106] := transitionClassAlpha; (* i *) - classification[107] := transitionClassAlpha; (* j *) - classification[108] := transitionClassAlpha; (* k *) - classification[109] := transitionClassAlpha; (* l *) - classification[110] := transitionClassAlpha; (* m *) - classification[111] := transitionClassAlpha; (* n *) - classification[112] := transitionClassAlpha; (* o *) - classification[113] := transitionClassAlpha; (* p *) - classification[114] := transitionClassAlpha; (* q *) - classification[115] := transitionClassAlpha; (* r *) - classification[116] := transitionClassAlpha; (* s *) - classification[117] := transitionClassAlpha; (* t *) - classification[118] := transitionClassAlpha; (* u *) - classification[119] := transitionClassAlpha; (* v *) - classification[120] := transitionClassAlpha; (* w *) - classification[121] := transitionClassX; (* x *) - classification[122] := transitionClassAlpha; (* y *) - classification[123] := transitionClassAlpha; (* z *) - classification[124] := transitionClassOther; (* { *) - classification[125] := transitionClassSingle; (* | *) - classification[126] := transitionClassOther; (* } *) - classification[127] := transitionClassSingle; (* ~ *) - classification[128] := transitionClassInvalid; (* DEL *) + classification[1] := TransitionClass.eof; (* NUL *) + classification[2] := TransitionClass.invalid; (* SOH *) + classification[3] := TransitionClass.invalid; (* STX *) + classification[4] := TransitionClass.invalid; (* ETX *) + classification[5] := TransitionClass.invalid; (* EOT *) + classification[6] := TransitionClass.invalid; (* EMQ *) + classification[7] := TransitionClass.invalid; (* ACK *) + classification[8] := TransitionClass.invalid; (* BEL *) + classification[9] := TransitionClass.invalid; (* BS *) + classification[10] := TransitionClass.space; (* HT *) + classification[11] := TransitionClass.space; (* LF *) + classification[12] := TransitionClass.invalid; (* VT *) + classification[13] := TransitionClass.invalid; (* FF *) + classification[14] := TransitionClass.space; (* CR *) + classification[15] := TransitionClass.invalid; (* SO *) + classification[16] := TransitionClass.invalid; (* SI *) + classification[17] := TransitionClass.invalid; (* DLE *) + classification[18] := TransitionClass.invalid; (* DC1 *) + classification[19] := TransitionClass.invalid; (* DC2 *) + classification[20] := TransitionClass.invalid; (* DC3 *) + classification[21] := TransitionClass.invalid; (* DC4 *) + classification[22] := TransitionClass.invalid; (* NAK *) + classification[23] := TransitionClass.invalid; (* SYN *) + classification[24] := TransitionClass.invalid; (* ETB *) + classification[25] := TransitionClass.invalid; (* CAN *) + classification[26] := TransitionClass.invalid; (* EM *) + classification[27] := TransitionClass.invalid; (* SUB *) + classification[28] := TransitionClass.invalid; (* ESC *) + classification[29] := TransitionClass.invalid; (* FS *) + classification[30] := TransitionClass.invalid; (* GS *) + classification[31] := TransitionClass.invalid; (* RS *) + classification[32] := TransitionClass.invalid; (* US *) + classification[33] := TransitionClass.space; (* Space *) + classification[34] := TransitionClass.single; (* ! *) + classification[35] := TransitionClass.double_quote; (* " *) + classification[36] := TransitionClass.other; (* # *) + classification[37] := TransitionClass.other; (* $ *) + classification[38] := TransitionClass.single; (* % *) + classification[39] := TransitionClass.single; (* & *) + classification[40] := TransitionClass.single_quote; (* ' *) + classification[41] := TransitionClass.left_paren; (* ( *) + classification[42] := TransitionClass.right_paren; (* ) *) + classification[43] := TransitionClass.asterisk; (* * *) + classification[44] := TransitionClass.single; (* + *) + classification[45] := TransitionClass.single; (* , *) + classification[46] := TransitionClass.minus; (* - *) + classification[47] := TransitionClass.dot; (* . *) + classification[48] := TransitionClass.single; (* / *) + classification[49] := TransitionClass.zero; (* 0 *) + classification[50] := TransitionClass.digit; (* 1 *) + classification[51] := TransitionClass.digit; (* 2 *) + classification[52] := TransitionClass.digit; (* 3 *) + classification[53] := TransitionClass.digit; (* 4 *) + classification[54] := TransitionClass.digit; (* 5 *) + classification[55] := TransitionClass.digit; (* 6 *) + classification[56] := TransitionClass.digit; (* 7 *) + classification[57] := TransitionClass.digit; (* 8 *) + classification[58] := TransitionClass.digit; (* 9 *) + classification[59] := TransitionClass.colon; (* : *) + classification[60] := TransitionClass.single; (* ; *) + classification[61] := TransitionClass.less; (* < *) + classification[62] := TransitionClass.equals; (* = *) + classification[63] := TransitionClass.greater; (* > *) + classification[64] := TransitionClass.other; (* ? *) + classification[65] := TransitionClass.single; (* @ *) + classification[66] := TransitionClass.alpha; (* A *) + classification[67] := TransitionClass.alpha; (* B *) + classification[68] := TransitionClass.alpha; (* C *) + classification[69] := TransitionClass.alpha; (* D *) + classification[70] := TransitionClass.alpha; (* E *) + classification[71] := TransitionClass.alpha; (* F *) + classification[72] := TransitionClass.alpha; (* G *) + classification[73] := TransitionClass.alpha; (* H *) + classification[74] := TransitionClass.alpha; (* I *) + classification[75] := TransitionClass.alpha; (* J *) + classification[76] := TransitionClass.alpha; (* K *) + classification[77] := TransitionClass.alpha; (* L *) + classification[78] := TransitionClass.alpha; (* M *) + classification[79] := TransitionClass.alpha; (* N *) + classification[80] := TransitionClass.alpha; (* O *) + classification[81] := TransitionClass.alpha; (* P *) + classification[82] := TransitionClass.alpha; (* Q *) + classification[83] := TransitionClass.alpha; (* R *) + classification[84] := TransitionClass.alpha; (* S *) + classification[85] := TransitionClass.alpha; (* T *) + classification[86] := TransitionClass.alpha; (* U *) + classification[87] := TransitionClass.alpha; (* V *) + classification[88] := TransitionClass.alpha; (* W *) + classification[89] := TransitionClass.alpha; (* X *) + classification[90] := TransitionClass.alpha; (* Y *) + classification[91] := TransitionClass.alpha; (* Z *) + classification[92] := TransitionClass.single; (* [ *) + classification[93] := TransitionClass.other; (* \ *) + classification[94] := TransitionClass.single; (* ] *) + classification[95] := TransitionClass.single; (* ^ *) + classification[96] := TransitionClass.underscore; (* _ *) + classification[97] := TransitionClass.other; (* ` *) + classification[98] := TransitionClass.hex; (* a *) + classification[99] := TransitionClass.hex; (* b *) + classification[100] := TransitionClass.hex; (* c *) + classification[101] := TransitionClass.hex; (* d *) + classification[102] := TransitionClass.hex; (* e *) + classification[103] := TransitionClass.hex; (* f *) + classification[104] := TransitionClass.alpha; (* g *) + classification[105] := TransitionClass.alpha; (* h *) + classification[106] := TransitionClass.alpha; (* i *) + classification[107] := TransitionClass.alpha; (* j *) + classification[108] := TransitionClass.alpha; (* k *) + classification[109] := TransitionClass.alpha; (* l *) + classification[110] := TransitionClass.alpha; (* m *) + classification[111] := TransitionClass.alpha; (* n *) + classification[112] := TransitionClass.alpha; (* o *) + classification[113] := TransitionClass.alpha; (* p *) + classification[114] := TransitionClass.alpha; (* q *) + classification[115] := TransitionClass.alpha; (* r *) + classification[116] := TransitionClass.alpha; (* s *) + classification[117] := TransitionClass.alpha; (* t *) + classification[118] := TransitionClass.alpha; (* u *) + classification[119] := TransitionClass.alpha; (* v *) + classification[120] := TransitionClass.alpha; (* w *) + classification[121] := TransitionClass.x; (* x *) + classification[122] := TransitionClass.alpha; (* y *) + classification[123] := TransitionClass.alpha; (* z *) + classification[124] := TransitionClass.other; (* { *) + classification[125] := TransitionClass.single; (* | *) + classification[126] := TransitionClass.other; (* } *) + classification[127] := TransitionClass.single; (* ~ *) + classification[128] := TransitionClass.invalid; (* DEL *) - i := 129; - while i <= 256 do - classification[i] := transitionClassOther; - INC(i) + i := 129u; + while i <= 256u do + classification[i] := TransitionClass.other; + i := i + 1 end end; @@ -301,15 +304,15 @@ var keyword_length: Word; continue: Bool; begin - index := 0; + index := 0u; result := true; keyword_length := Length(keyword); continue := (index < keyword_length) & (token_start.iterator <> token_end); while continue & result do result := (keyword[index] = token_start.iterator^) or (Lower(keyword[index]) = token_start.iterator^); - INC(token_start.iterator); - INC(index); + token_start.iterator := token_start.iterator + 1; + index := index + 1u; continue := (index < keyword_length) & (token_start.iterator <> token_end) end; result := result & (index = Length(keyword)); @@ -320,18 +323,18 @@ end; (* Reached the end of file. *) proc transition_action_eof(lexer: ^Lexer, token: ^LexerToken); begin - token^.kind := lexerKindEof + token^.kind := LexerKind.eof end; proc increment(position: ^BufferPosition); begin - INC(position^.iterator) + position^.iterator := position^.iterator + 1 end; (* Add the character to the token currently read and advance to the next character. *) proc transition_action_accumulate(lexer: ^Lexer, token: ^LexerToken); begin - increment(ADR(lexer^.current)) + increment(@lexer^.current) end; (* The current character is not a part of the token. Finish the token already @@ -339,22 +342,22 @@ end; proc transition_action_finalize(lexer: ^Lexer, token: ^LexerToken); begin if lexer^.start.iterator^ = ':' then - token^.kind := lexerKindColon + token^.kind := LexerKind.colon end; if lexer^.start.iterator^ = '>' then - token^.kind := lexerKindGreaterThan + token^.kind := LexerKind.greater_than end; if lexer^.start.iterator^ = '<' then - token^.kind := lexerKindLessThan + token^.kind := LexerKind.less_than end; if lexer^.start.iterator^ = '(' then - token^.kind := lexerKindLeftParen + token^.kind := LexerKind.left_paren end; if lexer^.start.iterator^ = '-' then - token^.kind := lexerKindMinus + token^.kind := LexerKind.minus end; if lexer^.start.iterator^ = '.' then - token^.kind := lexerKindDot + token^.kind := LexerKind.dot end end; @@ -363,35 +366,35 @@ proc transition_action_composite(lexer: ^Lexer, token: ^LexerToken); begin if lexer^.start.iterator^ = '<' then if lexer^.current.iterator^ = '>' then - token^.kind := lexerKindNotEqual + token^.kind := LexerKind.not_equal end; if lexer^.current.iterator^ = '=' then - token^.kind := lexerKindLessEqual + token^.kind := LexerKind.less_equal end end; if (lexer^.start.iterator^ = '>') & (lexer^.current.iterator^ = '=') then - token^.kind := lexerKindGreaterEqual + token^.kind := LexerKind.greater_equal end; if (lexer^.start.iterator^ = '.') & (lexer^.current.iterator^ = '.') then - token^.kind := lexerKindRange + token^.kind := LexerKind.range end; if (lexer^.start.iterator^ = ':') & (lexer^.current.iterator^ = '=') then - token^.kind := lexerKindAssignment + token^.kind := LexerKind.assignment end; if (lexer^.start.iterator^ = '-') & (lexer^.current.iterator^ = '>') then - token^.kind := lexerKindArrow + token^.kind := LexerKind.arrow end; - increment(ADR(lexer^.current)) + increment(@lexer^.current) end; (* Skip a space. *) proc transition_action_skip(lexer: ^Lexer, token: ^LexerToken); begin - increment(ADR(lexer^.start)); + increment(@lexer^.start); if ORD(lexer^.start.iterator^) = 10 then - INC(lexer^.start.location.line); - lexer^.start.location.column := 1 + lexer^.start.location.line := lexer^.start.location.line + 1u; + lexer^.start.location.column := 1u end; lexer^.current := lexer^.start end; @@ -399,133 +402,128 @@ end; (* Delimited string action. *) proc transition_action_delimited(lexer: ^Lexer, token: ^LexerToken); var - text_length: Word; + text_length: Int; begin if lexer^.start.iterator^ = '(' then - token^.kind := lexerKindComment + token^.kind := LexerKind.comment end; if lexer^.start.iterator^ = '"' then - text_length := lexer^.current.iterator; - DEC(text_length, lexer^.start.iterator); - INC(text_length); + text_length := lexer^.current.iterator - lexer^.start.iterator + 1; - MemZero(ADR(token^.stringKind), TSIZE(ShortString)); - MemCopy(lexer^.start.iterator, text_length, ADR(token^.stringKind)); + MemZero(@token^.stringKind, #size(ShortString)); + MemCopy(lexer^.start.iterator, text_length, @token^.stringKind); - token^.kind := lexerKindCharacter + token^.kind := LexerKind.character end; if lexer^.start.iterator^ = "'" then - text_length := lexer^.current.iterator; - DEC(text_length, lexer^.start.iterator); - INC(text_length); + text_length := lexer^.current.iterator - lexer^.start.iterator + 1; - MemZero(ADR(token^.stringKind), TSIZE(ShortString)); - MemCopy(lexer^.start.iterator, text_length, ADR(token^.stringKind)); + MemZero(@token^.stringKind, #size(ShortString)); + MemCopy(lexer^.start.iterator, text_length, @token^.stringKind); - token^.kind := lexerKindString + token^.kind := LexerKind.string end; - increment(ADR(lexer^.current)) + increment(@lexer^.current) end; (* Finalize keyword or identifier. *) proc transition_action_key_id(lexer: ^Lexer, token: ^LexerToken); begin - token^.kind := lexerKindIdentifier; + token^.kind := LexerKind.identifier; - token^.identifierKind[1] := lexer^.current.iterator; - DEC(token^.identifierKind[1], lexer^.start.iterator); - MemCopy(lexer^.start.iterator, ORD(token^.identifierKind[1]), ADR(token^.identifierKind[2])); + token^.identifierKind[1] := cast(lexer^.current.iterator - lexer^.start.iterator: Char); + MemCopy(lexer^.start.iterator, ORD(token^.identifierKind[1]), @token^.identifierKind[2]); if compare_keyword("program", lexer^.start, lexer^.current.iterator) then - token^.kind := lexerKindProgram + token^.kind := LexerKind._program end; if compare_keyword("import", lexer^.start, lexer^.current.iterator) then - token^.kind := lexerKindImport + token^.kind := LexerKind._import end; if compare_keyword("const", lexer^.start, lexer^.current.iterator) then - token^.kind := lexerKindConst + token^.kind := LexerKind._const end; if compare_keyword("var", lexer^.start, lexer^.current.iterator) then - token^.kind := lexerKindVar + token^.kind := LexerKind._var end; if compare_keyword("if", lexer^.start, lexer^.current.iterator) then - token^.kind := lexerKindIf + token^.kind := LexerKind._if end; if compare_keyword("then", lexer^.start, lexer^.current.iterator) then - token^.kind := lexerKindThen + token^.kind := LexerKind._then end; if compare_keyword("elsif", lexer^.start, lexer^.current.iterator) then - token^.kind := lexerKindElsif + token^.kind := LexerKind._elsif end; if compare_keyword("else", lexer^.start, lexer^.current.iterator) then - token^.kind := lexerKindElse + token^.kind := LexerKind._else end; if compare_keyword("while", lexer^.start, lexer^.current.iterator) then - token^.kind := lexerKindWhile + token^.kind := LexerKind._while end; if compare_keyword("do", lexer^.start, lexer^.current.iterator) then - token^.kind := lexerKindDo + token^.kind := LexerKind._do end; if compare_keyword("proc", lexer^.start, lexer^.current.iterator) then - token^.kind := lexerKindProc + token^.kind := LexerKind._proc end; if compare_keyword("begin", lexer^.start, lexer^.current.iterator) then - token^.kind := lexerKindBegin + token^.kind := LexerKind._begin end; if compare_keyword("end", lexer^.start, lexer^.current.iterator) then - token^.kind := lexerKindEnd + token^.kind := LexerKind._end end; if compare_keyword("type", lexer^.start, lexer^.current.iterator) then - token^.kind := lexerKindType + token^.kind := LexerKind._type end; if compare_keyword("record", lexer^.start, lexer^.current.iterator) then - token^.kind := lexerKindRecord + token^.kind := LexerKind._record end; if compare_keyword("union", lexer^.start, lexer^.current.iterator) then - token^.kind := lexerKindUnion + token^.kind := LexerKind._union end; if compare_keyword("NIL", lexer^.start, lexer^.current.iterator) then - token^.kind := lexerKindNull + token^.kind := LexerKind.null end; if compare_keyword("or", lexer^.start, lexer^.current.iterator) then - token^.kind := lexerKindOr + token^.kind := LexerKind._or end; if compare_keyword("return", lexer^.start, lexer^.current.iterator) then - token^.kind := lexerKindReturn + token^.kind := LexerKind._return end; if compare_keyword("defer", lexer^.start, lexer^.current.iterator) then - token^.kind := lexerKindDefer + token^.kind := LexerKind._defer end; if compare_keyword("TO", lexer^.start, lexer^.current.iterator) then - token^.kind := lexerKindTo + token^.kind := LexerKind.to end; if compare_keyword("CASE", lexer^.start, lexer^.current.iterator) then - token^.kind := lexerKindCase + token^.kind := LexerKind._case end; if compare_keyword("OF", lexer^.start, lexer^.current.iterator) then - token^.kind := lexerKindOf + token^.kind := LexerKind._of end; if compare_keyword("FROM", lexer^.start, lexer^.current.iterator) then - token^.kind := lexerKindFrom + token^.kind := LexerKind.from end; if compare_keyword("module", lexer^.start, lexer^.current.iterator) then - token^.kind := lexerKindModule + token^.kind := LexerKind._module end; if compare_keyword("xor", lexer^.start, lexer^.current.iterator) then - token^.kind := lexerKindXor + token^.kind := LexerKind._xor end; if compare_keyword("POINTER", lexer^.start, lexer^.current.iterator) then - token^.kind := lexerKindPointer + token^.kind := LexerKind.pointer end; if compare_keyword("ARRAY", lexer^.start, lexer^.current.iterator) then - token^.kind := lexerKindArray + token^.kind := LexerKind.array end; if compare_keyword("TRUE", lexer^.start, lexer^.current.iterator) then - token^.kind := lexerKindBoolean; + token^.kind := LexerKind.boolean; token^.booleanKind := true end; if compare_keyword("FALSE", lexer^.start, lexer^.current.iterator) then - token^.kind := lexerKindBoolean; + token^.kind := LexerKind.boolean; token^.booleanKind := false end end; @@ -535,68 +533,67 @@ end; proc transition_action_single(lexer: ^Lexer, token: ^LexerToken); begin if lexer^.current.iterator^ = '&' then - token^.kind := lexerKindAnd + token^.kind := LexerKind.and end; if lexer^.current.iterator^ = ';' then - token^.kind := lexerKindSemicolon + token^.kind := LexerKind.semicolon end; if lexer^.current.iterator^ = ',' then - token^.kind := lexerKindComma + token^.kind := LexerKind.comma end; if lexer^.current.iterator^ = '~' then - token^.kind := lexerKindTilde + token^.kind := LexerKind.tilde end; if lexer^.current.iterator^ = ')' then - token^.kind := lexerKindRightParen + token^.kind := LexerKind.right_paren end; if lexer^.current.iterator^ = '[' then - token^.kind := lexerKindLeftSquare + token^.kind := LexerKind.left_square end; if lexer^.current.iterator^ = ']' then - token^.kind := lexerKindRightSquare + token^.kind := LexerKind.right_square end; if lexer^.current.iterator^ = '^' then - token^.kind := lexerKindHat + token^.kind := LexerKind.hat end; if lexer^.current.iterator^ = '=' then - token^.kind := lexerKindEqual + token^.kind := LexerKind.equal end; if lexer^.current.iterator^ = '+' then - token^.kind := lexerKindPlus + token^.kind := LexerKind.plus end; if lexer^.current.iterator^ = '*' then - token^.kind := lexerKindAsterisk + token^.kind := LexerKind.asterisk end; if lexer^.current.iterator^ = '/' then - token^.kind := lexerKindDivision + token^.kind := LexerKind.division end; if lexer^.current.iterator^ = '%' then - token^.kind := lexerKindRemainder + token^.kind := LexerKind.remainder end; if lexer^.current.iterator^ = '@' then - token^.kind := lexerKindAt + token^.kind := LexerKind.at end; if lexer^.current.iterator^ = '|' then - token^.kind := lexerKindPipe + token^.kind := LexerKind.pipe end; - increment(ADR(lexer^.current.iterator)) + increment(@lexer^.current.iterator) end; (* Handle an integer literal. *) proc transition_action_integer(lexer: ^Lexer, token: ^LexerToken); var buffer: String; - integer_length: Word; + integer_length: Int; found: Bool; begin - token^.kind := lexerKindInteger; + token^.kind := LexerKind.integer; - integer_length := lexer^.current.iterator; - DEC(integer_length, lexer^.start.iterator); - MemZero(ADR(token^.identifierKind), TSIZE(Identifier)); - MemCopy(lexer^.start.iterator, integer_length, ADR(token^.identifierKind[1])); + integer_length := lexer^.current.iterator - lexer^.start.iterator; + MemZero(@token^.identifierKind, #size(Identifier)); + MemCopy(lexer^.start.iterator, integer_length, @token^.identifierKind[1]); - buffer := InitStringCharStar(ADR(token^.identifierKind[1])); + buffer := InitStringCharStar(@token^.identifierKind[1]); token^.integerKind := StringToInteger(buffer, 10, found); buffer := KillString(buffer) end; @@ -608,28 +605,28 @@ begin default_transition.action := default_action; default_transition.next_state := next_state; - transitions[ORD(current_state) + 1][ORD(transitionClassInvalid) + 1] := default_transition; - transitions[ORD(current_state) + 1][ORD(transitionClassDigit) + 1] := default_transition; - transitions[ORD(current_state) + 1][ORD(transitionClassAlpha) + 1] := default_transition; - transitions[ORD(current_state) + 1][ORD(transitionClassSpace) + 1] := default_transition; - transitions[ORD(current_state) + 1][ORD(transitionClassColon) + 1] := default_transition; - transitions[ORD(current_state) + 1][ORD(transitionClassEquals) + 1] := default_transition; - transitions[ORD(current_state) + 1][ORD(transitionClassLeftParen) + 1] := default_transition; - transitions[ORD(current_state) + 1][ORD(transitionClassRightParen) + 1] := default_transition; - transitions[ORD(current_state) + 1][ORD(transitionClassAsterisk) + 1] := default_transition; - transitions[ORD(current_state) + 1][ORD(transitionClassUnderscore) + 1] := default_transition; - transitions[ORD(current_state) + 1][ORD(transitionClassSingle) + 1] := default_transition; - transitions[ORD(current_state) + 1][ORD(transitionClassHex) + 1] := default_transition; - transitions[ORD(current_state) + 1][ORD(transitionClassZero) + 1] := default_transition; - transitions[ORD(current_state) + 1][ORD(transitionClassX) + 1] := default_transition; - transitions[ORD(current_state) + 1][ORD(transitionClassEof) + 1] := default_transition; - transitions[ORD(current_state) + 1][ORD(transitionClassDot) + 1] := default_transition; - transitions[ORD(current_state) + 1][ORD(transitionClassMinus) + 1] := default_transition; - transitions[ORD(current_state) + 1][ORD(transitionClassSingleQuote) + 1] := default_transition; - transitions[ORD(current_state) + 1][ORD(transitionClassDoubleQuote) + 1] := default_transition; - transitions[ORD(current_state) + 1][ORD(transitionClassGreater) + 1] := default_transition; - transitions[ORD(current_state) + 1][ORD(transitionClassLess) + 1] := default_transition; - transitions[ORD(current_state) + 1][ORD(transitionClassOther) + 1] := default_transition + transitions[ORD(current_state) + 1][ORD(TransitionClass.invalid) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(TransitionClass.digit) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(TransitionClass.alpha) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(TransitionClass.space) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(TransitionClass.colon) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(TransitionClass.equals) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(TransitionClass.left_paren) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(TransitionClass.right_paren) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(TransitionClass.asterisk) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(TransitionClass.underscore) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(TransitionClass.single) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(TransitionClass.hex) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(TransitionClass.zero) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(TransitionClass.x) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(TransitionClass.eof) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(TransitionClass.dot) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(TransitionClass.minus) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(TransitionClass.single_quote) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(TransitionClass.double_quote) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(TransitionClass.greater) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(TransitionClass.less) + 1] := default_transition; + transitions[ORD(current_state) + 1][ORD(TransitionClass.other) + 1] := default_transition end; (* @@ -651,239 +648,239 @@ end; proc initialize_transitions(); begin (* Start state. *) - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassInvalid) + 1].action := nil; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassInvalid) + 1].next_state := transitionStateEnd; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.invalid) + 1].action := nil; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.invalid) + 1].next_state := TransitionState.finish; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassDigit) + 1].action := transition_action_accumulate; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassDigit) + 1].next_state := transitionStateDecimal; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.digit) + 1].action := transition_action_accumulate; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.digit) + 1].next_state := TransitionState.decimal; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassAlpha) + 1].action := transition_action_accumulate; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassAlpha) + 1].next_state := transitionStateIdentifier; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.alpha) + 1].action := transition_action_accumulate; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.alpha) + 1].next_state := TransitionState.identifier; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassSpace) + 1].action := transition_action_skip; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassSpace) + 1].next_state := transitionStateStart; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.space) + 1].action := transition_action_skip; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.space) + 1].next_state := TransitionState.start; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassColon) + 1].action := transition_action_accumulate; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassColon) + 1].next_state := transitionStateColon; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.colon) + 1].action := transition_action_accumulate; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.colon) + 1].next_state := TransitionState.colon; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassEquals) + 1].action := transition_action_single; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassEquals) + 1].next_state := transitionStateEnd; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.equals) + 1].action := transition_action_single; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.equals) + 1].next_state := TransitionState.finish; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassLeftParen) + 1].action := transition_action_accumulate; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassLeftParen) + 1].next_state := transitionStateLeftParen; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.left_paren) + 1].action := transition_action_accumulate; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.left_paren) + 1].next_state := TransitionState.left_paren; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassRightParen) + 1].action := transition_action_single; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassRightParen) + 1].next_state := transitionStateEnd; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.right_paren) + 1].action := transition_action_single; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.right_paren) + 1].next_state := TransitionState.finish; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassAsterisk) + 1].action := transition_action_single; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassAsterisk) + 1].next_state := transitionStateEnd; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.asterisk) + 1].action := transition_action_single; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.asterisk) + 1].next_state := TransitionState.finish; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassUnderscore) + 1].action := transition_action_accumulate; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassUnderscore) + 1].next_state := transitionStateIdentifier; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.underscore) + 1].action := transition_action_accumulate; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.underscore) + 1].next_state := TransitionState.identifier; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassSingle) + 1].action := transition_action_single; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassSingle) + 1].next_state := transitionStateEnd; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.single) + 1].action := transition_action_single; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.single) + 1].next_state := TransitionState.finish; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassHex) + 1].action := transition_action_accumulate; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassHex) + 1].next_state := transitionStateIdentifier; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.hex) + 1].action := transition_action_accumulate; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.hex) + 1].next_state := TransitionState.identifier; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassZero) + 1].action := transition_action_accumulate; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassZero) + 1].next_state := transitionStateLeadingZero; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.zero) + 1].action := transition_action_accumulate; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.zero) + 1].next_state := TransitionState.leading_zero; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassX) + 1].action := transition_action_accumulate; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassX) + 1].next_state := transitionStateIdentifier; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.x) + 1].action := transition_action_accumulate; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.x) + 1].next_state := TransitionState.identifier; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassEof) + 1].action := transition_action_eof; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassEof) + 1].next_state := transitionStateEnd; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.eof) + 1].action := transition_action_eof; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.eof) + 1].next_state := TransitionState.finish; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassDot) + 1].action := transition_action_accumulate; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassDot) + 1].next_state := transitionStateDot; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.dot) + 1].action := transition_action_accumulate; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.dot) + 1].next_state := TransitionState.dot; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassMinus) + 1].action := transition_action_accumulate; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassMinus) + 1].next_state := transitionStateMinus; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.minus) + 1].action := transition_action_accumulate; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.minus) + 1].next_state := TransitionState.minus; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassSingleQuote) + 1].action := transition_action_accumulate; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassSingleQuote) + 1].next_state := transitionStateCharacter; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.single_quote) + 1].action := transition_action_accumulate; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.single_quote) + 1].next_state := TransitionState.character; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassDoubleQuote) + 1].action := transition_action_accumulate; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassDoubleQuote) + 1].next_state := transitionStateString; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.double_quote) + 1].action := transition_action_accumulate; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.double_quote) + 1].next_state := TransitionState.string; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassGreater) + 1].action := transition_action_accumulate; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassGreater) + 1].next_state := transitionStateGreater; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.greater) + 1].action := transition_action_accumulate; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.greater) + 1].next_state := TransitionState.greater; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassLess) + 1].action := transition_action_accumulate; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassLess) + 1].next_state := transitionStateLess; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.less) + 1].action := transition_action_accumulate; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.less) + 1].next_state := TransitionState.less; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassOther) + 1].action := nil; - transitions[ORD(transitionStateStart) + 1][ORD(transitionClassOther) + 1].next_state := transitionStateEnd; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.other) + 1].action := nil; + transitions[ORD(TransitionState.start) + 1][ORD(TransitionClass.other) + 1].next_state := TransitionState.finish; (* Colon state. *) - set_default_transition(transitionStateColon, transition_action_finalize, transitionStateEnd); + set_default_transition(TransitionState.colon, transition_action_finalize, TransitionState.finish); - transitions[ORD(transitionStateColon) + 1][ORD(transitionClassEquals) + 1].action := transition_action_composite; - transitions[ORD(transitionStateColon) + 1][ORD(transitionClassEquals) + 1].next_state := transitionStateEnd; + transitions[ORD(TransitionState.colon) + 1][ORD(TransitionClass.equals) + 1].action := transition_action_composite; + transitions[ORD(TransitionState.colon) + 1][ORD(TransitionClass.equals) + 1].next_state := TransitionState.finish; (* Identifier state. *) - set_default_transition(transitionStateIdentifier, transition_action_key_id, transitionStateEnd); + set_default_transition(TransitionState.identifier, transition_action_key_id, TransitionState.finish); - transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassDigit) + 1].action := transition_action_accumulate; - transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassDigit) + 1].next_state := transitionStateIdentifier; + transitions[ORD(TransitionState.identifier) + 1][ORD(TransitionClass.digit) + 1].action := transition_action_accumulate; + transitions[ORD(TransitionState.identifier) + 1][ORD(TransitionClass.digit) + 1].next_state := TransitionState.identifier; - transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassAlpha) + 1].action := transition_action_accumulate; - transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassAlpha) + 1].next_state := transitionStateIdentifier; + transitions[ORD(TransitionState.identifier) + 1][ORD(TransitionClass.alpha) + 1].action := transition_action_accumulate; + transitions[ORD(TransitionState.identifier) + 1][ORD(TransitionClass.alpha) + 1].next_state := TransitionState.identifier; - transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassUnderscore) + 1].action := transition_action_accumulate; - transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassUnderscore) + 1].next_state := transitionStateIdentifier; + transitions[ORD(TransitionState.identifier) + 1][ORD(TransitionClass.underscore) + 1].action := transition_action_accumulate; + transitions[ORD(TransitionState.identifier) + 1][ORD(TransitionClass.underscore) + 1].next_state := TransitionState.identifier; - transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassHex) + 1].action := transition_action_accumulate; - transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassHex) + 1].next_state := transitionStateIdentifier; + transitions[ORD(TransitionState.identifier) + 1][ORD(TransitionClass.hex) + 1].action := transition_action_accumulate; + transitions[ORD(TransitionState.identifier) + 1][ORD(TransitionClass.hex) + 1].next_state := TransitionState.identifier; - transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassZero) + 1].action := transition_action_accumulate; - transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassZero) + 1].next_state := transitionStateIdentifier; + transitions[ORD(TransitionState.identifier) + 1][ORD(TransitionClass.zero) + 1].action := transition_action_accumulate; + transitions[ORD(TransitionState.identifier) + 1][ORD(TransitionClass.zero) + 1].next_state := TransitionState.identifier; - transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassX) + 1].action := transition_action_accumulate; - transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassX) + 1].next_state := transitionStateIdentifier; + transitions[ORD(TransitionState.identifier) + 1][ORD(TransitionClass.x) + 1].action := transition_action_accumulate; + transitions[ORD(TransitionState.identifier) + 1][ORD(TransitionClass.x) + 1].next_state := TransitionState.identifier; (* Decimal state. *) - set_default_transition(transitionStateDecimal, transition_action_integer, transitionStateEnd); + set_default_transition(TransitionState.decimal, transition_action_integer, TransitionState.finish); - transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassDigit) + 1].action := transition_action_accumulate; - transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassDigit) + 1].next_state := transitionStateDecimal; + transitions[ORD(TransitionState.decimal) + 1][ORD(TransitionClass.digit) + 1].action := transition_action_accumulate; + transitions[ORD(TransitionState.decimal) + 1][ORD(TransitionClass.digit) + 1].next_state := TransitionState.decimal; - transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassAlpha) + 1].action := transition_action_accumulate; - transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassAlpha) + 1].next_state := transitionStateDecimalSuffix; + transitions[ORD(TransitionState.decimal) + 1][ORD(TransitionClass.alpha) + 1].action := transition_action_accumulate; + transitions[ORD(TransitionState.decimal) + 1][ORD(TransitionClass.alpha) + 1].next_state := TransitionState.decimal_suffix; - transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassUnderscore) + 1].action := nil; - transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassUnderscore) + 1].next_state := transitionStateEnd; + transitions[ORD(TransitionState.decimal) + 1][ORD(TransitionClass.underscore) + 1].action := nil; + transitions[ORD(TransitionState.decimal) + 1][ORD(TransitionClass.underscore) + 1].next_state := TransitionState.finish; - transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassHex) + 1].action := transition_action_accumulate; - transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassHex) + 1].next_state := transitionStateDecimalSuffix; + transitions[ORD(TransitionState.decimal) + 1][ORD(TransitionClass.hex) + 1].action := transition_action_accumulate; + transitions[ORD(TransitionState.decimal) + 1][ORD(TransitionClass.hex) + 1].next_state := TransitionState.decimal_suffix; - transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassZero) + 1].action := transition_action_accumulate; - transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassZero) + 1].next_state := transitionStateDecimal; + transitions[ORD(TransitionState.decimal) + 1][ORD(TransitionClass.zero) + 1].action := transition_action_accumulate; + transitions[ORD(TransitionState.decimal) + 1][ORD(TransitionClass.zero) + 1].next_state := TransitionState.decimal; - transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassX) + 1].action := transition_action_accumulate; - transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassX) + 1].next_state := transitionStateDecimalSuffix; + transitions[ORD(TransitionState.decimal) + 1][ORD(TransitionClass.x) + 1].action := transition_action_accumulate; + transitions[ORD(TransitionState.decimal) + 1][ORD(TransitionClass.x) + 1].next_state := TransitionState.decimal_suffix; (* Greater state. *) - set_default_transition(transitionStateGreater, transition_action_finalize, transitionStateEnd); + set_default_transition(TransitionState.greater, transition_action_finalize, TransitionState.finish); - transitions[ORD(transitionStateGreater) + 1][ORD(transitionClassEquals) + 1].action := transition_action_composite; - transitions[ORD(transitionStateGreater) + 1][ORD(transitionClassEquals) + 1].next_state := transitionStateEnd; + transitions[ORD(TransitionState.greater) + 1][ORD(TransitionClass.equals) + 1].action := transition_action_composite; + transitions[ORD(TransitionState.greater) + 1][ORD(TransitionClass.equals) + 1].next_state := TransitionState.finish; (* Minus state. *) - set_default_transition(transitionStateMinus, transition_action_finalize, transitionStateEnd); + set_default_transition(TransitionState.minus, transition_action_finalize, TransitionState.finish); - transitions[ORD(transitionStateMinus) + 1][ORD(transitionClassGreater) + 1].action := transition_action_composite; - transitions[ORD(transitionStateMinus) + 1][ORD(transitionClassGreater) + 1].next_state := transitionStateEnd; + transitions[ORD(TransitionState.minus) + 1][ORD(TransitionClass.greater) + 1].action := transition_action_composite; + transitions[ORD(TransitionState.minus) + 1][ORD(TransitionClass.greater) + 1].next_state := TransitionState.finish; (* Left paren state. *) - set_default_transition(transitionStateLeftParen, transition_action_finalize, transitionStateEnd); + set_default_transition(TransitionState.left_paren, transition_action_finalize, TransitionState.finish); - transitions[ORD(transitionStateLeftParen) + 1][ORD(transitionClassAsterisk) + 1].action := transition_action_accumulate; - transitions[ORD(transitionStateLeftParen) + 1][ORD(transitionClassAsterisk) + 1].next_state := transitionStateComment; + transitions[ORD(TransitionState.left_paren) + 1][ORD(TransitionClass.asterisk) + 1].action := transition_action_accumulate; + transitions[ORD(TransitionState.left_paren) + 1][ORD(TransitionClass.asterisk) + 1].next_state := TransitionState.comment; (* Less state. *) - set_default_transition(transitionStateLess, transition_action_finalize, transitionStateEnd); + set_default_transition(TransitionState.less, transition_action_finalize, TransitionState.finish); - transitions[ORD(transitionStateLess) + 1][ORD(transitionClassEquals) + 1].action := transition_action_composite; - transitions[ORD(transitionStateLess) + 1][ORD(transitionClassEquals) + 1].next_state := transitionStateEnd; + transitions[ORD(TransitionState.less) + 1][ORD(TransitionClass.equals) + 1].action := transition_action_composite; + transitions[ORD(TransitionState.less) + 1][ORD(TransitionClass.equals) + 1].next_state := TransitionState.finish; - transitions[ORD(transitionStateLess) + 1][ORD(transitionClassGreater) + 1].action := transition_action_composite; - transitions[ORD(transitionStateLess) + 1][ORD(transitionClassGreater) + 1].next_state := transitionStateEnd; + transitions[ORD(TransitionState.less) + 1][ORD(TransitionClass.greater) + 1].action := transition_action_composite; + transitions[ORD(TransitionState.less) + 1][ORD(TransitionClass.greater) + 1].next_state := TransitionState.finish; (* Hexadecimal after 0x. *) - set_default_transition(transitionStateDot, transition_action_finalize, transitionStateEnd); + set_default_transition(TransitionState.dot, transition_action_finalize, TransitionState.finish); - transitions[ORD(transitionStateDot) + 1][ORD(transitionClassDot) + 1].action := transition_action_composite; - transitions[ORD(transitionStateDot) + 1][ORD(transitionClassDot) + 1].next_state := transitionStateEnd; + transitions[ORD(TransitionState.dot) + 1][ORD(TransitionClass.dot) + 1].action := transition_action_composite; + transitions[ORD(TransitionState.dot) + 1][ORD(TransitionClass.dot) + 1].next_state := TransitionState.finish; (* Comment. *) - set_default_transition(transitionStateComment, transition_action_accumulate, transitionStateComment); + set_default_transition(TransitionState.comment, transition_action_accumulate, TransitionState.comment); - transitions[ORD(transitionStateComment) + 1][ORD(transitionClassAsterisk) + 1].action := transition_action_accumulate; - transitions[ORD(transitionStateComment) + 1][ORD(transitionClassAsterisk) + 1].next_state := transitionStateClosingComment; + transitions[ORD(TransitionState.comment) + 1][ORD(TransitionClass.asterisk) + 1].action := transition_action_accumulate; + transitions[ORD(TransitionState.comment) + 1][ORD(TransitionClass.asterisk) + 1].next_state := TransitionState.closing_comment; - transitions[ORD(transitionStateComment) + 1][ORD(transitionClassEof) + 1].action := nil; - transitions[ORD(transitionStateComment) + 1][ORD(transitionClassEof) + 1].next_state := transitionStateEnd; + transitions[ORD(TransitionState.comment) + 1][ORD(TransitionClass.eof) + 1].action := nil; + transitions[ORD(TransitionState.comment) + 1][ORD(TransitionClass.eof) + 1].next_state := TransitionState.finish; (* Closing comment. *) - set_default_transition(transitionStateClosingComment, transition_action_accumulate, transitionStateComment); + set_default_transition(TransitionState.closing_comment, transition_action_accumulate, TransitionState.comment); - transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassInvalid) + 1].action := nil; - transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassInvalid) + 1].next_state := transitionStateEnd; + transitions[ORD(TransitionState.closing_comment) + 1][ORD(TransitionClass.invalid) + 1].action := nil; + transitions[ORD(TransitionState.closing_comment) + 1][ORD(TransitionClass.invalid) + 1].next_state := TransitionState.finish; - transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassRightParen) + 1].action := transition_action_delimited; - transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassRightParen) + 1].next_state := transitionStateEnd; + transitions[ORD(TransitionState.closing_comment) + 1][ORD(TransitionClass.right_paren) + 1].action := transition_action_delimited; + transitions[ORD(TransitionState.closing_comment) + 1][ORD(TransitionClass.right_paren) + 1].next_state := TransitionState.finish; - transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassAsterisk) + 1].action := transition_action_accumulate; - transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassAsterisk) + 1].next_state := transitionStateClosingComment; + transitions[ORD(TransitionState.closing_comment) + 1][ORD(TransitionClass.asterisk) + 1].action := transition_action_accumulate; + transitions[ORD(TransitionState.closing_comment) + 1][ORD(TransitionClass.asterisk) + 1].next_state := TransitionState.closing_comment; - transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassEof) + 1].action := nil; - transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassEof) + 1].next_state := transitionStateEnd; + transitions[ORD(TransitionState.closing_comment) + 1][ORD(TransitionClass.eof) + 1].action := nil; + transitions[ORD(TransitionState.closing_comment) + 1][ORD(TransitionClass.eof) + 1].next_state := TransitionState.finish; (* Character. *) - set_default_transition(transitionStateCharacter, transition_action_accumulate, transitionStateCharacter); + set_default_transition(TransitionState.character, transition_action_accumulate, TransitionState.character); - transitions[ORD(transitionStateCharacter) + 1][ORD(transitionClassInvalid) + 1].action := nil; - transitions[ORD(transitionStateCharacter) + 1][ORD(transitionClassInvalid) + 1].next_state := transitionStateEnd; + transitions[ORD(TransitionState.character) + 1][ORD(TransitionClass.invalid) + 1].action := nil; + transitions[ORD(TransitionState.character) + 1][ORD(TransitionClass.invalid) + 1].next_state := TransitionState.finish; - transitions[ORD(transitionStateCharacter) + 1][ORD(transitionClassEof) + 1].action := nil; - transitions[ORD(transitionStateCharacter) + 1][ORD(transitionClassEof) + 1].next_state := transitionStateEnd; + transitions[ORD(TransitionState.character) + 1][ORD(TransitionClass.eof) + 1].action := nil; + transitions[ORD(TransitionState.character) + 1][ORD(TransitionClass.eof) + 1].next_state := TransitionState.finish; - transitions[ORD(transitionStateCharacter) + 1][ORD(transitionClassSingleQuote) + 1].action := transition_action_delimited; - transitions[ORD(transitionStateCharacter) + 1][ORD(transitionClassSingleQuote) + 1].next_state := transitionStateEnd; + transitions[ORD(TransitionState.character) + 1][ORD(TransitionClass.single_quote) + 1].action := transition_action_delimited; + transitions[ORD(TransitionState.character) + 1][ORD(TransitionClass.single_quote) + 1].next_state := TransitionState.finish; (* String. *) - set_default_transition(transitionStateString, transition_action_accumulate, transitionStateString); + set_default_transition(TransitionState.string, transition_action_accumulate, TransitionState.string); - transitions[ORD(transitionStateString) + 1][ORD(transitionClassInvalid) + 1].action := nil; - transitions[ORD(transitionStateString) + 1][ORD(transitionClassInvalid) + 1].next_state := transitionStateEnd; + transitions[ORD(TransitionState.string) + 1][ORD(TransitionClass.invalid) + 1].action := nil; + transitions[ORD(TransitionState.string) + 1][ORD(TransitionClass.invalid) + 1].next_state := TransitionState.finish; - transitions[ORD(transitionStateString) + 1][ORD(transitionClassEof) + 1].action := nil; - transitions[ORD(transitionStateString) + 1][ORD(transitionClassEof) + 1].next_state := transitionStateEnd; + transitions[ORD(TransitionState.string) + 1][ORD(TransitionClass.eof) + 1].action := nil; + transitions[ORD(TransitionState.string) + 1][ORD(TransitionClass.eof) + 1].next_state := TransitionState.finish; - transitions[ORD(transitionStateString) + 1][ORD(transitionClassDoubleQuote) + 1].action := transition_action_delimited; - transitions[ORD(transitionStateString) + 1][ORD(transitionClassDoubleQuote) + 1].next_state := transitionStateEnd; + transitions[ORD(TransitionState.string) + 1][ORD(TransitionClass.double_quote) + 1].action := transition_action_delimited; + transitions[ORD(TransitionState.string) + 1][ORD(TransitionClass.double_quote) + 1].next_state := TransitionState.finish; (* Leading zero. *) - set_default_transition(transitionStateLeadingZero, transition_action_integer, transitionStateEnd); + set_default_transition(TransitionState.leading_zero, transition_action_integer, TransitionState.finish); - transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassDigit) + 1].action := nil; - transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassDigit) + 1].next_state := transitionStateEnd; + transitions[ORD(TransitionState.leading_zero) + 1][ORD(TransitionClass.digit) + 1].action := nil; + transitions[ORD(TransitionState.leading_zero) + 1][ORD(TransitionClass.digit) + 1].next_state := TransitionState.finish; - transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassAlpha) + 1].action := nil; - transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassAlpha) + 1].next_state := transitionStateEnd; + transitions[ORD(TransitionState.leading_zero) + 1][ORD(TransitionClass.alpha) + 1].action := nil; + transitions[ORD(TransitionState.leading_zero) + 1][ORD(TransitionClass.alpha) + 1].next_state := TransitionState.finish; - transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassUnderscore) + 1].action := nil; - transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassUnderscore) + 1].next_state := transitionStateEnd; + transitions[ORD(TransitionState.leading_zero) + 1][ORD(TransitionClass.underscore) + 1].action := nil; + transitions[ORD(TransitionState.leading_zero) + 1][ORD(TransitionClass.underscore) + 1].next_state := TransitionState.finish; - transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassHex) + 1].action := nil; - transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassHex) + 1].next_state := transitionStateEnd; + transitions[ORD(TransitionState.leading_zero) + 1][ORD(TransitionClass.hex) + 1].action := nil; + transitions[ORD(TransitionState.leading_zero) + 1][ORD(TransitionClass.hex) + 1].next_state := TransitionState.finish; - transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassZero) + 1].action := nil; - transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassZero) + 1].next_state := transitionStateEnd; + transitions[ORD(TransitionState.leading_zero) + 1][ORD(TransitionClass.zero) + 1].action := nil; + transitions[ORD(TransitionState.leading_zero) + 1][ORD(TransitionClass.zero) + 1].next_state := TransitionState.finish; - transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassX) + 1].action := nil; - transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassX) + 1].next_state := transitionStateEnd; + transitions[ORD(TransitionState.leading_zero) + 1][ORD(TransitionClass.x) + 1].action := nil; + transitions[ORD(TransitionState.leading_zero) + 1][ORD(TransitionClass.x) + 1].next_state := TransitionState.finish; (* Digit with a character suffix. *) - set_default_transition(transitionStateDecimalSuffix, transition_action_integer, transitionStateEnd); + set_default_transition(TransitionState.decimal_suffix, transition_action_integer, TransitionState.finish); - transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassAlpha) + 1].action := nil; - transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassAlpha) + 1].next_state := transitionStateEnd; + transitions[ORD(TransitionState.decimal_suffix) + 1][ORD(TransitionClass.alpha) + 1].action := nil; + transitions[ORD(TransitionState.decimal_suffix) + 1][ORD(TransitionClass.alpha) + 1].next_state := TransitionState.finish; - transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassDigit) + 1].action := nil; - transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassDigit) + 1].next_state := transitionStateEnd; + transitions[ORD(TransitionState.decimal_suffix) + 1][ORD(TransitionClass.digit) + 1].action := nil; + transitions[ORD(TransitionState.decimal_suffix) + 1][ORD(TransitionClass.digit) + 1].next_state := TransitionState.finish; - transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassHex) + 1].action := nil; - transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassHex) + 1].next_state := transitionStateEnd; + transitions[ORD(TransitionState.decimal_suffix) + 1][ORD(TransitionClass.hex) + 1].action := nil; + transitions[ORD(TransitionState.decimal_suffix) + 1][ORD(TransitionClass.hex) + 1].next_state := TransitionState.finish; - transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassZero) + 1].action := nil; - transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassZero) + 1].next_state := transitionStateEnd; + transitions[ORD(TransitionState.decimal_suffix) + 1][ORD(TransitionClass.zero) + 1].action := nil; + transitions[ORD(TransitionState.decimal_suffix) + 1][ORD(TransitionClass.zero) + 1].next_state := TransitionState.finish; - transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassX) + 1].action := nil; - transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassX) + 1].next_state := transitionStateEnd + transitions[ORD(TransitionState.decimal_suffix) + 1][ORD(TransitionClass.x) + 1].action := nil; + transitions[ORD(TransitionState.decimal_suffix) + 1][ORD(TransitionClass.x) + 1].next_state := TransitionState.finish end; proc lexer_make*(lexer: ^Lexer, input: ^FILE); @@ -907,21 +904,21 @@ var index2: Word; begin lexer^.current := lexer^.start; - current_state := transitionStateStart; + current_state := TransitionState.start; - while current_state <> transitionStateEnd do + while current_state <> TransitionState.finish do index1 := ORD(lexer^.current.iterator^); - INC(index1); + index1 := index1 + 1u; current_class := classification[index1]; index1 := ORD(current_state); - INC(index1); + index1 := index1 + 1u; index2 := ORD(current_class); - INC(index2); + index2 := index + 1u; current_transition := transitions[index1][index2]; if current_transition.action <> nil then - current_transition.action(lexer, ADR(result)) + current_transition.action(lexer, @result) end; current_state := current_transition.next_state end; diff --git a/source/Parser.def b/source/Parser.def deleted file mode 100644 index a766e8e..0000000 --- a/source/Parser.def +++ /dev/null @@ -1,200 +0,0 @@ -DEFINITION MODULE Parser; - -FROM Common IMPORT Identifier, PIdentifier, ShortString; -FROM Lexer IMPORT PLexer; - -TYPE - Parser = RECORD - lexer: PLexer - END; - PParser = POINTER TO Parser; - - AstLiteralKind = ( - astLiteralKindInteger, - astLiteralKindString, - astLiteralKindNull, - astLiteralKindBoolean - ); - AstLiteral = RECORD - CASE kind: AstLiteralKind OF - astLiteralKindInteger: integer: INTEGER | - astLiteralKindString: string: ShortString | - astLiteralKindNull: | - astLiteralKindBoolean: boolean: BOOLEAN - END - END; - PAstLiteral = POINTER TO AstLiteral; - - AstUnaryOperator = ( - astUnaryOperatorReference, - astUnaryOperatorNot, - astUnaryOperatorMinus - ); - AstBinaryOperator = ( - astBinaryOperatorSum, - astBinaryOperatorSubtraction, - astBinaryOperatorMultiplication, - astBinaryOperatorDivision, - astBinaryOperatorRemainder, - astBinaryOperatorEquals, - astBinaryOperatorNotEquals, - astBinaryOperatorLess, - astBinaryOperatorGreater, - astBinaryOperatorLessEqual, - astBinaryOperatorGreaterEqual, - astBinaryOperatorDisjunction, - astBinaryOperatorConjunction, - astBinaryOperatorExclusiveDisjunction, - astBinaryOperatorShiftLeft, - astBinaryOperatorShiftRight - ); - - AstExpressionKind = ( - astExpressionKindLiteral, - astExpressionKindIdentifier, - astExpressionKindArrayAccess, - astExpressionKindDereference, - astExpressionKindFieldAccess, - astExpressionKindUnary, - astExpressionKindBinary, - astExpressionKindCall - ); - AstExpression = RECORD - CASE kind: AstExpressionKind OF - astExpressionKindLiteral: literal: PAstLiteral | - astExpressionKindIdentifier: identifier: Identifier | - astExpressionKindDereference: reference: PAstExpression | - astExpressionKindArrayAccess: - array: PAstExpression; - index: PAstExpression | - astExpressionKindFieldAccess: - aggregate: PAstExpression; - field: Identifier | - astExpressionKindUnary: - unary_operator: AstUnaryOperator; - unary_operand: PAstExpression | - astExpressionKindBinary: - binary_operator: AstBinaryOperator; - lhs: PAstExpression; - rhs: PAstExpression | - astExpressionKindCall: - callable: PAstExpression; - argument_count: CARDINAL; - arguments: PPAstExpression - END - END; - PAstExpression = POINTER TO AstExpression; - PPAstExpression = POINTER TO PAstExpression; - - AstStatementKind = ( - astStatementKindIf, - astStatementKindWhile, - astStatementKindAssignment, - astStatementKindReturn, - astStatementKindCall - ); - AstStatement = RECORD - CASE kind: AstStatementKind OF - astStatementKindIf: - if_condition: PAstExpression; - if_branch: AstCompoundStatement | - astStatementKindWhile: - while_condition: PAstExpression; - while_body: AstCompoundStatement | - astStatementKindAssignment: - assignee: PAstExpression; - assignment: PAstExpression | - astStatementKindReturn: returned: PAstExpression | - astStatementKindCall: call: PAstExpression - END - END; - PAstStatement = POINTER TO AstStatement; - PPAstStatement = POINTER TO PAstStatement; - AstCompoundStatement = RECORD - count: CARDINAL; - statements: PPAstStatement - END; - - AstImportStatement = RECORD - package: Identifier; - symbols: PIdentifier - END; - PAstImportStatement = POINTER TO AstImportStatement; - PPAstImportStatement = POINTER TO PAstImportStatement; - - AstConstantDeclaration = RECORD - constant_name: Identifier; - constant_value: INTEGER - END; - PAstConstantDeclaration = POINTER TO AstConstantDeclaration; - PPAstConstantDeclaration = POINTER TO PAstConstantDeclaration; - - AstFieldDeclaration = RECORD - field_name: Identifier; - field_type: PAstTypeExpression - END; - PAstFieldDeclaration = POINTER TO AstFieldDeclaration; - - AstTypeExpressionKind = ( - astTypeExpressionKindNamed, - astTypeExpressionKindRecord, - astTypeExpressionKindEnumeration, - astTypeExpressionKindArray, - astTypeExpressionKindPointer, - astTypeExpressionKindProcedure - ); - AstTypeExpression = RECORD - CASE kind: AstTypeExpressionKind OF - astTypeExpressionKindNamed: name: Identifier | - astTypeExpressionKindEnumeration: cases: PIdentifier | - astTypeExpressionKindPointer: target: PAstTypeExpression | - astTypeExpressionKindRecord: fields: PAstFieldDeclaration | - astTypeExpressionKindArray: - base: PAstTypeExpression; - length: CARDINAL | - astTypeExpressionKindProcedure: parameters: PPAstTypeExpression - END - END; - PAstTypeExpression = POINTER TO AstTypeExpression; - PPAstTypeExpression = POINTER TO PAstTypeExpression; - - AstTypedDeclaration = RECORD - identifier: Identifier; - type_expression: PAstTypeExpression - END; - PAstTypedDeclaration = POINTER TO AstTypedDeclaration; - PPAstTypedDeclaration = POINTER TO PAstTypedDeclaration; - - AstVariableDeclaration = RECORD - variable_name: Identifier; - variable_type: PAstTypeExpression - END; - PAstVariableDeclaration = POINTER TO AstVariableDeclaration; - PPAstVariableDeclaration = POINTER TO PAstVariableDeclaration; - - AstProcedureDeclaration = RECORD - name: Identifier; - parameter_count: CARDINAL; - parameters: PAstTypedDeclaration; - return_type: PAstTypeExpression; - constants: PPAstConstantDeclaration; - variables: PPAstVariableDeclaration; - statements: AstCompoundStatement - END; - PAstProcedureDeclaration = POINTER TO AstProcedureDeclaration; - PPAstProcedureDeclaration = POINTER TO PAstProcedureDeclaration; - - AstModule = RECORD - main: BOOLEAN; - imports: PPAstImportStatement; - constants: PPAstConstantDeclaration; - types: PPAstTypedDeclaration; - variables: PPAstVariableDeclaration; - procedures: PPAstProcedureDeclaration; - statements: AstCompoundStatement - END; - PAstModule = POINTER TO AstModule; - -PROCEDURE parse(lexer: PLexer): PAstModule; - -END Parser. diff --git a/source/Parser.elna b/source/Parser.elna index d870036..30958c0 100644 --- a/source/Parser.elna +++ b/source/Parser.elna @@ -1,15 +1,201 @@ +(* This Source Code Form is subject to the terms of the Mozilla Public License, + v. 2.0. If a copy of the MPL was not distributed with this file, You can + obtain one at https://mozilla.org/MPL/2.0/. *) module; from FIO import ReadNBytes; -from SYSTEM import TSIZE, ADR; from MemUtils import MemZero; from Storage import ALLOCATE, REALLOCATE; +from Common import Identifier, ShortString; from Lexer import Lexer, LexerKind, LexerToken, lexer_current, lexer_lex; +type + Parser = record + lexer: ^Lexer + end; + + AstLiteralKind* = ( + integer, + string, + null, + boolean + ); + AstLiteral* = record + kind: AstLiteralKind; + value: union + integer: Int; + string: ShortString; + boolean: Bool + end + end; + + AstUnaryOperator* = ( + reference, + not, + minus + ); + AstBinaryOperator* = ( + sum, + subtraction, + multiplication, + division, + remainder, + equals, + not_equals, + less, + greater, + less_equal, + greater_equal, + disjunction, + conjunction, + exclusive_disjunction, + shift_left, + shift_right + ); + + AstExpressionKind* = ( + literal, + identifier, + array_access, + dereference, + field_access, + unary, + binary, + call + ); + AstExpression* = record + kind: AstExpressionKind + value: union + literal: ^AstLiteral; + identifier: Identifier; + reference: ^AstExpression; + array_access: record + array: ^AstExpression; + index: ^AstExpression + end; + field_access: record + aggregate: ^AstExpression; + field: Identifier + end; + unary: record + operator: AstUnaryOperator; + operand: ^AstExpression + end; + binary: record + operator: AstBinaryOperator; + lhs: ^AstExpression; + rhs: ^AstExpression + end; + call: record + callable: ^AstExpression; + argument_count: Word; + arguments: ^^AstExpression + end + end + end; + + ConditionalStatement = record + condition: ^AstExpression; + branch: AstCompoundStatement + end; + + AstStatementKind* = ( + if_statement, + while_statement, + assignment_statement, + return_statement, + call_statement + ); + AstStatement* = record + kind: AstStatementKind + value: union + if_statement: ConditionalStatement; + while_statement: ConditionalStatement; + assignment_statement: record + assignee: ^AstExpression; + assignment: ^AstExpression + end; + return_statement: ^AstExpression; + call_statement: ^AstExpression + end + end; + AstCompoundStatement* = record + count: Word; + statements: ^^AstStatement + end; + + AstImportStatement* = record + package: Identifier; + symbols: ^Identifier + end; + + AstConstantDeclaration* = record + constant_name: Identifier; + constant_value: Int + end; + + AstFieldDeclaration* = record + field_name: Identifier; + field_type: ^AstTypeExpression + end; + + AstTypeExpressionKind* = ( + named_expression, + record_expression, + enumeration_expression, + array_expression, + pointer_expression, + procedure_expression + ); + AstTypeExpression* = record + kind: AstTypeExpressionKind; + value: union + name: Identifier; + cases: ^Identifier; + target: ^AstTypeExpression; + fields: ^AstFieldDeclaration; + array_expression: record + base: ^AstTypeExpression; + length: Word + end; + parameters: ^^AstTypeExpression + end + end; + + AstTypedDeclaration* = record + identifier: Identifier; + type_expression: ^AstTypeExpression + end; + + AstVariableDeclaration* = record + variable_name: Identifier; + variable_type: ^AstTypeExpression + end; + + AstProcedureDeclaration* = record + name: Identifier; + parameter_count: Word; + parameters: ^AstTypedDeclaration; + return_type: ^AstTypeExpression; + constants: ^^AstConstantDeclaration; + variables: ^^AstVariableDeclaration; + statements: AstCompoundStatement + end; + + AstModule* = record + main: Bool; + imports: ^^AstImportStatement; + constants: ^^AstConstantDeclaration; + types: ^^AstTypedDeclaration; + variables: ^^AstVariableDeclaration; + procedures: ^^AstProcedureDeclaration; + statements: AstCompoundStatement + end; + (* Calls lexer_lex() but skips the comments. *) -proc parser_lex(lexer: PLexer) -> LexerToken; +proc parser_lex(lexer: ^Lexer) -> LexerToken; var result: LexerToken; begin @@ -22,24 +208,24 @@ begin return result end; -proc parse_type_fields(parser: PParser) -> PAstFieldDeclaration; +proc parse_type_fields(parser: ^Parser) -> ^AstFieldDeclaration; var token: LexerToken; - field_declarations: PAstFieldDeclaration; - field_count: CARDINAL; - current_field: PAstFieldDeclaration; + field_declarations: ^AstFieldDeclaration; + field_count: Word; + current_field: ^AstFieldDeclaration; begin - ALLOCATE(field_declarations, TSIZE(AstFieldDeclaration)); + ALLOCATE(field_declarations, #size(AstFieldDeclaration)); token := parser_lex(parser^.lexer); field_count := 0; while token.kind <> lexerKindEnd do - INC(field_count); - INC(field_count); - REALLOCATE(field_declarations, TSIZE(AstFieldDeclaration) * field_count); - DEC(field_count); + field_count := field_count + 2u; + + REALLOCATE(field_declarations, #size(AstFieldDeclaration) * field_count); + field_count := field_count - 1u; current_field := field_declarations; - INC(current_field , TSIZE(AstFieldDeclaration) * (field_count - 1)); + INC(current_field , #size(AstFieldDeclaration) * (field_count - 1)); token := parser_lex(parser^.lexer); @@ -53,30 +239,30 @@ begin token := parser_lex(parser^.lexer) end end; - INC(current_field, TSIZE(AstFieldDeclaration)); - MemZero(current_field, TSIZE(AstFieldDeclaration)); + INC(current_field, #size(AstFieldDeclaration)); + MemZero(current_field, #size(AstFieldDeclaration)); return field_declarations end; -proc parse_record_type(parser: PParser) -> PAstTypeExpression; +proc parse_record_type(parser: ^Parser) -> ^AstTypeExpression; var - result: PAstTypeExpression; + result: ^AstTypeExpression; begin NEW(result); - result^.kind := astTypeExpressionKindRecord; + result^.kind := AstTypeExpressionKind.record_expression; result^.fields := parse_type_fields(parser); return result end; -proc parse_pointer_type(parser: PParser) -> PAstTypeExpression; +proc parse_pointer_type(parser: ^Parser) -> ^AstTypeExpression; var token: LexerToken; - result: PAstTypeExpression; + result: ^AstTypeExpression; begin NEW(result); - result^.kind := astTypeExpressionKindPointer; + result^.kind := AstTypeExpressionKind.pointer_expression; token := lexer_current(parser^.lexer); @@ -89,15 +275,15 @@ begin return result end; -proc parse_array_type(parser: PParser) -> PAstTypeExpression; +proc parse_array_type(parser: ^Parser) -> ^AstTypeExpression; var token: LexerToken; buffer: [20]CHAR; - result: PAstTypeExpression; + result: ^AstTypeExpression; begin NEW(result); - result^.kind := astTypeExpressionKindArray; - result^.length := 0; + result^.kind := AstTypeExpressionKind.array_expression; + result^.array_expression.length := 0u; token := lexer_current(parser^.lexer); @@ -107,28 +293,28 @@ begin if token.kind <> lexerKindOf then token := parser_lex(parser^.lexer); - result^.length := token.integerKind; + result^.array_expression.length := token.integerKind; token := parser_lex(parser^.lexer) end; token := parser_lex(parser^.lexer); - result^.base := parse_type_expression(parser); + result^.array_expression.base := parse_type_expression(parser); return result end; -proc parse_enumeration_type(parser: PParser) -> PAstTypeExpression; +proc parse_enumeration_type(parser: ^Parser) -> ^AstTypeExpression; var token: LexerToken; - result: PAstTypeExpression; - current_case: PIdentifier; - case_count: CARDINAL; + result: ^AstTypeExpression; + current_case: ^Identifier; + case_count: Word; begin NEW(result); - result^.kind := astTypeExpressionKindEnumeration; + result^.kind := AstTypeExpressionKind.enumeration_expression; case_count := 1; - ALLOCATE(result^.cases, TSIZE(Identifier) * 2); + ALLOCATE(result^.cases, #size(Identifier) * 2); token := parser_lex(parser^.lexer); current_case := result^.cases; current_case^ := token.identifierKind; @@ -138,46 +324,46 @@ begin while token.kind = lexerKindComma do token := parser_lex(parser^.lexer); - INC(case_count); - INC(case_count); - REALLOCATE(result^.cases, TSIZE(Identifier) * case_count); - DEC(case_count); + case_count := case_count + 2u; + + REALLOCATE(result^.cases, #size(Identifier) * case_count); + case_count := case_count - 1u; current_case := result^.cases; - INC(current_case, TSIZE(Identifier) * (case_count - 1)); + INC(current_case, #size(Identifier) * (case_count - 1)); current_case^ := token.identifierKind; token := parser_lex(parser^.lexer) end; - INC(current_case, TSIZE(Identifier)); - MemZero(current_case, TSIZE(Identifier)); + INC(current_case, #size(Identifier)); + MemZero(current_case, #size(Identifier)); return result end; -proc parse_named_type(parser: PParser) -> PAstTypeExpression; +proc parse_named_type(parser: ^Parser) -> ^AstTypeExpression; var token: LexerToken; - result: PAstTypeExpression; + result: ^AstTypeExpression; begin token := lexer_current(parser^.lexer); NEW(result); - result^.kind := astTypeExpressionKindNamed; + result^.kind := AstTypeExpressionKind.named_expression; result^.name := token.identifierKind; return result end; -proc parse_procedure_type(parser: PParser) -> PAstTypeExpression; +proc parse_procedure_type(parser: ^Parser) -> ^AstTypeExpression; var token: LexerToken; - result: PAstTypeExpression; - current_parameter: PPAstTypeExpression; - parameter_count: CARDINAL; + result: ^AstTypeExpression; + current_parameter: ^^AstTypeExpression; + parameter_count: Word; begin parameter_count := 0; NEW(result); - result^.kind := astTypeExpressionKindProcedure; + result^.kind := AstTypeExpressionKind.procedure_expression; ALLOCATE(result^.parameters, 1); @@ -185,12 +371,12 @@ begin token := parser_lex(parser^.lexer); while token.kind <> lexerKindRightParen do - INC(parameter_count); - INC(parameter_count); - REALLOCATE(result^.parameters, TSIZE(PAstTypeExpression) * parameter_count); - DEC(parameter_count); + parameter_count := parameter_count + 2u; + + REALLOCATE(result^.parameters, #size(^AstTypeExpression) * parameter_count); + parameter_count := parameter_count - 1u; current_parameter := result^.parameters; - INC(current_parameter, TSIZE(PAstTypeExpression) * (parameter_count - 1)); + INC(current_parameter, #size(^AstTypeExpression) * (parameter_count - 1)); current_parameter^ := parse_type_expression(parser); @@ -200,16 +386,16 @@ begin end end; current_parameter := result^.parameters; - INC(current_parameter, TSIZE(PAstTypeExpression) * parameter_count); + INC(current_parameter, #size(^AstTypeExpression) * parameter_count); current_parameter^ := nil; return result end; -proc parse_type_expression(parser: PParser) -> PAstTypeExpression; +proc parse_type_expression(parser: ^Parser) -> ^AstTypeExpression; var token: LexerToken; - result: PAstTypeExpression; + result: ^AstTypeExpression; begin result := nil; token := lexer_current(parser^.lexer); @@ -235,10 +421,10 @@ begin return result end; -proc parse_type_declaration(parser: PParser) -> PAstTypedDeclaration; +proc parse_type_declaration(parser: ^Parser) -> ^AstTypedDeclaration; var token: LexerToken; - result: PAstTypedDeclaration; + result: ^AstTypedDeclaration; begin token := lexer_current(parser^.lexer); @@ -254,45 +440,45 @@ begin return result end; -proc parse_type_part(parser: PParser) -> PPAstTypedDeclaration; +proc parse_type_part(parser: ^Parser) -> ^^AstTypedDeclaration; var token: LexerToken; - result: PPAstTypedDeclaration; - current_declaration: PPAstTypedDeclaration; - declaration_count: CARDINAL; + result: ^^AstTypedDeclaration; + current_declaration: ^^AstTypedDeclaration; + declaration_count: Word; begin token := lexer_current(parser^.lexer); - ALLOCATE(result, TSIZE(PAstTypedDeclaration)); + ALLOCATE(result, #size(^AstTypedDeclaration)); current_declaration := result; - declaration_count := 0; + declaration_count := 0u; if token.kind = lexerKindType then token := parser_lex(parser^.lexer); while token.kind = lexerKindIdentifier do - INC(declaration_count); + declaration_count := declaration_count + 1u; - REALLOCATE(result, TSIZE(PAstTypedDeclaration) * (declaration_count + 1)); + REALLOCATE(result, #size(^AstTypedDeclaration) * (declaration_count + 1)); current_declaration := result; - INC(current_declaration, TSIZE(PAstTypedDeclaration) * (declaration_count - 1)); + INC(current_declaration, #size(^AstTypedDeclaration) * (declaration_count - 1)); current_declaration^ := parse_type_declaration(parser); token := parser_lex(parser^.lexer) end end; - if declaration_count <> 0 then - INC(current_declaration, TSIZE(PAstTypedDeclaration)) + if declaration_count <> 0u then + INC(current_declaration, #size(^AstTypedDeclaration)) end; current_declaration^ := nil; return result end; -proc parse_variable_declaration(parser: PParser) -> PAstVariableDeclaration; +proc parse_variable_declaration(parser: ^Parser) -> ^AstVariableDeclaration; var token: LexerToken; - result: PAstVariableDeclaration; + result: ^AstVariableDeclaration; begin NEW(result); @@ -308,16 +494,16 @@ begin return result end; -proc parse_variable_part(parser: PParser) -> PPAstVariableDeclaration; +proc parse_variable_part(parser: ^Parser) -> ^^AstVariableDeclaration; var token: LexerToken; - result: PPAstVariableDeclaration; - current_declaration: PPAstVariableDeclaration; - declaration_count: CARDINAL; + result: ^^AstVariableDeclaration; + current_declaration: ^^AstVariableDeclaration; + declaration_count: Word; begin token := lexer_current(parser^.lexer); - ALLOCATE(result, TSIZE(PAstVariableDeclaration)); + ALLOCATE(result, #size(^AstVariableDeclaration)); current_declaration := result; declaration_count := 0; @@ -325,28 +511,28 @@ begin token := parser_lex(parser^.lexer); while token.kind = lexerKindIdentifier do - INC(declaration_count); + declaration_count := declaration_count + 1u; - REALLOCATE(result, TSIZE(PAstVariableDeclaration) * (declaration_count + 1)); + REALLOCATE(result, #size(^AstVariableDeclaration) * (declaration_count + 1)); current_declaration := result; - INC(current_declaration, TSIZE(PAstVariableDeclaration) * (declaration_count - 1)); + INC(current_declaration, #size(^AstVariableDeclaration) * (declaration_count - 1)); current_declaration^ := parse_variable_declaration(parser); token := parser_lex(parser^.lexer) end end; if declaration_count <> 0 then - INC(current_declaration, TSIZE(PAstVariableDeclaration)) + INC(current_declaration, #size(^AstVariableDeclaration)) end; current_declaration^ := nil; return result end; -proc parse_constant_declaration(parser: PParser) -> PAstConstantDeclaration; +proc parse_constant_declaration(parser: ^Parser) -> ^AstConstantDeclaration; var token: LexerToken; - result: PAstConstantDeclaration; + result: ^AstConstantDeclaration; begin NEW(result); @@ -363,16 +549,16 @@ begin return result end; -proc parse_constant_part(parser: PParser) -> PPAstConstantDeclaration; +proc parse_constant_part(parser: ^Parser) -> ^^AstConstantDeclaration; var token: LexerToken; - result: PPAstConstantDeclaration; - current_declaration: PPAstConstantDeclaration; - declaration_count: CARDINAL; + result: ^^AstConstantDeclaration; + current_declaration: ^^AstConstantDeclaration; + declaration_count: Word; begin token := lexer_current(parser^.lexer); - ALLOCATE(result, TSIZE(PAstConstantDeclaration)); + ALLOCATE(result, #size(^AstConstantDeclaration)); current_declaration := result; declaration_count := 0; @@ -380,39 +566,39 @@ begin token := parser_lex(parser^.lexer); while token.kind = lexerKindIdentifier do - INC(declaration_count); + declaration_count := declaration_count + 1u; - REALLOCATE(result, TSIZE(PAstConstantDeclaration) * (declaration_count + 1)); + REALLOCATE(result, #size(^AstConstantDeclaration) * (declaration_count + 1)); current_declaration := result; - INC(current_declaration, TSIZE(PAstConstantDeclaration) * (declaration_count - 1)); + INC(current_declaration, #size(^AstConstantDeclaration) * (declaration_count - 1)); current_declaration^ := parse_constant_declaration(parser); token := parser_lex(parser^.lexer) end end; if declaration_count <> 0 then - INC(current_declaration, TSIZE(PAstConstantDeclaration)) + INC(current_declaration, #size(^AstConstantDeclaration)) end; current_declaration^ := nil; return result end; -proc parse_import_statement(parser: PParser) -> PAstImportStatement; +proc parse_import_statement(parser: ^Parser) -> ^AstImportStatement; var - result: PAstImportStatement; + result: ^AstImportStatement; token: LexerToken; - symbol_count: CARDINAL; - current_symbol: PIdentifier; + symbol_count: Word; + current_symbol: ^Identifier; begin NEW(result); - symbol_count := 1; + symbol_count := 1u; token := parser_lex(parser^.lexer); result^.package := token.identifierKind; token := parser_lex(parser^.lexer); - ALLOCATE(result^.symbols, TSIZE(Identifier) * 2); + ALLOCATE(result^.symbols, #size(Identifier) * 2); current_symbol := result^.symbols; @@ -422,56 +608,56 @@ begin token := parser_lex(parser^.lexer); while token.kind <> lexerKindSemicolon do token := parser_lex(parser^.lexer); - INC(symbol_count); + symbol_count := symbol_count + 1u; - REALLOCATE(result^.symbols, TSIZE(Identifier) * (symbol_count + 1)); + REALLOCATE(result^.symbols, #size(Identifier) * (symbol_count + 1)); current_symbol := result^.symbols; - INC(current_symbol, TSIZE(Identifier) * (symbol_count - 1)); + INC(current_symbol, #size(Identifier) * (symbol_count - 1)); current_symbol^ := token.identifierKind; token := parser_lex(parser^.lexer) end; - INC(current_symbol, TSIZE(Identifier)); - MemZero(current_symbol, TSIZE(Identifier)); + INC(current_symbol, #size(Identifier)); + MemZero(current_symbol, #size(Identifier)); token := parser_lex(parser^.lexer); return result end; -proc parse_import_part(parser: PParser) -> PPAstImportStatement; +proc parse_import_part(parser: ^Parser) -> ^^AstImportStatement; var token: LexerToken; - import_statement: PPAstImportStatement; - result: PPAstImportStatement; - import_count: CARDINAL; + import_statement: ^^AstImportStatement; + result: ^^AstImportStatement; + import_count: Word; begin token := lexer_current(parser^.lexer); - ALLOCATE(result, TSIZE(PAstImportStatement)); + ALLOCATE(result, #size(^AstImportStatement)); import_statement := result; - import_count := 0; + import_count := 0u; while token.kind = lexerKindFrom do - INC(import_count); + import_count := import_count + 1u; - REALLOCATE(result, TSIZE(PAstImportStatement) * (import_count + 1)); + REALLOCATE(result, #size(^AstImportStatement) * (import_count + 1)); import_statement := result; - INC(import_statement, TSIZE(PAstImportStatement) * (import_count - 1)); + INC(import_statement, #size(^AstImportStatement) * (import_count - 1)); import_statement^ := parse_import_statement(parser); token := lexer_current(parser^.lexer) end; if import_count > 0 then - INC(import_statement, TSIZE(PAstImportStatement)) + INC(import_statement, #size(^AstImportStatement)) end; import_statement^ := nil; return result end; -proc parse_literal(parser: PParser) -> PAstLiteral; +proc parse_literal(parser: ^Parser) -> ^AstLiteral; var - literal: PAstLiteral; + literal: ^AstLiteral; token: LexerToken; begin literal := nil; @@ -480,24 +666,24 @@ begin if token.kind = lexerKindInteger then NEW(literal); - literal^.kind := astLiteralKindInteger; + literal^.kind := AstLiteralKind.integer; literal^.integer := token.integerKind end; if (token.kind = lexerKindCharacter) or (token.kind = lexerKindString) then NEW(literal); - literal^.kind := astLiteralKindString; + literal^.kind := AstLiteralKind.string; literal^.string := token.stringKind end; if token.kind = lexerKindNull then NEW(literal); - literal^.kind := astLiteralKindNull + literal^.kind := AstLiteralKind.null end; if token.kind = lexerKindBoolean then NEW(literal); - literal^.kind := astLiteralKindBoolean; + literal^.kind := AstLiteralKind.boolean; literal^.boolean := token.booleanKind end; if literal <> nil then @@ -507,11 +693,11 @@ begin return literal end; -proc parse_factor(parser: PParser) -> PAstExpression; +proc parse_factor(parser: ^Parser) -> ^AstExpression; var next_token: LexerToken; - result: PAstExpression; - literal: PAstLiteral; + result: ^AstExpression; + literal: ^AstLiteral; begin result := nil; next_token := lexer_current(parser^.lexer); @@ -521,24 +707,24 @@ begin if (result = nil) & (literal <> nil) then NEW(result); - result^.kind := astExpressionKindLiteral; + result^.kind := AstExpressionKind.literal; result^.literal := literal end; if (result = nil) & (next_token.kind = lexerKindMinus) then NEW(result); next_token := parser_lex(parser^.lexer); - result^.kind := astExpressionKindUnary; - result^.unary_operator := astUnaryOperatorMinus; - result^.unary_operand := parse_factor(parser) + result^.kind := AstExpressionKind.unary; + result^.unary.operator := AstUnaryOperator.minus; + result^.unary.operand := parse_factor(parser) end; if (result = nil) & (next_token.kind = lexerKindTilde) then NEW(result); next_token := parser_lex(parser^.lexer); - result^.kind := astExpressionKindUnary; - result^.unary_operator := astUnaryOperatorNot; - result^.unary_operand := parse_factor(parser) + result^.kind := AstExpressionKind.unary; + result^.unary.operator := AstUnaryOperator.not; + result^.unary.operand := parse_factor(parser) end; if (result = nil) & (next_token.kind = lexerKindLeftParen) then next_token := parser_lex(parser^.lexer); @@ -550,7 +736,7 @@ begin if (result = nil) & (next_token.kind = lexerKindIdentifier) then NEW(result); - result^.kind := astExpressionKindIdentifier; + result^.kind := AstExpressionKind.identifier; result^.identifier := next_token.identifierKind; next_token := parser_lex(parser^.lexer) @@ -559,13 +745,13 @@ begin return result end; -proc parse_designator(parser: PParser) -> PAstExpression; +proc parse_designator(parser: ^Parser) -> ^AstExpression; var next_token: LexerToken; - inner_expression: PAstExpression; - designator: PAstExpression; - arguments: PPAstExpression; - handled: BOOLEAN; + inner_expression: ^AstExpression; + designator: ^AstExpression; + arguments: ^^AstExpression; + handled: Bool; begin designator := parse_factor(parser); handled := designator <> nil; @@ -578,7 +764,7 @@ begin if ~handled & (next_token.kind = lexerKindHat) then NEW(designator); - designator^.kind := astExpressionKindDereference; + designator^.kind := AstExpressionKind.dereference; designator^.reference := inner_expression; next_token := parser_lex(parser^.lexer); @@ -588,9 +774,9 @@ begin NEW(designator); next_token := parser_lex(parser^.lexer); - designator^.kind := astExpressionKindArrayAccess; - designator^.array := inner_expression; - designator^.index := parse_expression(parser); + designator^.kind := AstExpressionKind.array_access; + designator^.array_access.array := inner_expression; + designator^.array_access.index := parse_expression(parser); next_token := parser_lex(parser^.lexer); handled := true @@ -599,9 +785,9 @@ begin NEW(designator); next_token := parser_lex(parser^.lexer); - designator^.kind := astExpressionKindFieldAccess; - designator^.aggregate := inner_expression; - designator^.field := next_token.identifierKind; + designator^.kind := AstExpressionKind.field_access; + designator^.field_access.aggregate := inner_expression; + designator^.field_access.field := next_token.identifierKind; next_token := parser_lex(parser^.lexer); handled := true @@ -610,13 +796,13 @@ begin NEW(designator); next_token := parser_lex(parser^.lexer); - designator^.kind := astExpressionKindCall; - designator^.callable := inner_expression; - designator^.argument_count := 0; - designator^.arguments := nil; + designator^.kind := AstExpressionKind.call; + designator^.call.callable := inner_expression; + designator^.call.argument_count := 0; + designator^.call.arguments := nil; if next_token.kind <> lexerKindRightParen then - ALLOCATE(designator^.arguments, TSIZE(PAstExpression)); + ALLOCATE(designator^.arguments, #size(^AstExpression)); designator^.argument_count := 1; designator^.arguments^ := parse_expression(parser); @@ -626,9 +812,9 @@ begin next_token := parser_lex(parser^.lexer); designator^.argument_count := designator^.argument_count + 1; - REALLOCATE(designator^.arguments, TSIZE(PAstExpression) * designator^.argument_count); + REALLOCATE(designator^.arguments, #size(^AstExpression) * designator^.argument_count); arguments := designator^.arguments; - INC(arguments, TSIZE(PAstExpression) * (designator^.argument_count - 1)); + INC(arguments, #size(^AstExpression) * (designator^.argument_count - 1)); arguments^ := parse_expression(parser); next_token := lexer_current(parser^.lexer) @@ -643,11 +829,11 @@ begin return designator end; -proc parse_binary_expression(parser: PParser, left: PAstExpression, operator: AstBinaryOperator) -> PAstExpression; +proc parse_binary_expression(parser: ^Parser, left: ^AstExpression, operator: AstBinaryOperator) -> ^AstExpression; var next_token: LexerToken; - result: PAstExpression; - right: PAstExpression; + result: ^AstExpression; + right: ^AstExpression; begin next_token := parser_lex(parser^.lexer); right := parse_designator(parser); @@ -655,21 +841,21 @@ begin if right <> nil then NEW(result); - result^.kind := astExpressionKindBinary; - result^.binary_operator := operator; - result^.lhs := left; - result^.rhs := right + result^.kind := AstExpressionKind.binary; + result^.binary.operator := operator; + result^.binary.lhs := left; + result^.binary.rhs := right end; return result end; -proc parse_expression(parser: PParser) -> PAstExpression; +proc parse_expression(parser: ^Parser) -> ^AstExpression; var next_token: LexerToken; - left: PAstExpression; - result: PAstExpression; - written_bytes: CARDINAL; + left: ^AstExpression; + result: ^AstExpression; + written_bytes: Word; begin left := parse_designator(parser); result := nil; @@ -677,37 +863,37 @@ begin if left <> nil then if (result = nil) & (next_token.kind = lexerKindNotEqual) then - result := parse_binary_expression(parser, left, astBinaryOperatorNotEquals) + result := parse_binary_expression(parser, left, AstBinaryOperator.not_equals) end; if (result = nil) & (next_token.kind = lexerKindEqual) then - result := parse_binary_expression(parser, left, astBinaryOperatorEquals) + result := parse_binary_expression(parser, left, AstBinaryOperator.equals) end; if (result = nil) & (next_token.kind = lexerKindGreaterThan) then - result := parse_binary_expression(parser, left, astBinaryOperatorGreater) + result := parse_binary_expression(parser, left, AstBinaryOperator.greater) end; if (result = nil) & (next_token.kind = lexerKindLessThan) then - result := parse_binary_expression(parser, left, astBinaryOperatorLess) + result := parse_binary_expression(parser, left, AstBinaryOperator.less) end; if (result = nil) & (next_token.kind = lexerKindGreaterEqual) then - result := parse_binary_expression(parser, left, astBinaryOperatorGreaterEqual) + result := parse_binary_expression(parser, left, AstBinaryOperator.greater_equal) end; if (result = nil) & (next_token.kind = lexerKindLessEqual) then - result := parse_binary_expression(parser, left, astBinaryOperatorLessEqual) + result := parse_binary_expression(parser, left, AstBinaryOperator.less_equal) end; if (result = nil) & (next_token.kind = lexerKindAnd) then - result := parse_binary_expression(parser, left, astBinaryOperatorConjunction) + result := parse_binary_expression(parser, left, AstBinaryOperator.conjunction) end; if (result = nil) & (next_token.kind = lexerKindOr) then - result := parse_binary_expression(parser, left, astBinaryOperatorDisjunction) + result := parse_binary_expression(parser, left, AstBinaryOperator.disjunction) end; if (result = nil) & (next_token.kind = lexerKindMinus) then - result := parse_binary_expression(parser, left, astBinaryOperatorSubtraction) + result := parse_binary_expression(parser, left, AstBinaryOperator.subtraction) end; if (result = nil) & (next_token.kind = lexerKindPlus) then - result := parse_binary_expression(parser, left, astBinaryOperatorSum) + result := parse_binary_expression(parser, left, AstBinaryOperator.sum) end; if (result = nil) & (next_token.kind = lexerKindAsterisk) then - result := parse_binary_expression(parser, left, astBinaryOperatorMultiplication) + result := parse_binary_expression(parser, left, AstBinaryOperator.multiplication) end end; if (result = nil) & (left <> nil) then @@ -717,66 +903,66 @@ begin return result end; -proc parse_return_statement(parser: PParser) -> PAstStatement; +proc parse_return_statement(parser: ^Parser) -> ^AstStatement; var token: LexerToken; - result: PAstStatement; + result: ^AstStatement; begin NEW(result); - result^.kind := astStatementKindReturn; + result^.kind := AstStatementKind.return_statement; token := parser_lex(parser^.lexer); - result^.returned := parse_expression(parser); + result^.return_statement := parse_expression(parser); return result end; -proc parse_assignment_statement(parser: PParser, assignee: PAstExpression) -> PAstStatement; +proc parse_assignment_statement(parser: ^Parser, assignee: ^AstExpression) -> ^AstStatement; var token: LexerToken; - result: PAstStatement; + result: ^AstStatement; begin NEW(result); - result^.kind := astStatementKindAssignment; - result^.assignee := assignee; + result^.kind := AstStatementKind.assignment_statement; + result^.assignment_statement.assignee := assignee; token := parser_lex(parser^.lexer); - result^.assignment := parse_expression(parser); + result^.assignment_statement.assignment := parse_expression(parser); return result end; -proc parse_call_statement(parser: PParser, call: PAstExpression) -> PAstStatement; +proc parse_call_statement(parser: ^Parser, call: ^AstExpression) -> ^AstStatement; var - result: PAstStatement; + result: ^AstStatement; begin NEW(result); - result^.kind := astStatementKindCall; - result^.call := call; + result^.kind := AstStatementKind.call_statement; + result^.call_statement := call; return result end; -proc parse_compound_statement(parser: PParser) -> AstCompoundStatement; +proc parse_compound_statement(parser: ^Parser) -> AstCompoundStatement; var result: AstCompoundStatement; token: LexerToken; - current_statement: PPAstStatement; - old_count: CARDINAL; + current_statement: ^^AstStatement; + old_count: Word; begin - result.count := 0; + result.count := 0u; result.statements := nil; token := lexer_current(parser^.lexer); while token.kind <> lexerKindEnd do old_count := result.count; - INC(result.count); + result.count := result.count + 1u; - REALLOCATE(result.statements, TSIZE(PAstStatement) * result.count); + REALLOCATE(result.statements, #size(^AstStatement) * result.count); current_statement := result.statements; - INC(current_statement, TSIZE(PAstStatement) * old_count); + INC(current_statement, #size(^AstStatement) * old_count); current_statement^ := parse_statement(parser); token := lexer_current(parser^.lexer) @@ -785,11 +971,11 @@ begin return result end; -proc parse_statement(parser: PParser) -> PAstStatement; +proc parse_statement(parser: ^Parser) -> ^AstStatement; var token: LexerToken; - statement: PAstStatement; - designator: PAstExpression; + statement: ^AstStatement; + designator: ^AstExpression; begin statement := nil; token := parser_lex(parser^.lexer); @@ -817,39 +1003,39 @@ begin return statement end; -proc parse_if_statement(parser: PParser) -> PAstStatement; +proc parse_if_statement(parser: ^Parser) -> ^AstStatement; var token: LexerToken; - result: PAstStatement; + result: ^AstStatement; begin NEW(result); - result^.kind := astStatementKindIf; + result^.kind := AstStatementKind.if_statement; token := parser_lex(parser^.lexer); - result^.if_condition := parse_expression(parser); - result^.if_branch := parse_compound_statement(parser); + result^.if_statement.condition := parse_expression(parser); + result^.if_statement.branch := parse_compound_statement(parser); token := parser_lex(parser^.lexer); return result end; -proc parse_while_statement(parser: PParser) -> PAstStatement; +proc parse_while_statement(parser: ^Parser) -> ^AstStatement; var token: LexerToken; - result: PAstStatement; + result: ^AstStatement; begin NEW(result); - result^.kind := astStatementKindWhile; + result^.kind := AstStatementKind.while_statement; token := parser_lex(parser^.lexer); - result^.while_condition := parse_expression(parser); - result^.while_body := parse_compound_statement(parser); + result^.while_statement.condition := parse_expression(parser); + result^.while_statement.body := parse_compound_statement(parser); token := parser_lex(parser^.lexer); return result end; -proc parse_statement_part(parser: PParser) -> AstCompoundStatement; +proc parse_statement_part(parser: ^Parser) -> AstCompoundStatement; var token: LexerToken; compound: AstCompoundStatement; @@ -865,12 +1051,12 @@ begin return compound end; -proc parse_procedure_heading(parser: PParser) -> PAstProcedureDeclaration; +proc parse_procedure_heading(parser: ^Parser) -> ^AstProcedureDeclaration; var token: LexerToken; - declaration: PAstProcedureDeclaration; - parameter_index: CARDINAL; - current_parameter: PAstTypedDeclaration; + declaration: ^AstProcedureDeclaration; + parameter_index: Word; + current_parameter: ^AstTypedDeclaration; begin NEW(declaration); @@ -886,10 +1072,10 @@ begin while token.kind <> lexerKindRightParen do parameter_index := declaration^.parameter_count; INC(declaration^.parameter_count); - REALLOCATE(declaration^.parameters, TSIZE(AstTypedDeclaration) * declaration^.parameter_count); + REALLOCATE(declaration^.parameters, #size(AstTypedDeclaration) * declaration^.parameter_count); current_parameter := declaration^.parameters; - INC(current_parameter, TSIZE(AstTypedDeclaration) * parameter_index); + INC(current_parameter, #size(AstTypedDeclaration) * parameter_index); current_parameter^.identifier := token.identifierKind; @@ -917,10 +1103,10 @@ begin return declaration end; -proc parse_procedure_declaration(parser: PParser) -> PAstProcedureDeclaration; +proc parse_procedure_declaration(parser: ^Parser) -> ^AstProcedureDeclaration; var token: LexerToken; - declaration: PAstProcedureDeclaration; + declaration: ^AstProcedureDeclaration; begin declaration := parse_procedure_heading(parser); @@ -934,41 +1120,41 @@ begin return declaration end; -proc parse_procedure_part(parser: PParser) -> PPAstProcedureDeclaration; +proc parse_procedure_part(parser: ^Parser) -> ^^AstProcedureDeclaration; var token: LexerToken; - current_declaration: PPAstProcedureDeclaration; - result: PPAstProcedureDeclaration; - declaration_count: CARDINAL; - declaration_index: CARDINAL; + current_declaration: ^^AstProcedureDeclaration; + result: ^^AstProcedureDeclaration; + declaration_count: Word; + declaration_index: Word; begin token := lexer_current(parser^.lexer); - declaration_count := 0; - declaration_index := 0; + declaration_count := 0u; + declaration_index := 0u; - ALLOCATE(result, TSIZE(PAstProcedureDeclaration)); + ALLOCATE(result, #size(^AstProcedureDeclaration)); while token.kind = lexerKindProc do - INC(declaration_count); - REALLOCATE(result, TSIZE(PAstProcedureDeclaration) * (declaration_count + 1)); + declaration_count := declaration_count + 1u; + REALLOCATE(result, #size(^AstProcedureDeclaration) * (declaration_count + 1)); current_declaration := result; - INC(current_declaration, TSIZE(PAstProcedureDeclaration) * declaration_index); + INC(current_declaration, #size(^AstProcedureDeclaration) * declaration_index); current_declaration^ := parse_procedure_declaration(parser); token := lexer_current(parser^.lexer); declaration_index := declaration_count end; current_declaration := result; - INC(current_declaration, TSIZE(PAstProcedureDeclaration) * declaration_index); + INC(current_declaration, #size(^AstProcedureDeclaration) * declaration_index); current_declaration^ := nil; return result end; -proc parse_module(parser: PParser) -> PAstModule; +proc parse_module(parser: ^Parser) -> ^AstModule; var token: LexerToken; - result: PAstModule; + result: ^AstModule; begin NEW(result); token := parser_lex(parser^.lexer); @@ -996,13 +1182,13 @@ begin return result end; -proc parse(lexer: PLexer) -> PAstModule; +proc parse*(lexer: ^Lexer) -> ^AstModule; var parser: Parser; begin parser.lexer := lexer; - return parse_module(ADR(parser)) + return parse_module(@parser) end; end. diff --git a/source/Transpiler.def b/source/Transpiler.def deleted file mode 100644 index 5f8c219..0000000 --- a/source/Transpiler.def +++ /dev/null @@ -1,20 +0,0 @@ -DEFINITION MODULE Transpiler; - -FROM FIO IMPORT File; - -FROM Common IMPORT ShortString; -FROM Lexer IMPORT PLexer, Lexer; -FROM Parser IMPORT PAstModule; - -TYPE - TranspilerContext = RECORD - input_name: ShortString; - output: File; - definition: File; - indentation: CARDINAL - END; - PTranspilerContext = POINTER TO TranspilerContext; - -PROCEDURE transpile(ast_module: PAstModule; output: File; definition: File; input_name: ShortString); - -END Transpiler. diff --git a/source/Transpiler.elna b/source/Transpiler.elna index 44b3e10..3eacc5a 100644 --- a/source/Transpiler.elna +++ b/source/Transpiler.elna @@ -1,27 +1,34 @@ +(* This Source Code Form is subject to the terms of the Mozilla Public License, + v. 2.0. If a copy of the MPL was not distributed with this file, You can + obtain one at https://mozilla.org/MPL/2.0/. *) module; -from FIO import WriteNBytes, WriteLine, WriteChar, WriteString; -from SYSTEM import ADR, TSIZE; - +from FIO import File, WriteNBytes, WriteLine, WriteChar, WriteString; from NumberIO import IntToStr; -from Common import Identifier, PIdentifier, ShortString; +from Common import Identifier, ShortString; from Parser import AstTypeExpressionKind, AstExpressionKind, AstLiteralKind, AstUnaryOperator, AstBinaryOperator, - PAstModule, PPAstExpression, PAstExpression, PAstLiteral, PPAstProcedureDeclaration, - PAstConstantDeclaration, PPAstConstantDeclaration, PPAstStatement, PAstStatement, AstStatementKind, - AstTypedDeclaration, PAstTypedDeclaration, PPAstTypedDeclaration, AstCompoundStatement, PAstProcedureDeclaration, - PAstVariableDeclaration, PPAstVariableDeclaration, PAstImportStatement, PPAstImportStatement, - PAstTypeExpression, PPAstTypeExpression, AstFieldDeclaration, PAstFieldDeclaration; + AstModule, AstExpression, AstLiteral, AstConstantDeclaration, AstStatement, AstStatementKind, + AstTypedDeclaration, AstCompoundStatement, AstProcedureDeclaration, + AstVariableDeclaration, AstImportStatement, AstTypeExpression, AstFieldDeclaration; -proc indent(context: PTranspilerContext); +type + TranspilerContext* = record + input_name: ShortString; + output: File; + definition: File; + indentation: Word + end; + +proc indent(context: ^TranspilerContext); var - count: CARDINAL; + count: Word; begin count := 0; while count < context^.indentation do WriteString(context^.output, ' '); - INC(count) + count := count + 1u end end; @@ -32,46 +39,46 @@ begin WriteLine(output) end; -proc transpile_import_statement(context: PTranspilerContext, import_statement: PAstImportStatement); +proc transpile_import_statement(context: ^TranspilerContext, import_statement: ^AstImportStatement); var - written_bytes: CARDINAL; - current_symbol: PIdentifier; + written_bytes: Word; + current_symbol: ^Identifier; begin WriteString(context^.output, 'FROM '); - written_bytes := WriteNBytes(context^.output, ORD(import_statement^.package[1]), ADR(import_statement^.package[2])); + written_bytes := WriteNBytes(context^.output, ORD(import_statement^.package[1]), @import_statement^.package[2]); WriteString(context^.output, ' IMPORT '); current_symbol := import_statement^.symbols; - written_bytes := WriteNBytes(context^.output, ORD(current_symbol^[1]), ADR(current_symbol^[2])); - INC(current_symbol, TSIZE(Identifier)); + written_bytes := WriteNBytes(context^.output, ORD(current_symbol^[1]), @current_symbol^[2]); + INC(current_symbol, #size(Identifier)); while ORD(current_symbol^[1]) <> 0 do WriteString(context^.output, ', '); - written_bytes := WriteNBytes(context^.output, ORD(current_symbol^[1]), ADR(current_symbol^[2])); - INC(current_symbol, TSIZE(Identifier)) + written_bytes := WriteNBytes(context^.output, ORD(current_symbol^[1]), @current_symbol^[2]); + INC(current_symbol, #size(Identifier)) end; write_semicolon(context^.output) end; -proc transpile_import_part(context: PTranspilerContext, imports: PPAstImportStatement); +proc transpile_import_part(context: ^TranspilerContext, imports: ^^AstImportStatement); var - import_statement: PAstImportStatement; + import_statement: ^AstImportStatement; begin while imports^ <> nil do transpile_import_statement(context, imports^); - INC(imports, TSIZE(PAstImportStatement)) + INC(imports, #size(^AstImportStatement)) end; WriteLine(context^.output) end; -proc transpile_constant_declaration(context: PTranspilerContext, declaration: PAstConstantDeclaration); +proc transpile_constant_declaration(context: ^TranspilerContext, declaration: ^AstConstantDeclaration); var buffer: [20]CHAR; - written_bytes: CARDINAL; + written_bytes: Word; begin WriteString(context^.output, ' '); - written_bytes := WriteNBytes(context^.output, ORD(declaration^.constant_name[1]), ADR(declaration^.constant_name[2])); + written_bytes := WriteNBytes(context^.output, ORD(declaration^.constant_name[1]), @declaration^.constant_name[2]); WriteString(context^.output, ' = '); @@ -81,9 +88,9 @@ begin write_semicolon(context^.output) end; -proc transpile_constant_part(context: PTranspilerContext, declarations: PPAstConstantDeclaration, extra_newline: BOOLEAN); +proc transpile_constant_part(context: ^TranspilerContext, declarations: ^^AstConstantDeclaration, extra_newline: Bool); var - current_declaration: PPAstConstantDeclaration; + current_declaration: ^^AstConstantDeclaration; begin if declarations^ <> nil then WriteString(context^.output, 'CONST'); @@ -93,7 +100,7 @@ begin while current_declaration^ <> nil do transpile_constant_declaration(context, current_declaration^); - INC(current_declaration, TSIZE(PAstConstantDeclaration)) + INC(current_declaration, #size(^AstConstantDeclaration)) end; if extra_newline then WriteLine(context^.output) @@ -101,7 +108,7 @@ begin end end; -proc transpile_module(context: PTranspilerContext, result: PAstModule); +proc transpile_module(context: ^TranspilerContext, result: ^AstModule); begin if result^.main = false then WriteString(context^.output, 'IMPLEMENTATION ') @@ -130,21 +137,21 @@ begin WriteLine(context^.output) end; -proc transpile_type_fields(context: PTranspilerContext, fields: PAstFieldDeclaration); +proc transpile_type_fields(context: ^TranspilerContext, fields: ^AstFieldDeclaration); var - written_bytes: CARDINAL; - current_field: PAstFieldDeclaration; + written_bytes: Word; + current_field: ^AstFieldDeclaration; begin current_field := fields; while ORD(current_field^.field_name[1]) <> 0 do WriteString(context^.output, ' '); - written_bytes := WriteNBytes(context^.output, ORD(current_field^.field_name[1]), ADR(current_field^.field_name[2])); + written_bytes := WriteNBytes(context^.output, ORD(current_field^.field_name[1]), @current_field^.field_name[2]); WriteString(context^.output, ': '); transpile_type_expression(context, current_field^.field_type); - INC(current_field , TSIZE(AstFieldDeclaration)); + INC(current_field , #size(AstFieldDeclaration)); if ORD(current_field^.field_name[1]) <> 0 then WriteChar(context^.output, ';') @@ -153,7 +160,7 @@ begin end end; -proc transpile_record_type(context: PTranspilerContext, type_expression: PAstTypeExpression); +proc transpile_record_type(context: ^TranspilerContext, type_expression: ^AstTypeExpression); begin WriteString(context^.output, 'RECORD'); WriteLine(context^.output); @@ -161,14 +168,14 @@ begin WriteString(context^.output, ' END') end; -proc transpile_pointer_type(context: PTranspilerContext, type_expression: PAstTypeExpression); +proc transpile_pointer_type(context: ^TranspilerContext, type_expression: ^AstTypeExpression); begin WriteString(context^.output, 'POINTER TO '); transpile_type_expression(context, type_expression^.target) end; -proc transpile_array_type(context: PTranspilerContext, type_expression: PAstTypeExpression); +proc transpile_array_type(context: ^TranspilerContext, type_expression: ^AstTypeExpression); var buffer: [20]CHAR; begin @@ -187,43 +194,43 @@ begin transpile_type_expression(context, type_expression^.base) end; -proc transpile_enumeration_type(context: PTranspilerContext, type_expression: PAstTypeExpression); +proc transpile_enumeration_type(context: ^TranspilerContext, type_expression: ^AstTypeExpression); var - current_case: PIdentifier; - written_bytes: CARDINAL; + current_case: ^Identifier; + written_bytes: Word; begin current_case := type_expression^.cases; WriteString(context^.output, '('); WriteLine(context^.output); WriteString(context^.output, ' '); - written_bytes := WriteNBytes(context^.output, ORD(current_case^[1]), ADR(current_case^[2])); - INC(current_case, TSIZE(Identifier)); + written_bytes := WriteNBytes(context^.output, ORD(current_case^[1]), @current_case^[2]); + INC(current_case, #size(Identifier)); while ORD(current_case^[1]) <> 0 do WriteChar(context^.output, ','); WriteLine(context^.output); WriteString(context^.output, ' '); - written_bytes := WriteNBytes(context^.output, ORD(current_case^[1]), ADR(current_case^[2])); + written_bytes := WriteNBytes(context^.output, ORD(current_case^[1]), @current_case^[2]); - INC(current_case, TSIZE(Identifier)) + INC(current_case, #size(Identifier)) end; WriteLine(context^.output); WriteString(context^.output, ' )') end; -proc transpile_named_type(context: PTranspilerContext, type_expression: PAstTypeExpression); +proc transpile_named_type(context: ^TranspilerContext, type_expression: ^AstTypeExpression); var - written_bytes: CARDINAL; + written_bytes: Word; begin - written_bytes := WriteNBytes(context^.output, ORD(type_expression^.name[1]), ADR(type_expression^.name[2])) + written_bytes := WriteNBytes(context^.output, ORD(type_expression^.name[1]), @type_expression^.name[2]) end; -proc transpile_procedure_type(context: PTranspilerContext, type_expression: PAstTypeExpression); +proc transpile_procedure_type(context: ^TranspilerContext, type_expression: ^AstTypeExpression); var - result: PAstTypeExpression; - current_parameter: PPAstTypeExpression; - parameter_count: CARDINAL; + result: ^AstTypeExpression; + current_parameter: ^^AstTypeExpression; + parameter_count: Word; begin WriteString(context^.output, 'PROCEDURE('); current_parameter := type_expression^.parameters; @@ -231,7 +238,7 @@ begin while current_parameter^ <> nil do transpile_type_expression(context, current_parameter^); - INC(current_parameter, TSIZE(PAstTypeExpression)); + INC(current_parameter, #size(^AstTypeExpression)); if current_parameter^ <> nil then WriteString(context^.output, ', ') @@ -240,7 +247,7 @@ begin WriteChar(context^.output, ')') end; -proc transpile_type_expression(context: PTranspilerContext, type_expression: PAstTypeExpression); +proc transpile_type_expression(context: ^TranspilerContext, type_expression: ^AstTypeExpression); begin if type_expression^.kind = astTypeExpressionKindRecord then transpile_record_type(context, type_expression) @@ -262,22 +269,22 @@ begin end end; -proc transpile_type_declaration(context: PTranspilerContext, declaration: PAstTypedDeclaration); +proc transpile_type_declaration(context: ^TranspilerContext, declaration: ^AstTypedDeclaration); var - written_bytes: CARDINAL; + written_bytes: Word; begin WriteString(context^.output, ' '); - written_bytes := WriteNBytes(context^.output, ORD(declaration^.identifier[1]), ADR(declaration^.identifier[2])); + written_bytes := WriteNBytes(context^.output, ORD(declaration^.identifier[1]), @declaration^.identifier[2]); WriteString(context^.output, ' = '); transpile_type_expression(context, declaration^.type_expression); write_semicolon(context^.output) end; -proc transpile_type_part(context: PTranspilerContext, declarations: PPAstTypedDeclaration); +proc transpile_type_part(context: ^TranspilerContext, declarations: ^^AstTypedDeclaration); var - current_declaration: PPAstTypedDeclaration; + current_declaration: ^^AstTypedDeclaration; begin if declarations^ <> nil then WriteString(context^.output, 'TYPE'); @@ -287,18 +294,18 @@ begin while current_declaration^ <> nil do transpile_type_declaration(context, current_declaration^); - INC(current_declaration, TSIZE(PAstTypedDeclaration)) + INC(current_declaration, #size(^AstTypedDeclaration)) end; WriteLine(context^.output) end end; -proc transpile_variable_declaration(context: PTranspilerContext, declaration: PAstVariableDeclaration); +proc transpile_variable_declaration(context: ^TranspilerContext, declaration: ^AstVariableDeclaration); var - written_bytes: CARDINAL; + written_bytes: Word; begin WriteString(context^.output, ' '); - written_bytes := WriteNBytes(context^.output, ORD(declaration^.variable_name[1]), ADR(declaration^.variable_name[2])); + written_bytes := WriteNBytes(context^.output, ORD(declaration^.variable_name[1]), @declaration^.variable_name[2]); WriteString(context^.output, ': '); @@ -306,9 +313,9 @@ begin write_semicolon(context^.output) end; -proc transpile_variable_part(context: PTranspilerContext, declarations: PPAstVariableDeclaration, extra_newline: BOOLEAN); +proc transpile_variable_part(context: ^TranspilerContext, declarations: ^^AstVariableDeclaration, extra_newline: Bool); var - current_declaration: PPAstVariableDeclaration; + current_declaration: ^^AstVariableDeclaration; begin if declarations^ <> nil then WriteString(context^.output, 'VAR'); @@ -318,7 +325,7 @@ begin while current_declaration^ <> nil do transpile_variable_declaration(context, current_declaration^); - INC(current_declaration, TSIZE(PAstVariableDeclaration)) + INC(current_declaration, #size(^AstVariableDeclaration)) end; if extra_newline then WriteLine(context^.output) @@ -326,26 +333,26 @@ begin end end; -proc transpile_procedure_heading(context: PTranspilerContext, declaration: PAstProcedureDeclaration); +proc transpile_procedure_heading(context: ^TranspilerContext, declaration: ^AstProcedureDeclaration); var - written_bytes: CARDINAL; - parameter_index: CARDINAL; - current_parameter: PAstTypedDeclaration; + written_bytes: Word; + parameter_index: Word; + current_parameter: ^AstTypedDeclaration; begin WriteString(context^.output, 'PROCEDURE '); - written_bytes := WriteNBytes(context^.output, ORD(declaration^.name[1]), ADR(declaration^.name[2])); + written_bytes := WriteNBytes(context^.output, ORD(declaration^.name[1]), @declaration^.name[2]); WriteChar(context^.output, '('); parameter_index := 0; current_parameter := declaration^.parameters; while parameter_index < declaration^.parameter_count do - written_bytes := WriteNBytes(context^.output, ORD(current_parameter^.identifier[1]), ADR(current_parameter^.identifier[2])); + written_bytes := WriteNBytes(context^.output, ORD(current_parameter^.identifier[1]), @current_parameter^.identifier[2]); WriteString(context^.output, ': '); transpile_type_expression(context, current_parameter^.type_expression); - INC(parameter_index); - INC(current_parameter, TSIZE(AstTypedDeclaration)); + parameter_index := parameter_index + 1u; + INC(current_parameter, #size(AstTypedDeclaration)); if parameter_index <> declaration^.parameter_count then WriteString(context^.output, '; ') @@ -362,83 +369,63 @@ begin write_semicolon(context^.output) end; -proc transpile_unary_operator(context: PTranspilerContext, operator: AstUnaryOperator); +proc transpile_unary_operator(context: ^TranspilerContext, operator: AstUnaryOperator); begin - if operator = astUnaryOperatorMinus then + if operator = AstUnaryOperator.minus then WriteChar(context^.output, '-') end; - if operator = astUnaryOperatorNot then + if operator = AstUnaryOperator.not then WriteChar(context^.output, '~') end end; -proc transpile_binary_operator(context: PTranspilerContext, operator: AstBinaryOperator); +proc transpile_binary_operator(context: ^TranspilerContext, operator: AstBinaryOperator); begin - if operator = astBinaryOperatorSum then - WriteChar(context^.output, '+') - end; - if operator = astBinaryOperatorSubtraction then - WriteChar(context^.output, '-') - end; - if operator = astBinaryOperatorMultiplication then - WriteChar(context^.output, '*') - end; - if operator = astBinaryOperatorEquals then - WriteChar(context^.output, '=') - end; - if operator = astBinaryOperatorNotEquals then - WriteChar(context^.output, '#') - end; - if operator = astBinaryOperatorLess then - WriteChar(context^.output, '<') - end; - if operator = astBinaryOperatorGreater then - WriteChar(context^.output, '>') - end; - if operator = astBinaryOperatorLessEqual then - WriteString(context^.output, '<=') - end; - if operator = astBinaryOperatorGreaterEqual then - WriteString(context^.output, '>=') - end; - if operator = astBinaryOperatorDisjunction then - WriteString(context^.output, 'OR') - end; - if operator = astBinaryOperatorConjunction then - WriteString(context^.output, 'AND') + case operator of + AstBinaryOperator.sum: WriteChar(context^.output, '+') + | AstBinaryOperator.subtraction: WriteChar(context^.output, '-') + | AstBinaryOperator.multiplication: WriteChar(context^.output, '*') + | AstBinaryOperator.equals: WriteChar(context^.output, '=') + | AstBinaryOperator.not_equals: WriteChar(context^.output, '#') + | AstBinaryOperator.less: WriteChar(context^.output, '<') + | AstBinaryOperator.greater: WriteChar(context^.output, '>') + | AstBinaryOperator.less_equal: WriteString(context^.output, '<=') + | AstBinaryOperator.greater_equal: WriteString(context^.output, '>=') + | AstBinaryOperator.disjunction: WriteString(context^.output, 'OR') + | AstBinaryOperatorConjunction: WriteString(context^.output, 'AND') end end; -proc transpile_expression(context: PTranspilerContext, expression: PAstExpression); +proc transpile_expression(context: ^TranspilerContext, expression: ^AstExpression); var - literal: PAstLiteral; + literal: ^AstLiteral; buffer: [20]CHAR; - written_bytes: CARDINAL; - argument_index: CARDINAL; - current_argument: PPAstExpression; + written_bytes: Word; + argument_index: Word; + current_argument: ^^AstExpression; begin if expression^.kind = astExpressionKindLiteral then literal := expression^.literal; - if literal^.kind = astLiteralKindInteger then + if literal^.kind = AstLiteralKind.integer then IntToStr(literal^.integer, 0, buffer); WriteString(context^.output, buffer) end; - if literal^.kind = astLiteralKindString then + if literal^.kind = AstLiteralKind.string then WriteString(context^.output, literal^.string) end; - if literal^.kind = astLiteralKindNull then + if literal^.kind = AstLiteralKind.null then WriteString(context^.output, 'NIL') end; - if (literal^.kind = astLiteralKindBoolean) & literal^.boolean then + if (literal^.kind = AstLiteralKind.boolean) & literal^.boolean then WriteString(context^.output, 'TRUE') end; - if (literal^.kind = astLiteralKindBoolean) & (literal^.boolean = false) then + if (literal^.kind = AstLiteralKind.boolean) & (literal^.boolean = false) then WriteString(context^.output, 'FALSE') end end; if expression^.kind = astExpressionKindIdentifier then - written_bytes := WriteNBytes(context^.output, ORD(expression^.identifier[1]), ADR(expression^.identifier[2])) + written_bytes := WriteNBytes(context^.output, ORD(expression^.identifier[1]), @expression^.identifier[2]) end; if expression^.kind = astExpressionKindDereference then transpile_expression(context, expression^.reference); @@ -453,7 +440,7 @@ begin if expression^.kind = astExpressionKindFieldAccess then transpile_expression(context, expression^.aggregate); WriteChar(context^.output, '.'); - written_bytes := WriteNBytes(context^.output, ORD(expression^.field[1]), ADR(expression^.field[2])) + written_bytes := WriteNBytes(context^.output, ORD(expression^.field[1]), @expression^.field[2]) end; if expression^.kind = astExpressionKindUnary then transpile_unary_operator(context, expression^.unary_operator); @@ -476,70 +463,70 @@ begin if expression^.argument_count > 0 then transpile_expression(context, current_argument^); - argument_index := 1; - INC(current_argument, TSIZE(PAstExpression)); + argument_index := 1u; + INC(current_argument, #size(^AstExpression)); while argument_index < expression^.argument_count do WriteString(context^.output, ', '); transpile_expression(context, current_argument^); - INC(current_argument, TSIZE(PAstExpression)); - INC(argument_index) + INC(current_argument, #size(^AstExpression)); + argument_index := argument_index + 1u end end; WriteChar(context^.output, ')') end end; -proc transpile_if_statement(context: PTranspilerContext, statement: PAstStatement); +proc transpile_if_statement(context: ^TranspilerContext, statement: ^AstStatement); begin WriteString(context^.output, 'IF '); transpile_expression(context, statement^.if_condition); WriteString(context^.output, ' THEN'); WriteLine(context^.output); - INC(context^.indentation); + context^.indentation := context^.indentation + 1u; transpile_compound_statement(context, statement^.if_branch); - DEC(context^.indentation); + context^.indentation := context^.indentation - 1u; indent(context); WriteString(context^.output, 'END') end; -proc transpile_while_statement(context: PTranspilerContext, statement: PAstStatement); +proc transpile_while_statement(context: ^TranspilerContext, statement: ^AstStatement); begin WriteString(context^.output, 'WHILE '); transpile_expression(context, statement^.while_condition); WriteString(context^.output, ' DO'); WriteLine(context^.output); - INC(context^.indentation); + context^.indentation := context^.indentation + 1u; transpile_compound_statement(context, statement^.while_body); - DEC(context^.indentation); + context^.indentation := context^.indentation - 1u; indent(context); WriteString(context^.output, 'END') end; -proc transpile_assignment_statement(context: PTranspilerContext, statement: PAstStatement); +proc transpile_assignment_statement(context: ^TranspilerContext, statement: ^AstStatement); begin transpile_expression(context, statement^.assignee); WriteString(context^.output, ' := '); transpile_expression(context, statement^.assignment) end; -proc transpile_return_statement(context: PTranspilerContext, statement: PAstStatement); +proc transpile_return_statement(context: ^TranspilerContext, statement: ^AstStatement); begin WriteString(context^.output, 'RETURN '); transpile_expression(context, statement^.returned) end; -proc transpile_compound_statement(context: PTranspilerContext, statement: AstCompoundStatement); +proc transpile_compound_statement(context: ^TranspilerContext, statement: AstCompoundStatement); var - current_statement: PPAstStatement; - index: CARDINAL; + current_statement: ^^AstStatement; + index: Word; begin index := 0; current_statement := statement.statements; @@ -547,8 +534,8 @@ begin while index < statement.count do transpile_statement(context, current_statement^); - INC(current_statement, TSIZE(PAstStatement)); - INC(index); + INC(current_statement, #size(^AstStatement)); + index := index + 1u; if index <> statement.count then WriteChar(context^.output, ';') @@ -557,7 +544,7 @@ begin end end; -proc transpile_statement(context: PTranspilerContext, statement: PAstStatement); +proc transpile_statement(context: ^TranspilerContext, statement: ^AstStatement); begin indent(context); @@ -578,21 +565,21 @@ begin end end; -proc transpile_statement_part(context: PTranspilerContext, compound: AstCompoundStatement); +proc transpile_statement_part(context: ^TranspilerContext, compound: AstCompoundStatement); begin if compound.count > 0 then WriteString(context^.output, 'BEGIN'); WriteLine(context^.output); - INC(context^.indentation); + context^.indentation := context^.indentation + 1u; transpile_compound_statement(context, compound); - DEC(context^.indentation) + context^.indentation := context^.indentation - 1u; end end; -proc transpile_procedure_declaration(context: PTranspilerContext, declaration: PAstProcedureDeclaration); +proc transpile_procedure_declaration(context: ^TranspilerContext, declaration: ^AstProcedureDeclaration); var - written_bytes: CARDINAL; + written_bytes: Word; begin transpile_procedure_heading(context, declaration); @@ -601,58 +588,58 @@ begin transpile_statement_part(context, declaration^.statements); WriteString(context^.output, 'END '); - written_bytes := WriteNBytes(context^.output, ORD(declaration^.name[1]), ADR(declaration^.name[2])); + written_bytes := WriteNBytes(context^.output, ORD(declaration^.name[1]), @declaration^.name[2]); write_semicolon(context^.output) end; -proc transpile_procedure_part(context: PTranspilerContext, declaration: PPAstProcedureDeclaration); +proc transpile_procedure_part(context: ^TranspilerContext, declaration: ^^AstProcedureDeclaration); begin while declaration^ <> nil do transpile_procedure_declaration(context, declaration^); WriteLine(context^.output); - INC(declaration, TSIZE(PAstProcedureDeclaration)) + INC(declaration, #size(^AstProcedureDeclaration)) end end; -proc transpile_module_name(context: PTranspilerContext); +proc transpile_module_name(context: ^TranspilerContext); var - counter: CARDINAL; - last_slash: CARDINAL; + counter: Word; + last_slash: Word; begin - counter := 1; - last_slash := 0; + counter := 1u; + last_slash := 0u; while (context^.input_name[counter] <> '.') & (ORD(context^.input_name[counter]) <> 0) do if context^.input_name[counter] = '/' then last_slash := counter end; - INC(counter) + counter := counter + 1u end; - if last_slash = 0 then - counter := 1 + if last_slash = 0u then + counter := 1u end; - if last_slash <> 0 then - counter := last_slash + 1 + if last_slash <> 0u then + counter := last_slash + 1u end; while (context^.input_name[counter] <> '.') & (ORD(context^.input_name[counter]) <> 0) do WriteChar(context^.output, context^.input_name[counter]); - INC(counter) + counter := counter + 1u end end; -proc transpile(ast_module: PAstModule, output: File, definition: File, input_name: ShortString); +proc transpile*(ast_module: ^AstModule, output: File, definition: File, input_name: ShortString); var context: TranspilerContext; begin context.input_name := input_name; context.output := output; context.definition := definition; - context.indentation := 0; + context.indentation := 0u; - transpile_module(ADR(context), ast_module) + transpile_module(@context, ast_module) end; end.