Fix ICE substracting pointers

1 files changed, 0 insertions, 480 deletions

diff --git a/cl.elna b/cl.elna
index c9754cc..f716676 100644
--- a/cl.elna
+++ b/cl.elna
@@ -601,8 +601,6 @@ var
 	variable_map_global: ^ElnaSymbolTable
 	compiler_strings: [4096]Char
 
-	classification: [256]Word
-	transition_table: [19][23]ElnaLexerTransition
 	word_type: ^ElnaType
 	char_type: ^ElnaType
 	bool_type: ^ElnaType
@@ -6165,356 +6163,6 @@ begin
 	elna_symbol_table_enter(symbol_table_global, "String".ptr, 6, current_info)
 end
 
-proc elna_lexer_classifications1()
-begin
-	classification[1] := ElnaLexerClass.eof;
-	classification[10] := ElnaLexerClass.space;
-	classification[11] := ElnaLexerClass.space;
-	classification[14] := ElnaLexerClass.space;
-	classification[33] := ElnaLexerClass.space;
-	classification[34] := ElnaLexerClass.single
-end
-
-proc elna_lexer_classifications2()
-begin
-	classification[35] := ElnaLexerClass.double_quote;
-	classification[36] := ElnaLexerClass.number_sign;
-	classification[37] := ElnaLexerClass.other;
-	classification[38] := ElnaLexerClass.single;
-	classification[39] := ElnaLexerClass.single;
-	classification[40] := ElnaLexerClass.single_quote;
-	classification[41] := ElnaLexerClass.left_paren;
-	classification[42] := ElnaLexerClass.right_paren;
-	classification[43] := ElnaLexerClass.asterisk;
-	classification[44] := ElnaLexerClass.single;
-	classification[45] := ElnaLexerClass.single;
-	classification[46] := ElnaLexerClass.minus;
-	classification[47] := ElnaLexerClass.dot;
-	classification[48] := ElnaLexerClass.single;
-	classification[49] := ElnaLexerClass.zero;
-	classification[50] := ElnaLexerClass.digit;
-	classification[51] := ElnaLexerClass.digit;
-	classification[52] := ElnaLexerClass.digit;
-	classification[53] := ElnaLexerClass.digit;
-	classification[54] := ElnaLexerClass.digit;
-	classification[55] := ElnaLexerClass.digit;
-	classification[56] := ElnaLexerClass.digit;
-	classification[57] := ElnaLexerClass.digit;
-	classification[58] := ElnaLexerClass.digit;
-	classification[59] := ElnaLexerClass.colon;
-	classification[60] := ElnaLexerClass.single;
-	classification[61] := ElnaLexerClass.less;
-	classification[62] := ElnaLexerClass.equals;
-	classification[63] := ElnaLexerClass.greater;
-	classification[64] := ElnaLexerClass.other
-end
-
-proc elna_lexer_classifications3()
-begin
-	classification[65] := ElnaLexerClass.single;
-	classification[66] := ElnaLexerClass.alpha;
-	classification[67] := ElnaLexerClass.alpha;
-	classification[68] := ElnaLexerClass.alpha;
-	classification[69] := ElnaLexerClass.alpha;
-	classification[70] := ElnaLexerClass.alpha;
-	classification[71] := ElnaLexerClass.alpha;
-	classification[72] := ElnaLexerClass.alpha;
-	classification[73] := ElnaLexerClass.alpha;
-	classification[74] := ElnaLexerClass.alpha;
-	classification[75] := ElnaLexerClass.alpha;
-	classification[76] := ElnaLexerClass.alpha;
-	classification[77] := ElnaLexerClass.alpha;
-	classification[78] := ElnaLexerClass.alpha;
-	classification[79] := ElnaLexerClass.alpha;
-	classification[80] := ElnaLexerClass.alpha;
-	classification[81] := ElnaLexerClass.alpha;
-	classification[82] := ElnaLexerClass.alpha;
-	classification[83] := ElnaLexerClass.alpha;
-	classification[84] := ElnaLexerClass.alpha;
-	classification[85] := ElnaLexerClass.alpha;
-	classification[86] := ElnaLexerClass.alpha;
-	classification[87] := ElnaLexerClass.alpha;
-	classification[88] := ElnaLexerClass.alpha;
-	classification[89] := ElnaLexerClass.alpha;
-	classification[90] := ElnaLexerClass.alpha;
-	classification[91] := ElnaLexerClass.alpha;
-	classification[92] := ElnaLexerClass.single;
-	classification[93] := ElnaLexerClass.backslash;
-	classification[94] := ElnaLexerClass.single;
-	classification[95] := ElnaLexerClass.single;
-	classification[96] := ElnaLexerClass.alpha;
-	classification[97] := ElnaLexerClass.other;
-	classification[98] := ElnaLexerClass.hex
-end
-
-proc elna_lexer_classifications4()
-begin
-	classification[99] := ElnaLexerClass.hex;
-	classification[100] := ElnaLexerClass.hex;
-	classification[101] := ElnaLexerClass.hex;
-	classification[102] := ElnaLexerClass.hex;
-	classification[103] := ElnaLexerClass.hex;
-	classification[104] := ElnaLexerClass.alpha;
-	classification[105] := ElnaLexerClass.alpha;
-	classification[106] := ElnaLexerClass.alpha;
-	classification[107] := ElnaLexerClass.alpha;
-	classification[108] := ElnaLexerClass.alpha;
-	classification[109] := ElnaLexerClass.alpha;
-	classification[110] := ElnaLexerClass.alpha;
-	classification[111] := ElnaLexerClass.alpha;
-	classification[112] := ElnaLexerClass.alpha;
-	classification[113] := ElnaLexerClass.alpha;
-	classification[114] := ElnaLexerClass.alpha;
-	classification[115] := ElnaLexerClass.alpha;
-	classification[116] := ElnaLexerClass.alpha;
-	classification[117] := ElnaLexerClass.alpha;
-	classification[118] := ElnaLexerClass.alpha;
-	classification[119] := ElnaLexerClass.alpha;
-	classification[120] := ElnaLexerClass.alpha;
-	classification[121] := ElnaLexerClass.x;
-	classification[122] := ElnaLexerClass.alpha;
-	classification[123] := ElnaLexerClass.alpha;
-	classification[124] := ElnaLexerClass.other;
-	classification[125] := ElnaLexerClass.single;
-	classification[126] := ElnaLexerClass.other;
-	classification[127] := ElnaLexerClass.single
-end
-
-(**
- * Initializes the array with character classes.
- *)
-proc elna_lexer_classifications()
-var
-	code: Word
-begin
-	code := 1;
-
-	(* Set everything by default to invalid. *)
-	.elna_lexer_classifications_invalid;
-	classification[code] := ElnaLexerClass.invalid;
-	code := code + 1;
-
-	if code < 129 then
-		goto elna_lexer_classifications_invalid
-	end;
-
-	elna_lexer_classifications1();
-	elna_lexer_classifications2();
-	elna_lexer_classifications3();
-	elna_lexer_classifications4();
-
-	(* Set the remaining 129 - 256 bytes to transitionClassOther. *)
-	.elna_lexer_classifications_other;
-	classification[code] := ElnaLexerClass.other;
-	code := code + 1;
-
-	if code < 257 then
-		goto elna_lexer_classifications_other
-	end
-end
-
-proc elna_lexer_get_transition(current_state, character_class: Word): Word
-var
-	column_position: Word
-	target: Word
-begin
-	(* Each state is 8 bytes long (2 words: action and next state).
-	There are 23 character classes, so a transition row 8 * 23 = 184 bytes long. *)
-	column_position := character_class - 1;
-	column_position := column_position * 8;
-
-	target := @transition_table[current_state];
-
-	return target + column_position
-end
-
-(**
- * Parameters:
- * current_state - First index into transitions table.
- * character_class - Second index into transitions table.
- * action - Action to assign.
- * next_state - Next state to assign.
- *)
-proc elna_lexer_set_transition(current_state, character_class, action: Word; next_state: ElnaLexerState)
-var
-	transition: ^ElnaLexerTransition
-begin
-	transition := elna_lexer_get_transition(current_state, character_class);
-
-	transition^.action := action;
-	transition^.next_state := next_state
-end
-
-(* Sets same action and state transition for all character classes in one transition row. *)
-
-(**
- * Parameters:
- * current_state - Current state (Transition state enumeration).
- * default_action - Default action (Callback).
- * next_state - Next state (Transition state enumeration).
- *)
-proc elna_lexer_default_transition(current_state, default_action: Word; next_state: ElnaLexerState)
-begin
-	elna_lexer_set_transition(current_state, ElnaLexerClass.invalid, default_action, next_state);
-	elna_lexer_set_transition(current_state, ElnaLexerClass.digit, default_action, next_state);
-	elna_lexer_set_transition(current_state, ElnaLexerClass.alpha, default_action, next_state);
-	elna_lexer_set_transition(current_state, ElnaLexerClass.space, default_action, next_state);
-	elna_lexer_set_transition(current_state, ElnaLexerClass.colon, default_action, next_state);
-	elna_lexer_set_transition(current_state, ElnaLexerClass.equals, default_action, next_state);
-	elna_lexer_set_transition(current_state, ElnaLexerClass.left_paren, default_action, next_state);
-	elna_lexer_set_transition(current_state, ElnaLexerClass.right_paren, default_action, next_state);
-	elna_lexer_set_transition(current_state, ElnaLexerClass.asterisk, default_action, next_state);
-	elna_lexer_set_transition(current_state, ElnaLexerClass.backslash, default_action, next_state);
-	elna_lexer_set_transition(current_state, ElnaLexerClass.single, default_action, next_state);
-	elna_lexer_set_transition(current_state, ElnaLexerClass.hex, default_action, next_state);
-	elna_lexer_set_transition(current_state, ElnaLexerClass.zero, default_action, next_state);
-	elna_lexer_set_transition(current_state, ElnaLexerClass.x, default_action, next_state);
-	elna_lexer_set_transition(current_state, ElnaLexerClass.eof, default_action, next_state);
-	elna_lexer_set_transition(current_state, ElnaLexerClass.dot, default_action, next_state);
-	elna_lexer_set_transition(current_state, ElnaLexerClass.minus, default_action, next_state);
-	elna_lexer_set_transition(current_state, ElnaLexerClass.single_quote, default_action, next_state);
-	elna_lexer_set_transition(current_state, ElnaLexerClass.double_quote, default_action, next_state);
-	elna_lexer_set_transition(current_state, ElnaLexerClass.greater, default_action, next_state);
-	elna_lexer_set_transition(current_state, ElnaLexerClass.less, default_action, next_state);
-	elna_lexer_set_transition(current_state, ElnaLexerClass.other, default_action, next_state);
-	elna_lexer_set_transition(current_state, ElnaLexerClass.number_sign, default_action, next_state)
-end
-
-(**
- * The transition table describes transitions from one state to another, given
- * a symbol (character class).
- *
- * The table has m rows and n columns, where m is the amount of states and n is
- * the amount of classes. So given the current state and a classified character
- * the table can be used to look up the next state.
- *)
-proc elna_lexer_transitions()
-begin
-	(* Start state. *)
-	elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.invalid, ElnaLexerAction.none, ElnaLexerState.finish);
-	elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.digit, ElnaLexerAction.accumulate, ElnaLexerState.decimal);
-	elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.alpha, ElnaLexerAction.accumulate, ElnaLexerState.identifier);
-	elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.space, ElnaLexerAction.skip, ElnaLexerState.start);
-	elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.colon, ElnaLexerAction.accumulate, ElnaLexerState.colon);
-	elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.equals, ElnaLexerAction.single, ElnaLexerState.finish);
-	elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.left_paren, ElnaLexerAction.accumulate, ElnaLexerState.left_paren);
-	elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.right_paren, ElnaLexerAction.single, ElnaLexerState.finish);
-	elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.asterisk, ElnaLexerAction.single, ElnaLexerState.finish);
-	elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.backslash, ElnaLexerAction.none, ElnaLexerState.finish);
-	elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.single, ElnaLexerAction.single, ElnaLexerState.finish);
-	elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.hex, ElnaLexerAction.accumulate, ElnaLexerState.identifier);
-	elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.zero, ElnaLexerAction.accumulate, ElnaLexerState.leading_zero);
-	elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.x, ElnaLexerAction.accumulate, ElnaLexerState.identifier);
-	elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.eof, ElnaLexerAction.eof, ElnaLexerState.finish);
-	elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.dot, ElnaLexerAction.single, ElnaLexerState.finish);
-	elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.minus, ElnaLexerAction.accumulate, ElnaLexerState.minus);
-	elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.single_quote, ElnaLexerAction.accumulate, ElnaLexerState.character);
-	elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.double_quote, ElnaLexerAction.accumulate, ElnaLexerState.string);
-	elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.greater, ElnaLexerAction.accumulate, ElnaLexerState.greater);
-	elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.less, ElnaLexerAction.accumulate, ElnaLexerState.less);
-	elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.other, ElnaLexerAction.none, ElnaLexerState.finish);
-	elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.number_sign, ElnaLexerAction.accumulate, ElnaLexerState.number_sign);
-
-	(* Colon state. *)
-	elna_lexer_default_transition(ElnaLexerState.colon, ElnaLexerAction.finalize, ElnaLexerState.finish);
-	elna_lexer_set_transition(ElnaLexerState.colon, ElnaLexerClass.equals, ElnaLexerAction.composite, ElnaLexerState.finish);
-
-	(* Identifier state. *)
-	elna_lexer_default_transition(ElnaLexerState.identifier, ElnaLexerAction.key_id, ElnaLexerState.finish);
-	elna_lexer_set_transition(ElnaLexerState.identifier, ElnaLexerClass.digit, ElnaLexerAction.accumulate, ElnaLexerState.identifier);
-	elna_lexer_set_transition(ElnaLexerState.identifier, ElnaLexerClass.alpha, ElnaLexerAction.accumulate, ElnaLexerState.identifier);
-	elna_lexer_set_transition(ElnaLexerState.identifier, ElnaLexerClass.hex, ElnaLexerAction.accumulate, ElnaLexerState.identifier);
-	elna_lexer_set_transition(ElnaLexerState.identifier, ElnaLexerClass.zero, ElnaLexerAction.accumulate, ElnaLexerState.identifier);
-	elna_lexer_set_transition(ElnaLexerState.identifier, ElnaLexerClass.x, ElnaLexerAction.accumulate, ElnaLexerState.identifier);
-
-	(* Decimal state. *)
-	elna_lexer_default_transition(ElnaLexerState.decimal, ElnaLexerAction.integer, ElnaLexerState.finish);
-	elna_lexer_set_transition(ElnaLexerState.decimal, ElnaLexerClass.digit, ElnaLexerAction.accumulate, ElnaLexerState.decimal);
-	elna_lexer_set_transition(ElnaLexerState.decimal, ElnaLexerClass.alpha, ElnaLexerAction.none, ElnaLexerState.finish);
-	elna_lexer_set_transition(ElnaLexerState.decimal, ElnaLexerClass.hex, ElnaLexerAction.none, ElnaLexerState.finish);
-	elna_lexer_set_transition(ElnaLexerState.decimal, ElnaLexerClass.zero, ElnaLexerAction.accumulate, ElnaLexerState.decimal);
-	elna_lexer_set_transition(ElnaLexerState.decimal, ElnaLexerClass.x, ElnaLexerAction.none, ElnaLexerState.finish);
-
-	(* Leading zero. *)
-	elna_lexer_default_transition(ElnaLexerState.leading_zero, ElnaLexerAction.integer, ElnaLexerState.finish);
-	elna_lexer_set_transition(ElnaLexerState.leading_zero, ElnaLexerClass.digit, ElnaLexerAction.none, ElnaLexerState.finish);
-	elna_lexer_set_transition(ElnaLexerState.leading_zero, ElnaLexerClass.alpha, ElnaLexerAction.none, ElnaLexerState.finish);
-	elna_lexer_set_transition(ElnaLexerState.leading_zero, ElnaLexerClass.hex, ElnaLexerAction.none, ElnaLexerState.finish);
-	elna_lexer_set_transition(ElnaLexerState.leading_zero, ElnaLexerClass.zero, ElnaLexerAction.none, ElnaLexerState.finish);
-	elna_lexer_set_transition(ElnaLexerState.leading_zero, ElnaLexerClass.x, ElnaLexerAction.none, ElnaLexerState.dot);
-
-	(* Greater state. *)
-	elna_lexer_default_transition(ElnaLexerState.greater, ElnaLexerAction.finalize, ElnaLexerState.finish);
-	elna_lexer_set_transition(ElnaLexerState.greater, ElnaLexerClass.equals, ElnaLexerAction.composite, ElnaLexerState.finish);
-
-	(* Minus state. *)
-	elna_lexer_default_transition(ElnaLexerState.minus, ElnaLexerAction.finalize, ElnaLexerState.finish);
-	elna_lexer_set_transition(ElnaLexerState.minus, ElnaLexerClass.greater, ElnaLexerAction.composite, ElnaLexerState.finish);
-
-	(* Left paren state. *)
-	elna_lexer_default_transition(ElnaLexerState.left_paren, ElnaLexerAction.finalize, ElnaLexerState.finish);
-	elna_lexer_set_transition(ElnaLexerState.left_paren, ElnaLexerClass.asterisk, ElnaLexerAction.accumulate, ElnaLexerState.comment);
-
-	(* Less state. *)
-	elna_lexer_default_transition(ElnaLexerState.less, ElnaLexerAction.finalize, ElnaLexerState.finish);
-	elna_lexer_set_transition(ElnaLexerState.less, ElnaLexerClass.equals, ElnaLexerAction.composite, ElnaLexerState.finish);
-	elna_lexer_set_transition(ElnaLexerState.less, ElnaLexerClass.greater, ElnaLexerAction.composite, ElnaLexerState.finish);
-
-	(* Hexadecimal after 0x. *)
-	elna_lexer_default_transition(ElnaLexerState.dot, ElnaLexerAction.finalize, ElnaLexerState.finish);
-	elna_lexer_set_transition(ElnaLexerState.dot, ElnaLexerClass.dot, ElnaLexerAction.composite, ElnaLexerState.finish);
-
-	(* Comment. *)
-	elna_lexer_default_transition(ElnaLexerState.comment, ElnaLexerAction.accumulate, ElnaLexerState.comment);
-	elna_lexer_set_transition(ElnaLexerState.comment, ElnaLexerClass.asterisk, ElnaLexerAction.accumulate, ElnaLexerState.closing_comment);
-	elna_lexer_set_transition(ElnaLexerState.comment, ElnaLexerClass.eof, ElnaLexerAction.none, ElnaLexerState.finish);
-
-	(* Closing comment. *)
-	elna_lexer_default_transition(ElnaLexerState.closing_comment, ElnaLexerAction.accumulate, ElnaLexerState.comment);
-	elna_lexer_set_transition(ElnaLexerState.closing_comment, ElnaLexerClass.invalid, ElnaLexerAction.none, ElnaLexerState.finish);
-	elna_lexer_set_transition(ElnaLexerState.closing_comment, ElnaLexerClass.right_paren, ElnaLexerAction.delimited, ElnaLexerState.finish);
-	elna_lexer_set_transition(ElnaLexerState.closing_comment, ElnaLexerClass.asterisk, ElnaLexerAction.accumulate, ElnaLexerState.closing_comment);
-	elna_lexer_set_transition(ElnaLexerState.closing_comment, ElnaLexerClass.eof, ElnaLexerAction.none, ElnaLexerState.finish);
-
-	(* Character. *)
-	elna_lexer_default_transition(ElnaLexerState.character, ElnaLexerAction.accumulate, ElnaLexerState.character);
-	elna_lexer_set_transition(ElnaLexerState.character, ElnaLexerClass.invalid, ElnaLexerAction.none, ElnaLexerState.finish);
-	elna_lexer_set_transition(ElnaLexerState.character, ElnaLexerClass.eof, ElnaLexerAction.none, ElnaLexerState.finish);
-	elna_lexer_set_transition(ElnaLexerState.character, ElnaLexerClass.single_quote, ElnaLexerAction.delimited, ElnaLexerState.finish);
-	elna_lexer_set_transition(ElnaLexerState.character, ElnaLexerClass.backslash, ElnaLexerAction.accumulate, ElnaLexerState.character_escape);
-
-	(* Escape sequence in a character. *)
-	elna_lexer_default_transition(ElnaLexerState.character_escape, ElnaLexerAction.accumulate, ElnaLexerState.character);
-	elna_lexer_set_transition(ElnaLexerState.character_escape, ElnaLexerClass.invalid, ElnaLexerAction.none, ElnaLexerState.finish);
-	elna_lexer_set_transition(ElnaLexerState.character_escape, ElnaLexerClass.eof, ElnaLexerAction.none, ElnaLexerState.finish);
-
-	(* String. *)
-	elna_lexer_default_transition(ElnaLexerState.string, ElnaLexerAction.accumulate, ElnaLexerState.string);
-	elna_lexer_set_transition(ElnaLexerState.string, ElnaLexerClass.invalid, ElnaLexerAction.none, ElnaLexerState.finish);
-	elna_lexer_set_transition(ElnaLexerState.string, ElnaLexerClass.eof, ElnaLexerAction.none, ElnaLexerState.finish);
-	elna_lexer_set_transition(ElnaLexerState.string, ElnaLexerClass.double_quote, ElnaLexerAction.delimited, ElnaLexerState.finish);
-	elna_lexer_set_transition(ElnaLexerState.string, ElnaLexerClass.backslash, ElnaLexerAction.accumulate, ElnaLexerState.string_escape);
-
-	(* Escape sequence in a string. *)
-	elna_lexer_default_transition(ElnaLexerState.string_escape, ElnaLexerAction.accumulate, ElnaLexerState.string);
-	elna_lexer_set_transition(ElnaLexerState.string_escape, ElnaLexerClass.invalid, ElnaLexerAction.none, ElnaLexerState.finish);
-	elna_lexer_set_transition(ElnaLexerState.string_escape, ElnaLexerClass.eof, ElnaLexerAction.none, ElnaLexerState.finish);
-
-	(* Number sign state. *)
-	elna_lexer_default_transition(ElnaLexerState.number_sign, ElnaLexerAction.key_id, ElnaLexerState.finish);
-	elna_lexer_set_transition(ElnaLexerState.number_sign, ElnaLexerClass.alpha, ElnaLexerAction.accumulate, ElnaLexerState.trait);
-	elna_lexer_set_transition(ElnaLexerState.number_sign, ElnaLexerClass.hex, ElnaLexerAction.accumulate, ElnaLexerState.trait);
-	elna_lexer_set_transition(ElnaLexerState.number_sign, ElnaLexerClass.x, ElnaLexerAction.accumulate, ElnaLexerState.trait);
-
-	(* Trait state. *)
-	elna_lexer_default_transition(ElnaLexerState.trait, ElnaLexerAction.key_id, ElnaLexerState.finish);
-	elna_lexer_set_transition(ElnaLexerState.trait, ElnaLexerClass.digit, ElnaLexerAction.accumulate, ElnaLexerState.trait);
-	elna_lexer_set_transition(ElnaLexerState.trait, ElnaLexerClass.alpha, ElnaLexerAction.accumulate, ElnaLexerState.trait);
-	elna_lexer_set_transition(ElnaLexerState.trait, ElnaLexerClass.hex, ElnaLexerAction.accumulate, ElnaLexerState.trait);
-	elna_lexer_set_transition(ElnaLexerState.trait, ElnaLexerClass.zero, ElnaLexerAction.accumulate, ElnaLexerState.trait);
-	elna_lexer_set_transition(ElnaLexerState.trait, ElnaLexerClass.x, ElnaLexerAction.accumulate, ElnaLexerState.trait)
-end
-
 (**
  * One time lexer initialization.
  *)
