diff --git a/Rakefile b/Rakefile
index 7c75556..bee64e8 100644
--- a/Rakefile
+++ b/Rakefile
@@ -104,16 +104,20 @@ task :backport do
     source
       .gsub(/^(var|type|const|begin)/) { |match| match.upcase }
       .gsub(/^[[:alnum:]]* ?module/) { |match| match.upcase }
-      .gsub(/\brecord\b/) { |match| match.upcase }
-      .gsub(/proc(\(| )/, 'PROCEDURE\1')
+      .gsub(/\b(record|nil|or)\b/) { |match| match.upcase }
+      .gsub(/proc\(/, 'PROCEDURE(')
+      .gsub(/ & /, ' AND ')
       .gsub(/([[:space:]]*)end(;?)$/, '\1END\2')
       .gsub(/^([[:space:]]*)(while|return|if)\b/) { |match| match.upcase }
       .gsub(/^from ([[:alnum:]]+) import/, 'FROM \1 IMPORT')
       .gsub(/ \^([[:alnum:]])/, ' POINTER TO \1')
       .gsub(/(then|do)$/) { |match| match.upcase }
+      .gsub(/(:|=) \[([[:digit:]]+)\]/, '\1 ARRAY[1..\2] OF ')
       .each_line do |line|
-        if line.start_with? 'PROCEDURE'
-          current_procedure = line[10...line.index('(')]
+        if line.start_with? 'proc'
+          current_procedure = line[5...line.index('(')]
+
+          line = 'PROCEDURE ' + line[5..].gsub(',', ';')
         elsif line.start_with?('END;') && !current_procedure.nil?
           line = "END #{current_procedure};"
           current_proceure = nil
diff --git a/source/Compiler.elna b/source/Compiler.elna
index 9af3bca..4e6ea19 100644
--- a/source/Compiler.elna
+++ b/source/Compiler.elna
@@ -7,12 +7,12 @@ from Lexer import Lexer, lexer_destroy, lexer_initialize;
 from Transpiler import transpile;
 
 var
-  ALexer: Lexer;
+  lexer: Lexer;
 
 begin
-  lexer_initialize(ADR(ALexer), StdIn);
+  lexer_initialize(ADR(lexer), StdIn);
 
-  transpile(ADR(ALexer));
+  transpile(ADR(lexer));
 
-  lexer_destroy(ADR(ALexer))
+  lexer_destroy(ADR(lexer))
 end Compiler.
diff --git a/source/Lexer.elna b/source/Lexer.elna
index 756c499..264f895 100644
--- a/source/Lexer.elna
+++ b/source/Lexer.elna
@@ -9,7 +9,7 @@ from MemUtils import MemCopy, MemZero;
 from StrCase import Lower;
 
 const
-  ChunkSize = 65536;
+  CHUNK_SIZE = 65536;
 
 type
   (*
@@ -65,144 +65,145 @@ type
     Action: TransitionAction;
     NextState: TransitionState
   end;
+  TransitionClasses = [22]Transition;
 
 var
-  Classification: ARRAY[1..128] OF TransitionClass;
-  Transitions: ARRAY[0..15] OF ARRAY[0..21] OF Transition;
+  classification: [128]TransitionClass;
+  transitions: [16]TransitionClasses;
 
 proc initialize_classification();
 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] := 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 *)
 end;
 
-proc compare_keyword(Keyword: ARRAY OF CHAR; TokenStart: PLexerBuffer; TokenEnd: PLexerBuffer): BOOLEAN;
+proc compare_keyword(Keyword: ARRAY OF CHAR,  TokenStart: PLexerBuffer,  TokenEnd: PLexerBuffer): BOOLEAN;
 var
   Result: BOOLEAN;
   Index: CARDINAL;
@@ -210,196 +211,196 @@ begin
   Index := 0;
   Result := TRUE;
 
-  while (Index < Length(Keyword)) AND (TokenStart <> TokenEnd) AND Result DO
-    Result := (Keyword[Index] = TokenStart^) OR (Lower(Keyword[Index]) = TokenStart^);
+  while (Index < Length(Keyword)) & (TokenStart <> TokenEnd) & Result DO
+    Result := (Keyword[Index] = TokenStart^) or (Lower(Keyword[Index]) = TokenStart^);
     INC(TokenStart);
     INC(Index)
   end;
-  Result := (Index = Length(Keyword)) AND (TokenStart = TokenEnd) AND Result;
+  Result := (Index = Length(Keyword)) & (TokenStart = TokenEnd) & Result;
   return Result
 end;
 
 (* Reached the end of file. *)
-proc transition_action_eof(ALexer: PLexer; AToken: PLexerToken);
+proc transition_action_eof(lexer: PLexer,  AToken: PLexerToken);
 begin
   AToken^.Kind := lexerKindEof
 end;
 
 (* Add the character to the token currently read and advance to the next character. *)
-proc transition_action_accumulate(ALexer: PLexer; AToken: PLexerToken);
+proc transition_action_accumulate(lexer: PLexer,  AToken: PLexerToken);
 begin
-  INC(ALexer^.Current)
+  INC(lexer^.Current)
 end;
 
 (* The current character is not a part of the token. Finish the token already
  * read. Don't advance to the next character. *)
-proc transition_action_finalize(ALexer: PLexer; AToken: PLexerToken);
+proc transition_action_finalize(lexer: PLexer,  AToken: PLexerToken);
 begin
-  if ALexer^.Start^ = ':' then
+  if lexer^.Start^ = ':' then
     AToken^.Kind := lexerKindColon
   end;
-  if ALexer^.Start^ = '>' then
+  if lexer^.Start^ = '>' then
     AToken^.Kind := lexerKindGreaterThan
   end;
-  if ALexer^.Start^ = '<' then
+  if lexer^.Start^ = '<' then
     AToken^.Kind := lexerKindLessThan
   end;
-  if ALexer^.Start^ = '(' then
+  if lexer^.Start^ = '(' then
     AToken^.Kind := lexerKindLeftParen
   end;
-  if ALexer^.Start^ = '-' then
+  if lexer^.Start^ = '-' then
     AToken^.Kind := lexerKindLeftParen
   end;
-  if ALexer^.Start^ = '.' then
+  if lexer^.Start^ = '.' then
     AToken^.Kind := lexerKindDot
   end
 end;
 
 (* An action for tokens containing multiple characters. *)
-proc transition_action_composite(ALexer: PLexer; AToken: PLexerToken);
+proc transition_action_composite(lexer: PLexer,  AToken: PLexerToken);
 begin
-  if ALexer^.Start^ = '<' then
-    if ALexer^.Current^ = '>' then
+  if lexer^.Start^ = '<' then
+    if lexer^.Current^ = '>' then
       AToken^.Kind := lexerKindNotEqual
     end;
-    if ALexer^.Current^ = '=' then
+    if lexer^.Current^ = '=' then
       AToken^.Kind := lexerKindLessEqual
     end
   end;
-  if (ALexer^.Start^ = '>') AND (ALexer^.Current^ = '=') then
+  if (lexer^.Start^ = '>') & (lexer^.Current^ = '=') then
     AToken^.Kind := lexerKindGreaterEqual
   end;
-  if (ALexer^.Start^ = '.') AND (ALexer^.Current^ = '.') then
+  if (lexer^.Start^ = '.') & (lexer^.Current^ = '.') then
     AToken^.Kind := lexerKindRange
   end;
-  if (ALexer^.Start^ = ':') AND (ALexer^.Current^ = '=') then
+  if (lexer^.Start^ = ':') & (lexer^.Current^ = '=') then
     AToken^.Kind := lexerKindAssignment
   end;
-  INC(ALexer^.Current)
+  INC(lexer^.Current)
 end;
 
 (* Skip a space. *)
-proc transition_action_skip(ALexer: PLexer; AToken: PLexerToken);
+proc transition_action_skip(lexer: PLexer,  AToken: PLexerToken);
 begin
-  INC(ALexer^.Current);
-  INC(ALexer^.Start)
+  INC(lexer^.Current);
+  INC(lexer^.Start)
 end;
 
 (* Delimited string action. *)
-proc transition_action_delimited(ALexer: PLexer; AToken: PLexerToken);
+proc transition_action_delimited(lexer: PLexer,  AToken: PLexerToken);
 begin
-  if ALexer^.Start^ = '(' then
+  if lexer^.Start^ = '(' then
     AToken^.Kind := lexerKindComment
   end;
-  if ALexer^.Start^ = '"' then
+  if lexer^.Start^ = '"' then
     AToken^.Kind := lexerKindCharacter
   end;
-  if ALexer^.Start^ = "'" then
+  if lexer^.Start^ = "'" then
     AToken^.Kind := lexerKindString
   end;
-  INC(ALexer^.Current)
+  INC(lexer^.Current)
 end;
 
 (* Finalize keyword or identifier. *)
-proc transition_action_key_id(ALexer: PLexer; AToken: PLexerToken);
+proc transition_action_key_id(lexer: PLexer,  AToken: PLexerToken);
 begin
   AToken^.Kind := lexerKindIdentifier;
 
-  AToken^.identifierKind[1] := ALexer^.Current - ALexer^.Start;
-  MemCopy(ALexer^.Start, ORD(AToken^.identifierKind[1]), ADR(AToken^.identifierKind[2]));
+  AToken^.identifierKind[1] := lexer^.Current - lexer^.Start;
+  MemCopy(lexer^.Start, ORD(AToken^.identifierKind[1]), ADR(AToken^.identifierKind[2]));
 
-  if compare_keyword('PROGRAM', ALexer^.Start, ALexer^.Current) then
+  if compare_keyword('PROGRAM', lexer^.Start, lexer^.Current) then
     AToken^.Kind := lexerKindProgram
   end;
-  if compare_keyword('IMPORT', ALexer^.Start, ALexer^.Current) then
+  if compare_keyword('IMPORT', lexer^.Start, lexer^.Current) then
     AToken^.Kind := lexerKindImport
   end;
-  if compare_keyword('CONST', ALexer^.Start, ALexer^.Current) then
+  if compare_keyword('CONST', lexer^.Start, lexer^.Current) then
     AToken^.Kind := lexerKindConst
   end;
-  if compare_keyword('VAR', ALexer^.Start, ALexer^.Current) then
+  if compare_keyword('VAR', lexer^.Start, lexer^.Current) then
     AToken^.Kind := lexerKindVar
   end;
-  if compare_keyword('IF', ALexer^.Start, ALexer^.Current) then
+  if compare_keyword('IF', lexer^.Start, lexer^.Current) then
     AToken^.Kind := lexerKindIf
   end;
-  if compare_keyword('THEN', ALexer^.Start, ALexer^.Current) then
+  if compare_keyword('THEN', lexer^.Start, lexer^.Current) then
     AToken^.Kind := lexerKindThen
   end;
-  if compare_keyword('ELSIF', ALexer^.Start, ALexer^.Current) then
+  if compare_keyword('ELSIF', lexer^.Start, lexer^.Current) then
     AToken^.Kind := lexerKindElsif
   end;
-  if compare_keyword('ELSE', ALexer^.Start, ALexer^.Current) then
+  if compare_keyword('ELSE', lexer^.Start, lexer^.Current) then
     AToken^.Kind := lexerKindElse
   end;
-  if compare_keyword('WHILE', ALexer^.Start, ALexer^.Current) then
+  if compare_keyword('WHILE', lexer^.Start, lexer^.Current) then
     AToken^.Kind := lexerKindWhile
   end;
-  if compare_keyword('DO', ALexer^.Start, ALexer^.Current) then
+  if compare_keyword('DO', lexer^.Start, lexer^.Current) then
     AToken^.Kind := lexerKindDo
   end;
-  if compare_keyword('proc', ALexer^.Start, ALexer^.Current) then
+  if compare_keyword('proc', lexer^.Start, lexer^.Current) then
     AToken^.Kind := lexerKindProc
   end;
-  if compare_keyword('BEGIN', ALexer^.Start, ALexer^.Current) then
+  if compare_keyword('BEGIN', lexer^.Start, lexer^.Current) then
     AToken^.Kind := lexerKindBegin
   end;
-  if compare_keyword('END', ALexer^.Start, ALexer^.Current) then
+  if compare_keyword('END', lexer^.Start, lexer^.Current) then
     AToken^.Kind := lexerKindEnd
   end;
-  if compare_keyword('TYPE', ALexer^.Start, ALexer^.Current) then
+  if compare_keyword('TYPE', lexer^.Start, lexer^.Current) then
     AToken^.Kind := lexerKindType
   end;
-  if compare_keyword('RECORD', ALexer^.Start, ALexer^.Current) then
+  if compare_keyword('RECORD', lexer^.Start, lexer^.Current) then
     AToken^.Kind := lexerKindRecord
   end;
-  if compare_keyword('UNION', ALexer^.Start, ALexer^.Current) then
+  if compare_keyword('UNION', lexer^.Start, lexer^.Current) then
     AToken^.Kind := lexerKindUnion
   end;
-  if compare_keyword('NIL', ALexer^.Start, ALexer^.Current) then
+  if compare_keyword('NIL', lexer^.Start, lexer^.Current) then
     AToken^.Kind := lexerKindNull
   end;
-  if compare_keyword('AND', ALexer^.Start, ALexer^.Current) then
+  if compare_keyword('AND', lexer^.Start, lexer^.Current) then
     AToken^.Kind := lexerKindAnd
   end;
-  if compare_keyword('OR', ALexer^.Start, ALexer^.Current) then
+  if compare_keyword('OR', lexer^.Start, lexer^.Current) then
     AToken^.Kind := lexerKindOr
   end;
-  if compare_keyword('RETURN', ALexer^.Start, ALexer^.Current) then
+  if compare_keyword('RETURN', lexer^.Start, lexer^.Current) then
     AToken^.Kind := lexerKindReturn
   end;
-  if compare_keyword('DEFINITION', ALexer^.Start, ALexer^.Current) then
+  if compare_keyword('DEFINITION', lexer^.Start, lexer^.Current) then
     AToken^.Kind := lexerKindDefinition
   end;
-  if compare_keyword('TO', ALexer^.Start, ALexer^.Current) then
+  if compare_keyword('TO', lexer^.Start, lexer^.Current) then
     AToken^.Kind := lexerKindTo
   end;
-  if compare_keyword('CASE', ALexer^.Start, ALexer^.Current) then
+  if compare_keyword('CASE', lexer^.Start, lexer^.Current) then
     AToken^.Kind := lexerKindCase
   end;
-  if compare_keyword('OF', ALexer^.Start, ALexer^.Current) then
+  if compare_keyword('OF', lexer^.Start, lexer^.Current) then
     AToken^.Kind := lexerKindOf
   end;
-  if compare_keyword('FROM', ALexer^.Start, ALexer^.Current) then
+  if compare_keyword('FROM', lexer^.Start, lexer^.Current) then
     AToken^.Kind := lexerKindFrom
   end;
-  if compare_keyword('MODULE', ALexer^.Start, ALexer^.Current) then
+  if compare_keyword('MODULE', lexer^.Start, lexer^.Current) then
     AToken^.Kind := lexerKindModule
   end;
-  if compare_keyword('IMPLEMENTATION', ALexer^.Start, ALexer^.Current) then
+  if compare_keyword('IMPLEMENTATION', lexer^.Start, lexer^.Current) then
     AToken^.Kind := lexerKindImplementation
   end;
-  if compare_keyword('POINTER', ALexer^.Start, ALexer^.Current) then
+  if compare_keyword('POINTER', lexer^.Start, lexer^.Current) then
     AToken^.Kind := lexerKindPointer
   end;
-  if compare_keyword('ARRAY', ALexer^.Start, ALexer^.Current) then
+  if compare_keyword('ARRAY', lexer^.Start, lexer^.Current) then
     AToken^.Kind := lexerKindArray
   end;
-  if compare_keyword('TRUE', ALexer^.Start, ALexer^.Current) then
+  if compare_keyword('TRUE', lexer^.Start, lexer^.Current) then
     AToken^.Kind := lexerKindBoolean;
     AToken^.booleanKind := TRUE
   end;
-  if compare_keyword('FALSE', ALexer^.Start, ALexer^.Current) then
+  if compare_keyword('FALSE', lexer^.Start, lexer^.Current) then
     AToken^.Kind := lexerKindBoolean;
     AToken^.booleanKind := FALSE
   end
@@ -407,88 +408,88 @@ end;
 
 (* Action for tokens containing only one character. The character cannot be
  * followed by other characters forming a composite token. *)
-proc transition_action_single(ALexer: PLexer; AToken: PLexerToken);
+proc transition_action_single(lexer: PLexer,  AToken: PLexerToken);
 begin
-  if ALexer^.Current^ = '&' then
+  if lexer^.Current^ = '&' then
     AToken^.Kind := lexerKindAnd
   end;
-  if ALexer^.Current^ = ';' then
+  if lexer^.Current^ = ';' then
     AToken^.Kind := lexerKindSemicolon
   end;
-  if ALexer^.Current^ = ',' then
+  if lexer^.Current^ = ',' then
     AToken^.Kind := lexerKindComma
   end;
-  if ALexer^.Current^ = ',' then
+  if lexer^.Current^ = ',' then
     AToken^.Kind := lexerKindComma
   end;
-  if ALexer^.Current^ = ')' then
+  if lexer^.Current^ = ')' then
     AToken^.Kind := lexerKindRightParen
   end;
-  if ALexer^.Current^ = '[' then
+  if lexer^.Current^ = '[' then
     AToken^.Kind := lexerKindLeftSquare
   end;
-  if ALexer^.Current^ = ']' then
+  if lexer^.Current^ = ']' then
     AToken^.Kind := lexerKindRightSquare
   end;
-  if ALexer^.Current^ = '^' then
+  if lexer^.Current^ = '^' then
     AToken^.Kind := lexerKindHat
   end;
-  if ALexer^.Current^ = '=' then
+  if lexer^.Current^ = '=' then
     AToken^.Kind := lexerKindEqual
   end;
-  if ALexer^.Current^ = '+' then
+  if lexer^.Current^ = '+' then
     AToken^.Kind := lexerKindPlus
   end;
-  if ALexer^.Current^ = '/' then
+  if lexer^.Current^ = '/' then
     AToken^.Kind := lexerKindDivision
   end;
-  if ALexer^.Current^ = '%' then
+  if lexer^.Current^ = '%' then
     AToken^.Kind := lexerKindRemainder
   end;
-  if ALexer^.Current^ = '@' then
+  if lexer^.Current^ = '@' then
     AToken^.Kind := lexerKindAt
   end;
-  if ALexer^.Current^ = '|' then
+  if lexer^.Current^ = '|' then
     AToken^.Kind := lexerKindPipe
   end;
-  INC(ALexer^.Current)
+  INC(lexer^.Current)
 end;
 
 (* Handle an integer literal. *)
-proc transition_action_integer(ALexer: PLexer; AToken: PLexerToken);
+proc transition_action_integer(lexer: PLexer,  AToken: PLexerToken);
 begin
   AToken^.Kind := lexerKindInteger
 end;
 
-proc set_default_transition(CurrentState: TransitionState; DefaultAction: TransitionAction; NextState: TransitionState);
+proc set_default_transition(CurrentState: TransitionState,  DefaultAction: TransitionAction,  NextState: TransitionState);
 var
   DefaultTransition: Transition;
 begin
   DefaultTransition.Action := DefaultAction;
   DefaultTransition.NextState := NextState;
 
-  Transitions[ORD(CurrentState)][ORD(transitionClassInvalid)] := DefaultTransition;
-  Transitions[ORD(CurrentState)][ORD(transitionClassDigit)] := DefaultTransition;
-  Transitions[ORD(CurrentState)][ORD(transitionClassAlpha)] := DefaultTransition;
-  Transitions[ORD(CurrentState)][ORD(transitionClassSpace)] := DefaultTransition;
-  Transitions[ORD(CurrentState)][ORD(transitionClassColon)] := DefaultTransition;
-  Transitions[ORD(CurrentState)][ORD(transitionClassEquals)] := DefaultTransition;
-  Transitions[ORD(CurrentState)][ORD(transitionClassLeftParen)] := DefaultTransition;
-  Transitions[ORD(CurrentState)][ORD(transitionClassRightParen)] := DefaultTransition;
-  Transitions[ORD(CurrentState)][ORD(transitionClassAsterisk)] := DefaultTransition;
-  Transitions[ORD(CurrentState)][ORD(transitionClassUnderscore)] := DefaultTransition;
-  Transitions[ORD(CurrentState)][ORD(transitionClassSingle)] := DefaultTransition;
-  Transitions[ORD(CurrentState)][ORD(transitionClassHex)] := DefaultTransition;
-  Transitions[ORD(CurrentState)][ORD(transitionClassZero)] := DefaultTransition;
-  Transitions[ORD(CurrentState)][ORD(transitionClassX)] := DefaultTransition;
-  Transitions[ORD(CurrentState)][ORD(transitionClassEof)] := DefaultTransition;
-  Transitions[ORD(CurrentState)][ORD(transitionClassDot)] := DefaultTransition;
-  Transitions[ORD(CurrentState)][ORD(transitionClassMinus)] := DefaultTransition;
-  Transitions[ORD(CurrentState)][ORD(transitionClassSingleQuote)] := DefaultTransition;
-  Transitions[ORD(CurrentState)][ORD(transitionClassDoubleQuote)] := DefaultTransition;
-  Transitions[ORD(CurrentState)][ORD(transitionClassGreater)] := DefaultTransition;
-  Transitions[ORD(CurrentState)][ORD(transitionClassLess)] := DefaultTransition;
-  Transitions[ORD(CurrentState)][ORD(transitionClassOther)] := DefaultTransition
+  transitions[ORD(CurrentState) + 1][ORD(transitionClassInvalid) + 1] := DefaultTransition;
+  transitions[ORD(CurrentState) + 1][ORD(transitionClassDigit) + 1] := DefaultTransition;
+  transitions[ORD(CurrentState) + 1][ORD(transitionClassAlpha) + 1] := DefaultTransition;
+  transitions[ORD(CurrentState) + 1][ORD(transitionClassSpace) + 1] := DefaultTransition;
+  transitions[ORD(CurrentState) + 1][ORD(transitionClassColon) + 1] := DefaultTransition;
+  transitions[ORD(CurrentState) + 1][ORD(transitionClassEquals) + 1] := DefaultTransition;
+  transitions[ORD(CurrentState) + 1][ORD(transitionClassLeftParen) + 1] := DefaultTransition;
+  transitions[ORD(CurrentState) + 1][ORD(transitionClassRightParen) + 1] := DefaultTransition;
+  transitions[ORD(CurrentState) + 1][ORD(transitionClassAsterisk) + 1] := DefaultTransition;
+  transitions[ORD(CurrentState) + 1][ORD(transitionClassUnderscore) + 1] := DefaultTransition;
+  transitions[ORD(CurrentState) + 1][ORD(transitionClassSingle) + 1] := DefaultTransition;
+  transitions[ORD(CurrentState) + 1][ORD(transitionClassHex) + 1] := DefaultTransition;
+  transitions[ORD(CurrentState) + 1][ORD(transitionClassZero) + 1] := DefaultTransition;
+  transitions[ORD(CurrentState) + 1][ORD(transitionClassX) + 1] := DefaultTransition;
+  transitions[ORD(CurrentState) + 1][ORD(transitionClassEof) + 1] := DefaultTransition;
+  transitions[ORD(CurrentState) + 1][ORD(transitionClassDot) + 1] := DefaultTransition;
+  transitions[ORD(CurrentState) + 1][ORD(transitionClassMinus) + 1] := DefaultTransition;
+  transitions[ORD(CurrentState) + 1][ORD(transitionClassSingleQuote) + 1] := DefaultTransition;
+  transitions[ORD(CurrentState) + 1][ORD(transitionClassDoubleQuote) + 1] := DefaultTransition;
+  transitions[ORD(CurrentState) + 1][ORD(transitionClassGreater) + 1] := DefaultTransition;
+  transitions[ORD(CurrentState) + 1][ORD(transitionClassLess) + 1] := DefaultTransition;
+  transitions[ORD(CurrentState) + 1][ORD(transitionClassOther) + 1] := DefaultTransition
 end;
 
 (*
@@ -510,290 +511,290 @@ end;
 proc initialize_transitions();
 begin
   (* Start state. *)
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassInvalid)].Action := NIL;
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassInvalid)].NextState := transitionStateEnd;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassInvalid) + 1].Action := nil;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassInvalid) + 1].NextState := transitionStateEnd;
 
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassDigit)].Action := transition_action_accumulate;
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassDigit)].NextState := transitionStateDecimal;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassDigit) + 1].Action := transition_action_accumulate;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassDigit) + 1].NextState := transitionStateDecimal;
 
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassAlpha)].Action := transition_action_accumulate;
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassAlpha)].NextState := transitionStateIdentifier;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassAlpha) + 1].Action := transition_action_accumulate;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassAlpha) + 1].NextState := transitionStateIdentifier;
 
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassSpace)].Action := transition_action_skip;
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassSpace)].NextState := transitionStateStart;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassSpace) + 1].Action := transition_action_skip;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassSpace) + 1].NextState := transitionStateStart;
 
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassColon)].Action := transition_action_accumulate;
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassColon)].NextState := transitionStateColon;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassColon) + 1].Action := transition_action_accumulate;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassColon) + 1].NextState := transitionStateColon;
 
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassEquals)].Action := transition_action_single;
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassEquals)].NextState := transitionStateEnd;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassEquals) + 1].Action := transition_action_single;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassEquals) + 1].NextState := transitionStateEnd;
 
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassLeftParen)].Action := transition_action_accumulate;
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassLeftParen)].NextState := transitionStateLeftParen;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassLeftParen) + 1].Action := transition_action_accumulate;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassLeftParen) + 1].NextState := transitionStateLeftParen;
 
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassRightParen)].Action := transition_action_single;
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassRightParen)].NextState := transitionStateEnd;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassRightParen) + 1].Action := transition_action_single;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassRightParen) + 1].NextState := transitionStateEnd;
 
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassAsterisk)].Action := transition_action_single;
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassAsterisk)].NextState := transitionStateEnd;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassAsterisk) + 1].Action := transition_action_single;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassAsterisk) + 1].NextState := transitionStateEnd;
 
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassUnderscore)].Action := transition_action_accumulate;
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassUnderscore)].NextState := transitionStateIdentifier;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassUnderscore) + 1].Action := transition_action_accumulate;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassUnderscore) + 1].NextState := transitionStateIdentifier;
 
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassSingle)].Action := transition_action_single;
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassSingle)].NextState := transitionStateEnd;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassSingle) + 1].Action := transition_action_single;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassSingle) + 1].NextState := transitionStateEnd;
 
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassHex)].Action := transition_action_accumulate;
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassHex)].NextState := transitionStateIdentifier;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassHex) + 1].Action := transition_action_accumulate;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassHex) + 1].NextState := transitionStateIdentifier;
 
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassZero)].Action := transition_action_accumulate;
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassZero)].NextState := transitionStateLeadingZero;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassZero) + 1].Action := transition_action_accumulate;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassZero) + 1].NextState := transitionStateLeadingZero;
 
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassX)].Action := transition_action_accumulate;
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassX)].NextState := transitionStateIdentifier;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassX) + 1].Action := transition_action_accumulate;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassX) + 1].NextState := transitionStateIdentifier;
 
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassEof)].Action := transition_action_eof;
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassEof)].NextState := transitionStateEnd;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassEof) + 1].Action := transition_action_eof;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassEof) + 1].NextState := transitionStateEnd;
 
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassDot)].Action := transition_action_accumulate;
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassDot)].NextState := transitionStateDot;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassDot) + 1].Action := transition_action_accumulate;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassDot) + 1].NextState := transitionStateDot;
 
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassMinus)].Action := transition_action_accumulate;
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassMinus)].NextState := transitionStateMinus;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassMinus) + 1].Action := transition_action_accumulate;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassMinus) + 1].NextState := transitionStateMinus;
 
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassSingleQuote)].Action := transition_action_accumulate;
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassSingleQuote)].NextState := transitionStateCharacter;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassSingleQuote) + 1].Action := transition_action_accumulate;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassSingleQuote) + 1].NextState := transitionStateCharacter;
 
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassDoubleQuote)].Action := transition_action_accumulate;
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassDoubleQuote)].NextState := transitionStateString;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassDoubleQuote) + 1].Action := transition_action_accumulate;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassDoubleQuote) + 1].NextState := transitionStateString;
 
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassGreater)].Action := transition_action_accumulate;
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassGreater)].NextState := transitionStateGreater;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassGreater) + 1].Action := transition_action_accumulate;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassGreater) + 1].NextState := transitionStateGreater;
 
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassLess)].Action := transition_action_accumulate;
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassLess)].NextState := transitionStateLess;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassLess) + 1].Action := transition_action_accumulate;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassLess) + 1].NextState := transitionStateLess;
 
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassOther)].Action := NIL;
-  Transitions[ORD(transitionStateStart)][ORD(transitionClassOther)].NextState := transitionStateEnd;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassOther) + 1].Action := nil;
+  transitions[ORD(transitionStateStart) + 1][ORD(transitionClassOther) + 1].NextState := transitionStateEnd;
 
   (* Colon state. *)
   set_default_transition(transitionStateColon, transition_action_finalize, transitionStateEnd);
 