@@ -6532,87 +6180,6 @@ begin
 	cursor^.position.end_location.column := 1
 end
 
-(* Returns true or false depending whether two strings  are equal. *)
-proc string_compare(lhs_pointer, lhs_length: Word; rhs_pointer: String): Bool
-var
-	result: Bool
-begin
-	if lhs_length = rhs_pointer.length then
-		result := memcmp(lhs_pointer, rhs_pointer.ptr, lhs_length) = 0
-	else
-		result := false
-	end;
-	return result
-end
-
-proc elna_lexer_token_create(kind: ElnaLexerKind; position: ^ElnaPosition): ^ElnaLexerToken
-var
-	result: ^ElnaLexerToken
-begin
-	result := malloc(#size(ElnaLexerToken));
-	result^.kind := kind;
-	result^.position := position;
-
-	return result
-end
-
-proc elna_lexer_classify_keyword(position_start: ^Char; position_end: Word; position: ^ElnaPosition): ^ElnaLexerToken
-var
-	result: ^ElnaLexerToken
-	result_length: Word
-begin
-	result_length := position_end - position_start;
-
-	result := elna_lexer_token_create(ElnaLexerKind.identifier, position);
-	result^.start.ptr := position_start;
-	result^.start.length := result_length;
-
-	if position_start^ = '#' then
-		result^.kind := ElnaLexerKind.trait
-	elsif string_compare(position_start, result_length, "const") then
-		result^.kind := ElnaLexerKind._const
-	elsif string_compare(position_start, result_length, "var") then
-		result^.kind := ElnaLexerKind._var
-	elsif string_compare(position_start, result_length, "proc") then
-		result^.kind := ElnaLexerKind._proc
-	elsif string_compare(position_start, result_length, "type") then
-		result^.kind := ElnaLexerKind._type
-	elsif string_compare(position_start, result_length, "begin") then
-		result^.kind := ElnaLexerKind._begin
-	elsif string_compare(position_start, result_length, "end") then
-		result^.kind := ElnaLexerKind._end
-	elsif string_compare(position_start, result_length, "return") then
-		result^.kind := ElnaLexerKind._return
-	elsif string_compare(position_start, result_length, "goto") then
-		result^.kind := ElnaLexerKind._goto
-	elsif string_compare(position_start, result_length, "if") then
-		result^.kind := ElnaLexerKind._if
-	elsif string_compare(position_start, result_length, "extern") then
-		result^.kind := ElnaLexerKind._extern
-	elsif string_compare(position_start, result_length, "then") then
-		result^.kind := ElnaLexerKind._then
-	elsif string_compare(position_start, result_length, "else") then
-		result^.kind := ElnaLexerKind._else
-	elsif string_compare(position_start, result_length, "elsif") then
-		result^.kind := ElnaLexerKind._elsif
-	elsif string_compare(position_start, result_length, "record") then
-		result^.kind := ElnaLexerKind._record
-	elsif string_compare(position_start, result_length, "or") then
-		result^.kind := ElnaLexerKind._or
-	elsif string_compare(position_start, result_length, "xor") then
-		result^.kind := ElnaLexerKind._xor
-	elsif string_compare(position_start, result_length, "nil") then
-		result^.kind := ElnaLexerKind.null
-	elsif string_compare(position_start, result_length, "true") then
-		result^.kind := ElnaLexerKind.boolean
-	elsif string_compare(position_start, result_length, "false") then
-		result^.kind := ElnaLexerKind.boolean
-	elsif string_compare(position_start, result_length, "cast") then
-		result^.kind := ElnaLexerKind._cast
-	end;
-	return result
-end
-
 proc elna_lexer_classify_finalize(start_position: ^Char; position: ^ElnaPosition): ^ElnaLexerToken
 var
 	character: Char
@@ -6705,37 +6272,6 @@ begin
 	return result
 end
 
-proc elna_lexer_classify_delimited(start_position: ^Char; end_position: Word; position: ^ElnaPosition): ^ElnaLexerToken
-var
-	delimiter: Char
-	result: ^ElnaLexerToken
-begin
-	delimiter := start_position^;
-
-	if delimiter = '(' then
-		result := elna_lexer_token_create(ElnaLexerKind.comment, position)
-	elsif delimiter = '\'' then
-		result := elna_lexer_token_create(ElnaLexerKind.character, position)
-	elsif delimiter = '"' then
-		result := elna_lexer_token_create(ElnaLexerKind.string, position)
-	end;
-	result^.start.ptr := start_position;
-	result^.start.length := end_position - start_position;
-
-	return result
-end
-
-proc elna_lexer_classify_integer(start_position, end_position: Word; position: ^ElnaPosition): ^ElnaLexerToken
-var
-	result: ^ElnaLexerToken
-begin
-	result := elna_lexer_token_create(ElnaLexerKind.integer, position);
-	result^.start.ptr := start_position;
-	result^.start.length := end_position - start_position;
-
-	return result
-end
-
 proc elna_lexer_execute_action(cursor: ^ElnaLexerCursor; action_to_perform: Word): ^ElnaLexerToken
 var
 	token: ^ElnaLexerToken
@@ -6786,22 +6322,6 @@ begin
 	return elna_lexer_execute_action(cursor, next_transition^.action, kind)
 end
 
-proc elna_lexer_classify_space(start_position: ^Char; location: ^ElnaLocation)
-begin
-	if start_position^ = '\n' then
-		location^.line := location^.line + 1;
-		location^.column := 1
-	else
-		location^.column := location^.column + 1
-	end
-end
-
-proc elna_lexer_advance(cursor: ^ElnaLexerCursor)
-begin
-	cursor^.finish := cursor^.finish + 1;
-	cursor^.position.end_location.column := cursor^.position.end_location.column + 1
-end
-
 (**
  * Reads the next token and writes its type into the address in the kind parameter.
  * Resets the lexer state for reading the next token.