-  Transitions[ORD(transitionStateColon)][ORD(transitionClassEquals)].Action := transition_action_composite;
-  Transitions[ORD(transitionStateColon)][ORD(transitionClassEquals)].NextState := transitionStateEnd;
+  transitions[ORD(transitionStateColon) + 1][ORD(transitionClassEquals) + 1].Action := transition_action_composite;
+  transitions[ORD(transitionStateColon) + 1][ORD(transitionClassEquals) + 1].NextState := transitionStateEnd;
 
   (* Identifier state. *)
   set_default_transition(transitionStateIdentifier, transition_action_key_id, transitionStateEnd);
 
-  Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassDigit)].Action := transition_action_accumulate;
-  Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassDigit)].NextState := transitionStateIdentifier;
+  transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassDigit) + 1].Action := transition_action_accumulate;
+  transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassDigit) + 1].NextState := transitionStateIdentifier;
 
-  Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassAlpha)].Action := transition_action_accumulate;
-  Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassAlpha)].NextState := transitionStateIdentifier;
+  transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassAlpha) + 1].Action := transition_action_accumulate;
+  transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassAlpha) + 1].NextState := transitionStateIdentifier;
 
-  Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassUnderscore)].Action := transition_action_accumulate;
-  Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassUnderscore)].NextState := transitionStateIdentifier;
+  transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassUnderscore) + 1].Action := transition_action_accumulate;
+  transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassUnderscore) + 1].NextState := transitionStateIdentifier;
 
-  Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassHex)].Action := transition_action_accumulate;
-  Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassHex)].NextState := transitionStateIdentifier;
+  transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassHex) + 1].Action := transition_action_accumulate;
+  transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassHex) + 1].NextState := transitionStateIdentifier;
 
-  Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassZero)].Action := transition_action_accumulate;
-  Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassZero)].NextState := transitionStateIdentifier;
+  transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassZero) + 1].Action := transition_action_accumulate;
+  transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassZero) + 1].NextState := transitionStateIdentifier;
 
-  Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassX)].Action := transition_action_accumulate;
-  Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassX)].NextState := transitionStateIdentifier;
+  transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassX) + 1].Action := transition_action_accumulate;
+  transitions[ORD(transitionStateIdentifier) + 1][ORD(transitionClassX) + 1].NextState := transitionStateIdentifier;
 
   (* Decimal state. *)
   set_default_transition(transitionStateDecimal, transition_action_integer, transitionStateEnd);
 
-  Transitions[ORD(transitionStateDecimal)][ORD(transitionClassDigit)].Action := transition_action_accumulate;
-  Transitions[ORD(transitionStateDecimal)][ORD(transitionClassDigit)].NextState := transitionStateDecimal;
+  transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassDigit) + 1].Action := transition_action_accumulate;
+  transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassDigit) + 1].NextState := transitionStateDecimal;
 
-  Transitions[ORD(transitionStateDecimal)][ORD(transitionClassAlpha)].Action := transition_action_accumulate;
-  Transitions[ORD(transitionStateDecimal)][ORD(transitionClassAlpha)].NextState := transitionStateDecimalSuffix;
+  transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassAlpha) + 1].Action := transition_action_accumulate;
+  transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassAlpha) + 1].NextState := transitionStateDecimalSuffix;
 
-  Transitions[ORD(transitionStateDecimal)][ORD(transitionClassUnderscore)].Action := NIL;
-  Transitions[ORD(transitionStateDecimal)][ORD(transitionClassUnderscore)].NextState := transitionStateEnd;
+  transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassUnderscore) + 1].Action := nil;
+  transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassUnderscore) + 1].NextState := transitionStateEnd;
 
-  Transitions[ORD(transitionStateDecimal)][ORD(transitionClassHex)].Action := transition_action_accumulate;
-  Transitions[ORD(transitionStateDecimal)][ORD(transitionClassHex)].NextState := transitionStateDecimalSuffix;
+  transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassHex) + 1].Action := transition_action_accumulate;
+  transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassHex) + 1].NextState := transitionStateDecimalSuffix;
 
-  Transitions[ORD(transitionStateDecimal)][ORD(transitionClassZero)].Action := transition_action_accumulate;
-  Transitions[ORD(transitionStateDecimal)][ORD(transitionClassZero)].NextState := transitionStateDecimal;
+  transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassZero) + 1].Action := transition_action_accumulate;
+  transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassZero) + 1].NextState := transitionStateDecimal;
 
-  Transitions[ORD(transitionStateDecimal)][ORD(transitionClassX)].Action := transition_action_accumulate;
-  Transitions[ORD(transitionStateDecimal)][ORD(transitionClassX)].NextState := transitionStateDecimalSuffix;
+  transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassX) + 1].Action := transition_action_accumulate;
+  transitions[ORD(transitionStateDecimal) + 1][ORD(transitionClassX) + 1].NextState := transitionStateDecimalSuffix;
 
   (* Greater state. *)
   set_default_transition(transitionStateGreater, transition_action_finalize, transitionStateEnd);
 
-  Transitions[ORD(transitionStateGreater)][ORD(transitionClassEquals)].Action := transition_action_composite;
-  Transitions[ORD(transitionStateGreater)][ORD(transitionClassEquals)].NextState := transitionStateEnd;
+  transitions[ORD(transitionStateGreater) + 1][ORD(transitionClassEquals) + 1].Action := transition_action_composite;
+  transitions[ORD(transitionStateGreater) + 1][ORD(transitionClassEquals) + 1].NextState := transitionStateEnd;
 
   (* Minus state. *)
   set_default_transition(transitionStateMinus, transition_action_finalize, transitionStateEnd);
 
-  Transitions[ORD(transitionStateMinus)][ORD(transitionClassGreater)].Action := transition_action_composite;
-  Transitions[ORD(transitionStateMinus)][ORD(transitionClassGreater)].NextState := transitionStateEnd;
+  transitions[ORD(transitionStateMinus) + 1][ORD(transitionClassGreater) + 1].Action := transition_action_composite;
+  transitions[ORD(transitionStateMinus) + 1][ORD(transitionClassGreater) + 1].NextState := transitionStateEnd;
 
   (* Left paren state. *)
   set_default_transition(transitionStateLeftParen, transition_action_finalize, transitionStateEnd);
 
-  Transitions[ORD(transitionStateLeftParen)][ORD(transitionClassAsterisk)].Action := transition_action_accumulate;
-  Transitions[ORD(transitionStateLeftParen)][ORD(transitionClassAsterisk)].NextState := transitionStateComment;
+  transitions[ORD(transitionStateLeftParen) + 1][ORD(transitionClassAsterisk) + 1].Action := transition_action_accumulate;
+  transitions[ORD(transitionStateLeftParen) + 1][ORD(transitionClassAsterisk) + 1].NextState := transitionStateComment;
 
   (* Less state. *)
   set_default_transition(transitionStateLess, transition_action_finalize, transitionStateEnd);
 
-  Transitions[ORD(transitionStateLess)][ORD(transitionClassEquals)].Action := transition_action_composite;
-  Transitions[ORD(transitionStateLess)][ORD(transitionClassEquals)].NextState := transitionStateEnd;
+  transitions[ORD(transitionStateLess) + 1][ORD(transitionClassEquals) + 1].Action := transition_action_composite;
+  transitions[ORD(transitionStateLess) + 1][ORD(transitionClassEquals) + 1].NextState := transitionStateEnd;
 
-  Transitions[ORD(transitionStateLess)][ORD(transitionClassGreater)].Action := transition_action_composite;
-  Transitions[ORD(transitionStateLess)][ORD(transitionClassGreater)].NextState := transitionStateEnd;
+  transitions[ORD(transitionStateLess) + 1][ORD(transitionClassGreater) + 1].Action := transition_action_composite;
+  transitions[ORD(transitionStateLess) + 1][ORD(transitionClassGreater) + 1].NextState := transitionStateEnd;
 
   (* Hexadecimal after 0x. *)
   set_default_transition(transitionStateDot, transition_action_finalize, transitionStateEnd);
 
-  Transitions[ORD(transitionStateDot)][ORD(transitionClassDot)].Action := transition_action_composite;
-  Transitions[ORD(transitionStateDot)][ORD(transitionClassDot)].NextState := transitionStateEnd;
+  transitions[ORD(transitionStateDot) + 1][ORD(transitionClassDot) + 1].Action := transition_action_composite;
+  transitions[ORD(transitionStateDot) + 1][ORD(transitionClassDot) + 1].NextState := transitionStateEnd;
 
   (* Comment. *)
   set_default_transition(transitionStateComment, transition_action_accumulate, transitionStateComment);
 
-  Transitions[ORD(transitionStateComment)][ORD(transitionClassAsterisk)].Action := transition_action_accumulate;
-  Transitions[ORD(transitionStateComment)][ORD(transitionClassAsterisk)].NextState := transitionStateClosingComment;
+  transitions[ORD(transitionStateComment) + 1][ORD(transitionClassAsterisk) + 1].Action := transition_action_accumulate;
+  transitions[ORD(transitionStateComment) + 1][ORD(transitionClassAsterisk) + 1].NextState := transitionStateClosingComment;
 
-  Transitions[ORD(transitionStateComment)][ORD(transitionClassEof)].Action := NIL;
-  Transitions[ORD(transitionStateComment)][ORD(transitionClassEof)].NextState := transitionStateEnd;
+  transitions[ORD(transitionStateComment) + 1][ORD(transitionClassEof) + 1].Action := nil;
+  transitions[ORD(transitionStateComment) + 1][ORD(transitionClassEof) + 1].NextState := transitionStateEnd;
 
   (* Closing comment. *)
   set_default_transition(transitionStateClosingComment, transition_action_accumulate, transitionStateComment);
 
-  Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassInvalid)].Action := NIL;
-  Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassInvalid)].NextState := transitionStateEnd;
+  transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassInvalid) + 1].Action := nil;
+  transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassInvalid) + 1].NextState := transitionStateEnd;
 
-  Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassRightParen)].Action := transition_action_delimited;
-  Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassRightParen)].NextState := transitionStateEnd;
+  transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassRightParen) + 1].Action := transition_action_delimited;
+  transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassRightParen) + 1].NextState := transitionStateEnd;
 
-  Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassAsterisk)].Action := transition_action_accumulate;
-  Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassAsterisk)].NextState := transitionStateClosingComment;
+  transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassAsterisk) + 1].Action := transition_action_accumulate;
+  transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassAsterisk) + 1].NextState := transitionStateClosingComment;
 
-  Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassEof)].Action := NIL;
-  Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassEof)].NextState := transitionStateEnd;
+  transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassEof) + 1].Action := nil;
+  transitions[ORD(transitionStateClosingComment) + 1][ORD(transitionClassEof) + 1].NextState := transitionStateEnd;
 
   (* Character. *)
   set_default_transition(transitionStateCharacter, transition_action_accumulate, transitionStateCharacter);
 
-  Transitions[ORD(transitionStateCharacter)][ORD(transitionClassInvalid)].Action := NIL;
-  Transitions[ORD(transitionStateCharacter)][ORD(transitionClassInvalid)].NextState := transitionStateEnd;
+  transitions[ORD(transitionStateCharacter) + 1][ORD(transitionClassInvalid) + 1].Action := nil;
+  transitions[ORD(transitionStateCharacter) + 1][ORD(transitionClassInvalid) + 1].NextState := transitionStateEnd;
 
-  Transitions[ORD(transitionStateCharacter)][ORD(transitionClassEof)].Action := NIL;
-  Transitions[ORD(transitionStateCharacter)][ORD(transitionClassEof)].NextState := transitionStateEnd;
+  transitions[ORD(transitionStateCharacter) + 1][ORD(transitionClassEof) + 1].Action := nil;
+  transitions[ORD(transitionStateCharacter) + 1][ORD(transitionClassEof) + 1].NextState := transitionStateEnd;
 
-  Transitions[ORD(transitionStateCharacter)][ORD(transitionClassSingleQuote)].Action := transition_action_delimited;
-  Transitions[ORD(transitionStateCharacter)][ORD(transitionClassSingleQuote)].NextState := transitionStateEnd;
+  transitions[ORD(transitionStateCharacter) + 1][ORD(transitionClassSingleQuote) + 1].Action := transition_action_delimited;
+  transitions[ORD(transitionStateCharacter) + 1][ORD(transitionClassSingleQuote) + 1].NextState := transitionStateEnd;
 
   (* String. *)
   set_default_transition(transitionStateString, transition_action_accumulate, transitionStateString);
 
-  Transitions[ORD(transitionStateString)][ORD(transitionClassInvalid)].Action := NIL;
-  Transitions[ORD(transitionStateString)][ORD(transitionClassInvalid)].NextState := transitionStateEnd;
+  transitions[ORD(transitionStateString) + 1][ORD(transitionClassInvalid) + 1].Action := nil;
+  transitions[ORD(transitionStateString) + 1][ORD(transitionClassInvalid) + 1].NextState := transitionStateEnd;
 
-  Transitions[ORD(transitionStateString)][ORD(transitionClassEof)].Action := NIL;
-  Transitions[ORD(transitionStateString)][ORD(transitionClassEof)].NextState := transitionStateEnd;
+  transitions[ORD(transitionStateString) + 1][ORD(transitionClassEof) + 1].Action := nil;
+  transitions[ORD(transitionStateString) + 1][ORD(transitionClassEof) + 1].NextState := transitionStateEnd;
 
-  Transitions[ORD(transitionStateString)][ORD(transitionClassDoubleQuote)].Action := transition_action_delimited;
-  Transitions[ORD(transitionStateString)][ORD(transitionClassDoubleQuote)].NextState := transitionStateEnd;
+  transitions[ORD(transitionStateString) + 1][ORD(transitionClassDoubleQuote) + 1].Action := transition_action_delimited;
+  transitions[ORD(transitionStateString) + 1][ORD(transitionClassDoubleQuote) + 1].NextState := transitionStateEnd;
 
   (* Leading zero. *)
   set_default_transition(transitionStateLeadingZero, transition_action_integer, transitionStateEnd);
 
-  Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassDigit)].Action := NIL;
-  Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassDigit)].NextState := transitionStateEnd;
+  transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassDigit) + 1].Action := nil;
+  transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassDigit) + 1].NextState := transitionStateEnd;
 
-  Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassAlpha)].Action := NIL;
-  Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassAlpha)].NextState := transitionStateEnd;
+  transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassAlpha) + 1].Action := nil;
+  transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassAlpha) + 1].NextState := transitionStateEnd;
 
-  Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassUnderscore)].Action := NIL;
-  Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassUnderscore)].NextState := transitionStateEnd;
+  transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassUnderscore) + 1].Action := nil;
+  transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassUnderscore) + 1].NextState := transitionStateEnd;
 
-  Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassHex)].Action := NIL;
-  Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassHex)].NextState := transitionStateEnd;
+  transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassHex) + 1].Action := nil;
+  transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassHex) + 1].NextState := transitionStateEnd;
 
-  Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassZero)].Action := NIL;
-  Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassZero)].NextState := transitionStateEnd;
+  transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassZero) + 1].Action := nil;
+  transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassZero) + 1].NextState := transitionStateEnd;
 
-  Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassX)].Action := NIL;
-  Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassX)].NextState := transitionStateEnd;
+  transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassX) + 1].Action := nil;
+  transitions[ORD(transitionStateLeadingZero) + 1][ORD(transitionClassX) + 1].NextState := transitionStateEnd;
 
   (* Digit with a character suffix. *)
   set_default_transition(transitionStateDecimalSuffix, transition_action_integer, transitionStateEnd);
 
-  Transitions[ORD(transitionStateDecimalSuffix)][ORD(transitionClassAlpha)].Action := NIL;
-  Transitions[ORD(transitionStateDecimalSuffix)][ORD(transitionClassAlpha)].NextState := transitionStateEnd;
+  transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassAlpha) + 1].Action := nil;
+  transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassAlpha) + 1].NextState := transitionStateEnd;
 
-  Transitions[ORD(transitionStateDecimalSuffix)][ORD(transitionClassDigit)].Action := NIL;
-  Transitions[ORD(transitionStateDecimalSuffix)][ORD(transitionClassDigit)].NextState := transitionStateEnd;
+  transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassDigit) + 1].Action := nil;
+  transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassDigit) + 1].NextState := transitionStateEnd;
 
-  Transitions[ORD(transitionStateDecimalSuffix)][ORD(transitionClassHex)].Action := NIL;
-  Transitions[ORD(transitionStateDecimalSuffix)][ORD(transitionClassHex)].NextState := transitionStateEnd;
+  transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassHex) + 1].Action := nil;
+  transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassHex) + 1].NextState := transitionStateEnd;
 
-  Transitions[ORD(transitionStateDecimalSuffix)][ORD(transitionClassZero)].Action := NIL;
-  Transitions[ORD(transitionStateDecimalSuffix)][ORD(transitionClassZero)].NextState := transitionStateEnd;
+  transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassZero) + 1].Action := nil;
+  transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassZero) + 1].NextState := transitionStateEnd;
 
-  Transitions[ORD(transitionStateDecimalSuffix)][ORD(transitionClassX)].Action := NIL;
-  Transitions[ORD(transitionStateDecimalSuffix)][ORD(transitionClassX)].NextState := transitionStateEnd
+  transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassX) + 1].Action := nil;
+  transitions[ORD(transitionStateDecimalSuffix) + 1][ORD(transitionClassX) + 1].NextState := transitionStateEnd
 end;
 
-proc lexer_initialize(ALexer: PLexer; Input: File);
+proc lexer_initialize(lexer: PLexer,  Input: File);
 begin
-  ALexer^.Input := Input;
-  ALexer^.Length := 0;
+  lexer^.Input := Input;
+  lexer^.Length := 0;
 
-  ALLOCATE(ALexer^.Buffer, ChunkSize);
-  MemZero(ALexer^.Buffer, ChunkSize);
-  ALexer^.Size := ChunkSize
+  ALLOCATE(lexer^.Buffer, CHUNK_SIZE);
+  MemZero(lexer^.Buffer, CHUNK_SIZE);
+  lexer^.Size := CHUNK_SIZE
 end;
 
-proc lexer_current(ALexer: PLexer): LexerToken;
+proc lexer_current(lexer: PLexer): LexerToken;
 var
   CurrentClass: TransitionClass;
   CurrentState: TransitionState;
   CurrentTransition: Transition;
   Result: LexerToken;
 begin
-  ALexer^.Current := ALexer^.Start;
+  lexer^.Current := lexer^.Start;
   CurrentState := transitionStateStart;
 
   while CurrentState <> transitionStateEnd DO
-    CurrentClass := Classification[ORD(ALexer^.Current^) + 1];
+    CurrentClass := classification[ORD(lexer^.Current^) + 1];
 
-    CurrentTransition := Transitions[ORD(CurrentState)][ORD(CurrentClass)];
-    if CurrentTransition.Action <> NIL then
-      CurrentTransition.Action(ALexer, ADR(Result))
+    CurrentTransition := transitions[ORD(CurrentState) + 1][ORD(CurrentClass) + 1];
+    if CurrentTransition.Action <> nil then
+      CurrentTransition.Action(lexer, ADR(Result))
     end;
     CurrentState := CurrentTransition.NextState
   end;
   return Result
 end;
 
-proc lexer_lex(ALexer: PLexer): LexerToken;
+proc lexer_lex(lexer: PLexer): LexerToken;
 var
   Result: LexerToken;
 begin
-  if ALexer^.Length = 0 then
-    ALexer^.Length := ReadNBytes(ALexer^.Input, ChunkSize, ALexer^.Buffer);
-    ALexer^.Current := ALexer^.Buffer
+  if lexer^.Length = 0 then
+    lexer^.Length := ReadNBytes(lexer^.Input, CHUNK_SIZE, lexer^.Buffer);
+    lexer^.Current := lexer^.Buffer
   end;
-  ALexer^.Start := ALexer^.Current;
+  lexer^.Start := lexer^.Current;
 
-  Result := lexer_current(ALexer);
+  Result := lexer_current(lexer);
   return Result
 end;
 
-proc lexer_destroy(ALexer: PLexer);
+proc lexer_destroy(lexer: PLexer);
 begin
-  DEALLOCATE(ALexer^.Buffer, ALexer^.Size)
+  DEALLOCATE(lexer^.Buffer, lexer^.Size)
 end;
 
 begin
diff --git a/source/Transpiler.elna b/source/Transpiler.elna
index 0ece102..bdb6c5a 100644
--- a/source/Transpiler.elna
+++ b/source/Transpiler.elna
@@ -13,17 +13,17 @@ type
   end;
 
 (* Calls lexer_lex() but skips the comments. *)
-proc transpiler_lex(ALexer: PLexer): LexerToken;
+proc transpiler_lex(lexer: PLexer): LexerToken;
 var
-  Result: LexerToken;
+  result: LexerToken;
 begin
-  Result := lexer_lex(ALexer);
+  result := lexer_lex(lexer);
 
-  while Result.Kind = lexerKindComment do
-    Result := lexer_lex(ALexer)
+  while result.Kind = lexerKindComment do
+    result := lexer_lex(lexer)
   end;
 
-  return Result
+  return result
 end;
 
 (* Write a semicolon followed by a newline. *)
@@ -33,552 +33,569 @@ begin
   WriteLn()
 end;
 
-proc transpile_import(AContext: PTranspilerContext; ALexer: PLexer);
+proc transpile_import(context: PTranspilerContext,  lexer: PLexer);
 var
-  Token: LexerToken;
-  WrittenBytes: CARDINAL;
+  token: LexerToken;
+  written_bytes: CARDINAL;
 begin
   WriteString('FROM ');
-  Token := transpiler_lex(ALexer);
+  token := transpiler_lex(lexer);
 
-  WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
+  written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
 
-  Token := transpiler_lex(ALexer);
+  token := transpiler_lex(lexer);
   WriteString(' IMPORT ');
 
-  Token := transpiler_lex(ALexer);
-  WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
+  token := transpiler_lex(lexer);
+  written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
 
-  Token := transpiler_lex(ALexer);
-  while Token.Kind <> lexerKindSemicolon do
+  token := transpiler_lex(lexer);
+  while token.Kind <> lexerKindSemicolon do
     WriteString(', ');
-    Token := transpiler_lex(ALexer);
-    WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
-    Token := transpiler_lex(ALexer)
+    token := transpiler_lex(lexer);
+    written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
+    token := transpiler_lex(lexer)
   end;
   write_semicolon();
-  Token := transpiler_lex(ALexer)
+  token := transpiler_lex(lexer)
 end;
 
-proc transpile_import_part(AContext: PTranspilerContext; ALexer: PLexer);
+proc transpile_import_part(context: PTranspilerContext,  lexer: PLexer);
 var
-  Token: LexerToken;
+  token: LexerToken;
 begin
-  Token := lexer_current(ALexer);
+  token := lexer_current(lexer);
 
-  while Token.Kind = lexerKindFrom do
-    transpile_import(AContext, ALexer);
-    Token := lexer_current(ALexer)
+  while token.Kind = lexerKindFrom do
+    transpile_import(context, lexer);
+    token := lexer_current(lexer)
   end;
   WriteLn()
 end;
 
-proc transpile_constant(AContext: PTranspilerContext; ALexer: PLexer);
+proc transpile_constant(context: PTranspilerContext,  lexer: PLexer);
 var
   Token: LexerToken;
-  WrittenBytes: CARDINAL;
+  written_bytes: CARDINAL;
 begin
   WriteString('  ');
-  Token := lexer_current(ALexer);
-  WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
+  Token := lexer_current(lexer);
+  written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
 
-  Token := transpiler_lex(ALexer);
+  Token := transpiler_lex(lexer);
   WriteString(' = ');
 
-  Token := transpiler_lex(ALexer);
-  WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
+  Token := transpiler_lex(lexer);
+  written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
 
-  Token := transpiler_lex(ALexer);
+  Token := transpiler_lex(lexer);
   write_semicolon()
 end;
 
-proc transpile_constant_part(AContext: PTranspilerContext; ALexer: PLexer): BOOLEAN;
+proc transpile_constant_part(context: PTranspilerContext,  lexer: PLexer): BOOLEAN;
 var
   Token: LexerToken;
-  Result: BOOLEAN;
+  result: BOOLEAN;
 begin
-  Token := lexer_current(ALexer);
-  Result := Token.Kind = lexerKindConst;
+  Token := lexer_current(lexer);
+  result := Token.Kind = lexerKindConst;
 
-  if Result then
+  if result then
     WriteString('CONST');
     WriteLn();
-    Token := transpiler_lex(ALexer);
+    Token := transpiler_lex(lexer);
 
     while Token.Kind = lexerKindIdentifier do
-      transpile_constant(AContext, ALexer);
-      Token := transpiler_lex(ALexer)
+      transpile_constant(context, lexer);
+      Token := transpiler_lex(lexer)
     end
   end;
-  return Result
+  return result
 end;
 
-proc transpile_module(AContext: PTranspilerContext; ALexer: PLexer);
+proc transpile_module(context: PTranspilerContext,  lexer: PLexer);
 var
   Token: LexerToken;
-  WrittenBytes: CARDINAL;
+  written_bytes: CARDINAL;
 begin
-  Token := transpiler_lex(ALexer);
+  Token := transpiler_lex(lexer);
 
   if Token.Kind = lexerKindDefinition then
     WriteString('DEFINITION ');
-    Token := transpiler_lex(ALexer)
+    Token := transpiler_lex(lexer)
   end;
   if Token.Kind = lexerKindImplementation then
     WriteString('IMPLEMENTATION ');
-    Token := transpiler_lex(ALexer)
+    Token := transpiler_lex(lexer)
   end;
   WriteString('MODULE ');
 
   (* Write the module name and end the line with a semicolon and newline. *)
-  Token := transpiler_lex(ALexer);
-  WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
+  Token := transpiler_lex(lexer);
+  written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
 
-  Token := transpiler_lex(ALexer);
+  Token := transpiler_lex(lexer);
   write_semicolon();
   WriteLn();
 
   (* Write the module body. *)
-  Token := transpiler_lex(ALexer);
-  transpile_import_part(AContext, ALexer);
-  if transpile_constant_part(AContext, ALexer) then
+  Token := transpiler_lex(lexer);
+  transpile_import_part(context, lexer);
+  if transpile_constant_part(context, lexer) then
     WriteLn()
   end;
-  transpile_type_part(AContext, ALexer);
-  if transpile_variable_part(AContext, ALexer) then
+  transpile_type_part(context, lexer);
+  if transpile_variable_part(context, lexer) then
     WriteLn()
   end;
-  transpile_procedure_part(AContext, ALexer);
-  transpile_statement_part(AContext, ALexer);
+  transpile_procedure_part(context, lexer);
+  transpile_statement_part(context, lexer);
 
   WriteString('END ');
 
-  Token := transpiler_lex(ALexer);
-  WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
+  Token := transpiler_lex(lexer);
+  written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
 
-  Token := transpiler_lex(ALexer);
+  Token := transpiler_lex(lexer);
   Write('.');
 
-  Token := transpiler_lex(ALexer);
+  Token := transpiler_lex(lexer);
   WriteLn()
 end;
 
-proc transpile_type_fields(AContext: PTranspilerContext; ALexer: PLexer);
+proc transpile_type_fields(context: PTranspilerContext,  lexer: PLexer);
 var
   Token: LexerToken;
-  WrittenBytes: CARDINAL;
+  written_bytes: CARDINAL;
 begin
-  Token := transpiler_lex(ALexer);
+  Token := transpiler_lex(lexer);
 
   while Token.Kind <> lexerKindEnd do
     WriteString('    ');
-    WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
-    Token := transpiler_lex(ALexer);
+    written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
+    Token := transpiler_lex(lexer);
     WriteString(': ');
-    transpile_type_expression(AContext, ALexer);
-    Token := transpiler_lex(ALexer);
+    transpile_type_expression(context, lexer);
+    Token := transpiler_lex(lexer);
 
     if Token.Kind = lexerKindSemicolon then
-      Token := transpiler_lex(ALexer);
+      Token := transpiler_lex(lexer);
       Write(';')
     end;
     WriteLn()
   end
 end;
 
-proc transpile_record_type(AContext: PTranspilerContext; ALexer: PLexer);
+proc transpile_record_type(context: PTranspilerContext,  lexer: PLexer);
 var
   Token: LexerToken;
 begin
   WriteString('RECORD');
   WriteLn();
-  transpile_type_fields(AContext, ALexer);
+  transpile_type_fields(context, lexer);
   WriteString('  END')
 end;
 
-proc transpile_pointer_type(AContext: PTranspilerContext; ALexer: PLexer);
+proc transpile_pointer_type(context: PTranspilerContext,  lexer: PLexer);
 var
   Token: LexerToken;
-  WrittenBytes: CARDINAL;
+  written_bytes: CARDINAL;
 begin
-  Token := lexer_current(ALexer);
+  Token := lexer_current(lexer);
   WriteString('POINTER TO ');
   if Token.Kind = lexerKindPointer then
-    Token := transpiler_lex(ALexer)
+    Token := transpiler_lex(lexer)
   end;
-  transpile_type_expression(AContext, ALexer)
+  transpile_type_expression(context, lexer)
 end;
 
-proc transpile_array_type(AContext: PTranspilerContext; ALexer: PLexer);
+proc transpile_array_type(context: PTranspilerContext,  lexer: PLexer);
 var
   Token: LexerToken;
-  WrittenBytes: CARDINAL;
+  written_bytes: CARDINAL;
 begin
   WriteString('ARRAY');
-  Token := transpiler_lex(ALexer);
+  Token := lexer_current(lexer);
 
+  if Token.Kind = lexerKindArray then
+    Token := transpiler_lex(lexer)
+  end;
   if Token.Kind <> lexerKindOf then
-    Write('[');
-    Token := transpiler_lex(ALexer);
-    WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
-    Token := transpiler_lex(ALexer);
-    WriteString('..');
-    Token := transpiler_lex(ALexer);
-    WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
-    Token := transpiler_lex(ALexer);
-    Write(']');
-    Token := transpiler_lex(ALexer)
+    WriteString('[1..');
+    Token := transpiler_lex(lexer);
+    written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
+    Token := transpiler_lex(lexer);
+    Write(']')
   end;
   WriteString(' OF ');
-  transpile_type_expression(AContext, ALexer)
+  transpile_type_expression(context, lexer)
 end;
 
-proc transpile_enumeration_type(AContext: PTranspilerContext; ALexer: PLexer);
+proc transpile_enumeration_type(context: PTranspilerContext,  lexer: PLexer);
 var
   Token: LexerToken;
-  WrittenBytes: CARDINAL;
+  written_bytes: CARDINAL;
 begin
   WriteString('(');
   WriteLn();
   WriteString('    ');
 
-  Token := transpiler_lex(ALexer);
-  WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
+  Token := transpiler_lex(lexer);
+  written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
 
-  Token := transpiler_lex(ALexer);
+  Token := transpiler_lex(lexer);
 
   while Token.Kind = lexerKindComma do
     Write(',');
     WriteLn();
     WriteString('    ');
-    Token := transpiler_lex(ALexer);
-    WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
+    Token := transpiler_lex(lexer);
+    written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
 
-    Token := transpiler_lex(ALexer)
+    Token := transpiler_lex(lexer)
   end;
   WriteLn();
   WriteString('  )')
 end;
 
-proc transpile_union_type(AContext: PTranspilerContext; ALexer: PLexer);
+proc transpile_union_type(context: PTranspilerContext,  lexer: PLexer);
 var
   Token: LexerToken;
 end;
 
-proc transpile_procedure_type(AContext: PTranspilerContext; ALexer: PLexer);
+proc transpile_procedure_type(context: PTranspilerContext,  lexer: PLexer);
 var
   Token: LexerToken;
-  WrittenBytes: CARDINAL;
+  written_bytes: CARDINAL;
 begin
-  Token := transpiler_lex(ALexer);
+  Token := transpiler_lex(lexer);
   WriteString('PROCEDURE(');
 
-  Token := transpiler_lex(ALexer);
+  Token := transpiler_lex(lexer);
 
   while Token.Kind <> lexerKindRightParen do
-    WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
+    written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
 
-    Token := transpiler_lex(ALexer);
+    Token := transpiler_lex(lexer);
     if Token.Kind = lexerKindComma then
-      Token := transpiler_lex(ALexer);
+      Token := transpiler_lex(lexer);
       WriteString(', ')
     end
   end;
   Write(')')
 end;
 
-proc transpile_type_expression(AContext: PTranspilerContext; ALexer: PLexer);
+proc transpile_type_expression(context: PTranspilerContext,  lexer: PLexer);
 var
   Token: LexerToken;
-  WrittenBytes: CARDINAL;
+  written_bytes: CARDINAL;
 begin
-  Token := transpiler_lex(ALexer);
+  Token := transpiler_lex(lexer);
   if Token.Kind = lexerKindRecord then
-    transpile_record_type(AContext, ALexer)
+    transpile_record_type(context, lexer)
   end;
   if Token.Kind = lexerKindLeftParen then
-    transpile_enumeration_type(AContext, ALexer)
+    transpile_enumeration_type(context, lexer)
   end;
-  if Token.Kind = lexerKindArray then
-    transpile_array_type(AContext, ALexer)
+  if (Token.Kind = lexerKindArray) or (Token.Kind = lexerKindLeftSquare) then
+    transpile_array_type(context, lexer)
   end;
-  if (Token.Kind = lexerKindPointer) OR (Token.Kind = lexerKindHat) then
-    transpile_pointer_type(AContext, ALexer)
+  if Token.Kind = lexerKindHat then
+    transpile_pointer_type(context, lexer)
   end;
   if Token.Kind = lexerKindProc then
-    transpile_procedure_type(AContext, ALexer)
+    transpile_procedure_type(context, lexer)
   end;
   if Token.Kind = lexerKindIdentifier then
-    WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start)
+    written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start)
   end
 end;
 
-proc transpile_type_declaration(AContext: PTranspilerContext; ALexer: PLexer);
+proc transpile_type_declaration(context: PTranspilerContext,  lexer: PLexer);
 var
   Token: LexerToken;
-  WrittenBytes: CARDINAL;
+  written_bytes: CARDINAL;
 begin
   WriteString('  ');
-  Token := lexer_current(ALexer);
-  WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
+  Token := lexer_current(lexer);
+  written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
 
-  Token := transpiler_lex(ALexer);
+  Token := transpiler_lex(lexer);
   WriteString(' = ');
-  transpile_type_expression(AContext, ALexer);
-  Token := transpiler_lex(ALexer);
+  transpile_type_expression(context, lexer);
+  Token := transpiler_lex(lexer);
   write_semicolon();
 end;
 
-proc transpile_type_part(AContext: PTranspilerContext; ALexer: PLexer);
+proc transpile_type_part(context: PTranspilerContext,  lexer: PLexer);
 var
-  Token: LexerToken;
+  token: LexerToken;
 begin
-  Token := lexer_current(ALexer);
+  token := lexer_current(lexer);
 
-  if Token.Kind = lexerKindType then
+  if token.Kind = lexerKindType then
     WriteString('TYPE');
     WriteLn();
-    Token := transpiler_lex(ALexer);
+    token := transpiler_lex(lexer);
 
-    while Token.Kind = lexerKindIdentifier do
-      transpile_type_declaration(AContext, ALexer);
-      Token := transpiler_lex(ALexer)
+    while token.Kind = lexerKindIdentifier do
+      transpile_type_declaration(context, lexer);
+      token := transpiler_lex(lexer)
     end;
     WriteLn()
   end
 end;
 
-proc transpile_variable_declaration(AContext: PTranspilerContext; ALexer: PLexer);
+proc transpile_variable_declaration(context: PTranspilerContext,  lexer: PLexer);
 var
   Token: LexerToken;
-  WrittenBytes: CARDINAL;
+  written_bytes: CARDINAL;
 begin
   WriteString('  ');
-  Token := lexer_current(ALexer);
-  WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
+  Token := lexer_current(lexer);
+  written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
 
-  Token := transpiler_lex(ALexer);
+  Token := transpiler_lex(lexer);
   WriteString(': ');
-  transpile_type_expression(AContext, ALexer);
-  Token := transpiler_lex(ALexer);
+  transpile_type_expression(context, lexer);
+  Token := transpiler_lex(lexer);
   write_semicolon()
 end;
 
-proc transpile_variable_part(AContext: PTranspilerContext; ALexer: PLexer): BOOLEAN;
+proc transpile_variable_part(context: PTranspilerContext,  lexer: PLexer): BOOLEAN;
 var
   Token: LexerToken;
-  Result: BOOLEAN;
+  result: BOOLEAN;
 begin
-  Token := lexer_current(ALexer);
-  Result := Token.Kind = lexerKindVar;
+  Token := lexer_current(lexer);
+  result := Token.Kind = lexerKindVar;
 
-  if Result then
+  if result then
     WriteString('VAR');
     WriteLn();
-    Token := transpiler_lex(ALexer);
+    Token := transpiler_lex(lexer);
 
     while Token.Kind = lexerKindIdentifier do
-      transpile_variable_declaration(AContext, ALexer);
-      Token := transpiler_lex(ALexer)
+      transpile_variable_declaration(context, lexer);
+      Token := transpiler_lex(lexer)
     end
   end;
-  return Result
+  return result
 end;
 
-proc transpile_procedure_heading(AContext: PTranspilerContext; ALexer: PLexer): LexerToken;
+proc transpile_procedure_heading(context: PTranspilerContext, lexer: PLexer): LexerToken;
 var
-  Token: LexerToken;
-  Result: LexerToken;
-  WrittenBytes: CARDINAL;
+  token: LexerToken;
+  result: LexerToken;
+  written_bytes: CARDINAL;
 begin
   WriteString('PROCEDURE ');
 
-  Result := transpiler_lex(ALexer);
-  WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
+  result := transpiler_lex(lexer);
+  written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
 
-  Token := transpiler_lex(ALexer);
+  token := transpiler_lex(lexer);
   Write('(');
 
-  Token := transpiler_lex(ALexer);
-  while Token.Kind <> lexerKindRightParen do
-    WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
+  token := transpiler_lex(lexer);
+  while token.Kind <> lexerKindRightParen do
+    written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
 
-    Token := transpiler_lex(ALexer);
+    token := transpiler_lex(lexer);
     WriteString(': ');
 
-    transpile_type_expression(AContext, ALexer);
+    transpile_type_expression(context, lexer);
 
-    Token := transpiler_lex(ALexer);
-    if Token.Kind = lexerKindSemicolon then
+    token := transpiler_lex(lexer);
+    if (token.Kind = lexerKindSemicolon) or (token.Kind = lexerKindComma) then
       WriteString('; ');
-      Token := transpiler_lex(ALexer)
+      token := transpiler_lex(lexer)
     end
   end;
   WriteString(')');
-  Token := transpiler_lex(ALexer);
+  token := transpiler_lex(lexer);
 
   (* Check for the return type and write it. *)
-  if Token.Kind = lexerKindColon then
+  if token.Kind = lexerKindColon then
     WriteString(': ');
-    Token := transpiler_lex(ALexer);
-    WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
-    Token := transpiler_lex(ALexer)
+    token := transpiler_lex(lexer);
+    written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
+    token := transpiler_lex(lexer)
   end;
-  Token := transpiler_lex(ALexer);
+  token := transpiler_lex(lexer);
   write_semicolon();
 
-  return Result
+  return result
 end;
 
-proc transpile_expression(AContext: PTranspilerContext; ALexer: PLexer; TrailingToken: LexerKind);
+proc transpile_expression(context: PTranspilerContext,  lexer: PLexer,  TrailingToken: LexerKind);
 var
-  Token: LexerToken;
-  WrittenBytes: CARDINAL;
+  token: LexerToken;
+  written_bytes: CARDINAL;
 begin
-  Token := transpiler_lex(ALexer);
+  token := transpiler_lex(lexer);
 
-  while (Token.Kind <> TrailingToken) AND (Token.Kind <> lexerKindEnd) do
-    WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
-    Write(' ');
-    Token := transpiler_lex(ALexer)
+  while (token.Kind <> TrailingToken) & (token.Kind <> lexerKindEnd) do
+    written_bytes := 0;
+    if token.Kind = lexerKindNull then
+      WriteString('NIL ');
+      written_bytes := 1
+    end;
+    if token.Kind = lexerKindOr then
+      WriteString('OR ');
+      written_bytes := 1
+    end;
+    if token.Kind = lexerKindAnd then
+      WriteString('AND ');
+      written_bytes := 1
+    end;
+    if token.Kind = lexerKindNot then
+      WriteString('NOT ');
+      written_bytes := 1
+    end;
+    if written_bytes = 0 then
+      written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
+      Write(' ')
+    end;
+    token := transpiler_lex(lexer)
   end
 end;
 
-proc transpile_if_statement(AContext: PTranspilerContext; ALexer: PLexer);
+proc transpile_if_statement(context: PTranspilerContext,  lexer: PLexer);
 var
-  Token: LexerToken;
-  WrittenBytes: CARDINAL;
+  token: LexerToken;
+  written_bytes: CARDINAL;
 begin
   WriteString('  IF ');
-  transpile_expression(AContext, ALexer, lexerKindThen);
+  transpile_expression(context, lexer, lexerKindThen);
 
   WriteString('THEN');
   WriteLn();
-  transpile_statements(AContext, ALexer);
+  transpile_statements(context, lexer);
   WriteString('  END');
-  Token := transpiler_lex(ALexer)
+  token := transpiler_lex(lexer)
 end;
 
-proc transpile_while_statement(AContext: PTranspilerContext; ALexer: PLexer);
+proc transpile_while_statement(context: PTranspilerContext,  lexer: PLexer);
 var
   Token: LexerToken;
-  WrittenBytes: CARDINAL;
+  written_bytes: CARDINAL;
 begin
   WriteString('  WHILE ');
-  transpile_expression(AContext, ALexer, lexerKindDo);
+  transpile_expression(context, lexer, lexerKindDo);
 
   WriteString('DO');
   WriteLn();
-  transpile_statements(AContext, ALexer);
+  transpile_statements(context, lexer);
   WriteString('  END');
-  Token := transpiler_lex(ALexer)
+  Token := transpiler_lex(lexer)
 end;
 
-proc transpile_assignment_statement(AContext: PTranspilerContext; ALexer: PLexer);
+proc transpile_assignment_statement(context: PTranspilerContext,  lexer: PLexer);
 begin
   WriteString(' := ');
-  transpile_expression(AContext, ALexer, lexerKindSemicolon);
+  transpile_expression(context, lexer, lexerKindSemicolon);
 end;
 
-proc transpile_call_statement(AContext: PTranspilerContext; ALexer: PLexer);
+proc transpile_call_statement(context: PTranspilerContext,  lexer: PLexer);
 var
   Token: LexerToken;
-  WrittenBytes: CARDINAL;
+  written_bytes: CARDINAL;
 begin
   WriteString('(');
-  Token := transpiler_lex(ALexer);
+  Token := transpiler_lex(lexer);
 
-  while (Token.Kind <> lexerKindSemicolon) AND (Token.Kind <> lexerKindEnd) do
-    WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
-    Token := transpiler_lex(ALexer)
+  while (Token.Kind <> lexerKindSemicolon) & (Token.Kind <> lexerKindEnd) do
+    written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
+    Token := transpiler_lex(lexer)
   end
 end;
 
-proc transpile_return_statement(AContext: PTranspilerContext; ALexer: PLexer);
+proc transpile_return_statement(context: PTranspilerContext,  lexer: PLexer);
 var
   Token: LexerToken;
-  WrittenBytes: CARDINAL;
+  written_bytes: CARDINAL;
 begin
   WriteString('  RETURN ');
-  Token := transpiler_lex(ALexer);
-  WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
-  Token := transpiler_lex(ALexer)
+  Token := transpiler_lex(lexer);
+  written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
+  Token := transpiler_lex(lexer)
 end;
 
-proc transpile_statement(AContext: PTranspilerContext; ALexer: PLexer);
+proc transpile_statement(context: PTranspilerContext,  lexer: PLexer);
 var
-  Token: LexerToken;
-  WrittenBytes: CARDINAL;
+  token: LexerToken;
+  written_bytes: CARDINAL;
 begin
-  Token := transpiler_lex(ALexer);
+  token := transpiler_lex(lexer);
 
-  if Token.Kind = lexerKindIf then
-    transpile_if_statement(AContext, ALexer)
+  if token.Kind = lexerKindIf then
+    transpile_if_statement(context, lexer)
   end;
-  if Token.Kind = lexerKindWhile then
-    transpile_while_statement(AContext, ALexer)
+  if token.Kind = lexerKindWhile then
+    transpile_while_statement(context, lexer)
   end;
-  if Token.Kind = lexerKindReturn then
-    transpile_return_statement(AContext, ALexer)
+  if token.Kind = lexerKindReturn then
+    transpile_return_statement(context, lexer)
   end;
-  if Token.Kind = lexerKindIdentifier then
+  if token.Kind = lexerKindIdentifier then
     WriteString('  ');
-    WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
-    Token := transpiler_lex(ALexer);
+    written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
+    token := transpiler_lex(lexer);
 
-    while Token.Kind = lexerKindLeftSquare do
+    while token.Kind = lexerKindLeftSquare do
       Write('[');
-      Token := transpiler_lex(ALexer);
-      while Token.Kind <> lexerKindRightSquare do
-        WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
-        Token := transpiler_lex(ALexer)
+      token := transpiler_lex(lexer);
+      while token.Kind <> lexerKindRightSquare do
+        written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
+        token := transpiler_lex(lexer)
       end;
       Write(']');
-      Token := transpiler_lex(ALexer);
+      token := transpiler_lex(lexer);
     end;
-    if Token.Kind = lexerKindHat then
+    if token.Kind = lexerKindHat then
       Write('^');
-      Token := transpiler_lex(ALexer)
+      token := transpiler_lex(lexer)
     end;
-    if Token.Kind = lexerKindDot then
+    if token.Kind = lexerKindDot then
       Write('.');
-      Token := transpiler_lex(ALexer);
-      WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
-      Token := transpiler_lex(ALexer);
+      token := transpiler_lex(lexer);
+      written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
+      token := transpiler_lex(lexer);
     end;
-    if Token.Kind = lexerKindHat then
+    if token.Kind = lexerKindHat then
       Write('^');
-      Token := transpiler_lex(ALexer)
+      token := transpiler_lex(lexer)
     end;
-    while Token.Kind = lexerKindLeftSquare do
+    while token.Kind = lexerKindLeftSquare do
       Write('[');
-      Token := transpiler_lex(ALexer);
-      while Token.Kind <> lexerKindRightSquare do
-        WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
-        Token := transpiler_lex(ALexer)
+      token := transpiler_lex(lexer);
+      while token.Kind <> lexerKindRightSquare do
+        written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
+        token := transpiler_lex(lexer)
       end;
       Write(']');
-      Token := transpiler_lex(ALexer);
+      token := transpiler_lex(lexer);
     end;
 
-    if Token.Kind = lexerKindAssignment then
-      transpile_assignment_statement(AContext, ALexer)
+    if token.Kind = lexerKindAssignment then
+      transpile_assignment_statement(context, lexer)
     end;
-    if Token.Kind = lexerKindLeftParen then
-      transpile_call_statement(AContext, ALexer)
+    if token.Kind = lexerKindLeftParen then
+      transpile_call_statement(context, lexer)
     end
   end
 end;
 
-proc transpile_statements(AContext: PTranspilerContext; ALexer: PLexer);
+proc transpile_statements(context: PTranspilerContext,  lexer: PLexer);
 var
   Token: LexerToken;
 begin
-  Token := lexer_current(ALexer);
+  Token := lexer_current(lexer);
 
   while Token.Kind <> lexerKindEnd do
-    transpile_statement(AContext, ALexer);
-    Token := lexer_current(ALexer);
+    transpile_statement(context, lexer);
+    Token := lexer_current(lexer);
 
     if Token.Kind = lexerKindSemicolon then
       Write(';')
@@ -587,57 +604,57 @@ begin
   end
 end;
 
-proc transpile_statement_part(AContext: PTranspilerContext; ALexer: PLexer);
+proc transpile_statement_part(context: PTranspilerContext,  lexer: PLexer);
 var
   Token: LexerToken;
 begin
-  Token := lexer_current(ALexer);
+  Token := lexer_current(lexer);
   if Token.Kind = lexerKindBegin then
     WriteString('BEGIN');
     WriteLn();
-    transpile_statements(AContext, ALexer)
+    transpile_statements(context, lexer)
   end
 end;
 
-proc transpile_procedure_declaration(AContext: PTranspilerContext; ALexer: PLexer);
+proc transpile_procedure_declaration(context: PTranspilerContext,  lexer: PLexer);
 var
   Token: LexerToken;
-  SeenPart: BOOLEAN;
-  WrittenBytes: CARDINAL;
+  seen_part: BOOLEAN;
+  written_bytes: CARDINAL;
 begin
-  Token := transpile_procedure_heading(AContext, ALexer);
-  SeenPart := transpile_constant_part(AContext, ALexer);
-  SeenPart := transpile_variable_part(AContext, ALexer);
-  transpile_statement_part(AContext, ALexer);
+  Token := transpile_procedure_heading(context, lexer);
+  seen_part := transpile_constant_part(context, lexer);
+  seen_part := transpile_variable_part(context, lexer);
+  transpile_statement_part(context, lexer);
 
   WriteString('END ');
-  WrittenBytes := WriteNBytes(StdOut, ORD(Token.identifierKind[1]), ADR(Token.identifierKind[2]));
+  written_bytes := WriteNBytes(StdOut, ORD(Token.identifierKind[1]), ADR(Token.identifierKind[2]));
 
-  Token := transpiler_lex(ALexer);
+  Token := transpiler_lex(lexer);
   write_semicolon();
-  Token := transpiler_lex(ALexer)
+  Token := transpiler_lex(lexer)
 end;
 
-proc transpile_procedure_part(AContext: PTranspilerContext; ALexer: PLexer);
+proc transpile_procedure_part(context: PTranspilerContext,  lexer: PLexer);
 var
   Token: LexerToken;
 begin
-  Token := lexer_current(ALexer);
+  Token := lexer_current(lexer);
 
   while Token.Kind = lexerKindProc do
-    transpile_procedure_declaration(AContext, ALexer);
-    Token := lexer_current(ALexer);
+    transpile_procedure_declaration(context, lexer);
+    Token := lexer_current(lexer);
     WriteLn()
   end
 end;
 
-proc transpile(ALexer: PLexer);
+proc transpile(lexer: PLexer);
 var
   Token: LexerToken;
-  WrittenBytes: CARDINAL;
+  written_bytes: CARDINAL;
   Context: TranspilerContext;
 begin
-  transpile_module(ADR(Context), ALexer)
+  transpile_module(ADR(Context), lexer)
 end;
 
 end Transpiler.