From af9ad5b712003b41a981beafe519275b14d6c159 Mon Sep 17 00:00:00 2001
From: Eugen Wissner <belka@caraus.de>
Date: Sat, 4 Oct 2025 12:40:07 +0200
Subject: [PATCH] Implement enumeration

---
 boot/stage14.elna |   92 ++-
 boot/stage15.elna | 1698 +++++++++++++++++++++------------------------
 2 files changed, 868 insertions(+), 922 deletions(-)

diff --git a/boot/stage14.elna b/boot/stage14.elna
index 6e5e186..ecb9347 100644
--- a/boot/stage14.elna
+++ b/boot/stage14.elna
@@ -10,6 +10,7 @@
 (* - Space independent parsing. *)
 (* - Label names in goto statements aren't required to begin with a dot. *)
 (* - Dereferencing pointers pointing to word long data. *)
+(* - Enumeration type. *)
 
 const
 	symbol_builtin_name_int := "Int";
@@ -416,9 +417,21 @@ begin
 end;
 
 proc _compile_variable_expression();
+var
+	name: Word;
+	lookup_result: Word;
+	name_token: Word;
 begin
-	_compile_designator();
-	_write_z("\tlw t0, (t0)\n\0")
+	name := _lexer_global_get_start();
+	name_token := _lexer_global_get_end() + -name;
+	lookup_result := _symbol_table_lookup(@symbol_table_global, name, name_token);
+
+	if lookup_result <> 0 then
+		_compile_enumeration_value(lookup_result)
+	else
+		_compile_designator();
+		_write_z("\tlw t0, (t0)\n\0")
+	end
 end;
 
 (**
@@ -738,6 +751,50 @@ begin
 	_write_c('\n')
 end;
 
+proc _compile_enumeration_value(symbol: Word);
+var
+	enumeration_type: Word;
+	members: Word;
+	members_length: Word;
+	token_type: Word;
+	value_name: Word;
+	name_length: Word;
+	member_name: Word;
+	member_length: Word;
+	counter: Word;
+begin
+	enumeration_type := _type_info_get_type(symbol);
+	members := _enumeration_type_get_members(enumeration_type);
+	members_length := _enumeration_type_get_length(enumeration_type);
+
+	(* Skip enumeration type name and dot. Read the enumeration value. *)
+	_lexer_skip_token();
+	_lexer_read_token(@token_type);
+	_lexer_skip_token();
+	_lexer_read_token(@token_type);
+
+	value_name := _lexer_global_get_start();
+	name_length := _lexer_global_get_end() + -value_name;
+	_lexer_skip_token();
+	counter := 1;
+
+	.compile_enumeration_value_members;
+	if members_length > 0 then
+		member_name := _load_word(members);
+		member_length := _load_word(members + 4);
+
+		if _lexer_compare_keyword(value_name, name_length, member_name, member_length) = 0 then
+			members_length := members_length + -1;
+			members := members + 8;
+			counter := counter + 1;
+			goto .compile_enumeration_value_members
+		end;
+		_write_z("\tli t0, \0");
+		_write_i(counter);
+		_write_c('\n')
+	end
+end;
+
 proc _compile_designator();
 var
 	name_token: Word;
@@ -1040,7 +1097,7 @@ begin
 	_enumeration_type_set_members(result, memory_start);
 	_enumeration_type_set_length(result, member_count);
 
-	return result
+	return _type_info_create(result)
 end;
 
 proc _read_type_expression();
@@ -1104,6 +1161,24 @@ begin
 	return _load_word(this)
 end;
 
+proc _type_info_create(type_representation: Word);
+var
+	result: Word;
+	current_word: Word;
+begin
+	result := memory_free_pointer;
+	current_word := result;
+	(* 1 is INFO_TYPE *)
+	_store_word(1, current_word);
+
+	current_word := current_word + 4;
+	_store_word(type_representation, current_word);
+
+	memory_free_pointer := current_word + 4;
+
+	return result
+end;
+
 (**
  * Parameters:
  * temporary_index - Parameter index.
@@ -1427,11 +1502,20 @@ end;
 proc _compile_type_declaration();
 var
 	token_kind: Word;
+	type_name: Word;
+	name_length: Word;
+	type_info: Word;
 begin
+	type_name := _lexer_global_get_start();
+	name_length := _lexer_global_get_end() + -type_name;
+
 	_lexer_skip_token();
 	_lexer_read_token(@token_kind);
 	_lexer_skip_token();
-	_read_type_expression();
+	type_info := _read_type_expression();
+
+	_symbol_table_enter(@symbol_table_global, type_name, name_length, type_info);
+
 	_lexer_read_token(@token_kind);
 	_lexer_skip_token()
 end;
diff --git a/boot/stage15.elna b/boot/stage15.elna
index 9c8d3a3..6200fbd 100644
--- a/boot/stage15.elna
+++ b/boot/stage15.elna
@@ -4,12 +4,135 @@
  * obtain one at https://mozilla.org/MPL/2.0/.
  *)
 
-(* Stage 14 compiler. *)
+(* Stage 15 compiler. *)
 
-(* - Binary minus. *)
-(* - Space independent parsing. *)
-(* - Label names in goto statements aren't required to begin with a dot. *)
-(* - Dereferencing pointers pointing to word long data. *)
+type
+	LexerAction = (none, accumulate, skip, single, eof, finalize, composite, key_id, integer, delimited);
+
+	(**
+	 * Classification table assigns each possible character to a group (class). All
+	 * characters of the same group a handled equivalently.
+	 *
+	 * Transition = record
+	 *   action: TransitionAction;
+	 *   next_state: TransitionState
+	 * end;
+	 *)
+	LexerClass = (
+		invalid,
+		digit,
+		alpha,
+		space,
+		colon,
+		equals,
+		left_paren,
+		right_paren,
+		asterisk,
+		backslash,
+		single,
+		hex,
+		zero,
+		x,
+		eof,
+		dot,
+		minus,
+		single_quote,
+		double_quote,
+		greater,
+		less,
+		other
+	);
+	LexerState = (
+		start,
+		colon,
+		identifier,
+		decimal,
+		leading_zero,
+		greater,
+		minus,
+		left_paren,
+		less,
+		dot,
+		comment,
+		closing_comment,
+		character,
+		character_escape,
+		string,
+		string_escape,
+		finish
+	);
+	LexerTokenKind = (
+		identifier,
+		_const,
+		_var,
+		_proc,
+		_type,
+		_begin,
+		_end,
+		_if,
+		_then,
+		_else,
+		_elsif,
+		_while,
+		_do,
+		_extern,
+		_record,
+		_union,
+		_true,
+		_false,
+		null,
+		and,
+		_or,
+		_xor,
+		pipe,
+		not,
+		_return,
+		_module,
+		_program,
+		_import,
+		_cast,
+		_defer,
+		_case,
+		_of,
+		trait,
+		left_paren,
+		right_paren,
+		left_square,
+		right_square,
+		shift_left,
+		shift_right,
+		greater_equal,
+		less_equal,
+		greater_than,
+		less_than,
+		not_equal,
+		equals,
+		semicolon,
+		dot,
+		comma,
+		plus,
+		arrow,
+		minus,
+		multiplication,
+		division,
+		remainder,
+		assignment,
+		colon,
+		hat,
+		at,
+		comment,
+		string,
+		character,
+		integer,
+		word,
+		_goto,
+		eof
+	);
+	NodeKind := (
+		integer_literal,
+		string_literal,
+		character_literal
+	);
 
 const
 	symbol_builtin_name_int := "Int";
@@ -81,7 +204,7 @@ begin
 
 	if _load_byte(string) <> '"' then
 		counter := counter + 1;
-		goto .string_length_loop
+		goto string_length_loop
 	end;
 
 	return counter
@@ -114,7 +237,7 @@ begin
 		if current_byte <> '\\' then
 			compiler_strings_length := compiler_strings_length + 1
 		end;
-		goto .add_string_loop
+		goto add_string_loop
 	end;
 
 	return result
@@ -175,17 +298,17 @@ begin
 	_store_byte(current_character + '0', local_buffer);
 
 	number := number / 10;
-	local_buffer := local_buffer + -1;
+	local_buffer := local_buffer - 1;
 
 	if number <> 0 then
-		goto .print_i_digit10
+		goto print_i_digit10
 	end;
 	if is_negative = 1 then
 		_store_byte('-', local_buffer);
-		local_buffer := local_buffer + -1
+		local_buffer := local_buffer - 1
 	end;
 	result := @result + 11;
-	result := result + -local_buffer;
+	result := result - local_buffer;
 	_memcpy(output_buffer, local_buffer + 1, result);
 
 	return result
@@ -341,14 +464,14 @@ begin
 	if count <> 0 then
 		lhs_byte := _load_byte(lhs);
 		rhs_byte := _load_byte(rhs);
-		result := lhs_byte + -rhs_byte;
+		result := lhs_byte - rhs_byte;
 
 		lhs := lhs + 1;
 		rhs := rhs + 1;
-		count := count + -1;
+		count := count - 1;
 
 		if result = 0 then
-			goto .memcmp_loop
+			goto memcmp_loop
 		end
 	end;
 
@@ -376,14 +499,65 @@ begin
 
 		destination := destination + 1;
 		source := source + 1;
-		count := count + -1;
-		goto .memcpy_loop
+		count := count - 1;
+		goto memcpy_loop
 	end;
 
 	return destination
 end;
 
-proc _compile_integer_literal();
+proc _node_get_kind(this: Word);
+	return this^
+end;
+
+proc _node_set_kind(this: Word, kind: Word);
+begin
+	this^ := kind
+end;
+
+proc _integer_literal_node_size();
+	return 12
+end;
+
+proc _integer_literal_node_get_value(this: Word);
+	return _load_word(this + 4)
+end;
+
+proc _integer_literal_node_set_value(this: Word, value: Word);
+begin
+	_store_word(value, this + 4)
+end;
+
+proc _integer_literal_node_get_length(this: Word);
+	return _load_word(this + 8)
+end;
+
+proc _integer_literal_node_set_length(this: Word, value: Word);
+begin
+	_store_word(value, this + 8)
+end;
+
+proc _parse_integer_literal();
+var
+	integer_token: Word;
+	integer_length: Word;
+	result: Word;
+begin
+	result := memory_free_pointer;
+	memory_free_pointer := memory_free_pointer + 12;
+
+	integer_token := _lexer_global_get_start();
+	integer_length := _lexer_global_get_end() - integer_token;
+	_lexer_skip_token();
+
+	_node_set_kind(result, NodeKind.integer_literal);
+	_integer_literal_node_set_value(result, integer_token);
+	_integer_literal_node_set_length(result, integer_length);
+
+	return result
+end;
+
+proc _compile_integer_literal(integer_literal_node: Word);
 var
 	integer_token: Word;
 	integer_length: Word;
@@ -391,34 +565,80 @@ var
 begin
 	_write_z("\tli t0, \0");
 
-	integer_token := _lexer_global_get_start();
-	integer_length := _lexer_global_get_end() + -integer_token;
+	integer_token := _integer_literal_node_get_value(integer_literal_node);
+	integer_length := _integer_literal_node_get_length(integer_literal_node);
 
 	_write_s(integer_token, integer_length);
-	_lexer_skip_token();
-
 	_write_c('\n')
 end;
 
-proc _compile_character_literal();
+proc _character_literal_node_get_value(this: Word);
+	return _load_word(this + 4)
+end;
+
+proc _character_literal_node_set_value(this: Word, value: Word);
+begin
+	_store_word(value, this + 4)
+end;
+
+proc _character_literal_node_get_length(this: Word);
+	return _load_word(this + 8)
+end;
+
+proc _character_literal_node_set_length(this: Word, value: Word);
+begin
+	_store_word(value, this + 8)
+end;
+
+proc _parse_character_literal();
+var
+	character: Word;
+	character_length: Word;
+	result: Word;
+begin
+	result := memory_free_pointer;
+	memory_free_pointer := memory_free_pointer + 12;
+
+	character := _lexer_global_get_start();
+	character_length := _lexer_global_get_end() - character;
+	_lexer_skip_token();
+
+	_node_set_kind(result, NodeKind.character_literal);
+	_integer_literal_node_set_value(result, character);
+	_integer_literal_node_set_length(result, character_length);
+
+	return result
+end;
+
+proc _compile_character_literal(character_literal_node: Word);
 var
 	character: Word;
-	token_kind: Word;
 	character_length: Word;
 begin
-	character := _lexer_global_get_start();
-	character_length := _lexer_global_get_end() + -character;
+	character := _character_literal_node_get_value(character_literal_node);
+	character_length := _character_literal_node_get_length(character_literal_node);;
 
 	_write_z("\tli t0, \0");
 	_write_s(character, character_length);
 	_write_c('\n');
-	_lexer_skip_token()
 end;
 
 proc _compile_variable_expression();
+var
+	name: Word;
+	lookup_result: Word;
+	name_token: Word;
 begin
-	_compile_designator();
-	_write_z("\tlw t0, (t0)\n\0")
+	name := _lexer_global_get_start();
+	name_token := _lexer_global_get_end() - name;
+	lookup_result := _symbol_table_lookup(@symbol_table_global, name, name_token);
+
+	if lookup_result <> 0 then
+		_compile_enumeration_value(lookup_result)
+	else
+		_compile_designator();
+		_write_z("\tlw t0, (t0)\n\0")
+	end
 end;
 
 (**
@@ -451,19 +671,57 @@ begin
 	_write_z("\tnot t0, t0\n\0")
 end; 
 
-proc _compile_string_literal();
+proc _string_literal_node_size();
+	return 12
+end;
+
+proc _string_literal_node_get_value(this: Word);
+	return _load_word(this + 4)
+end;
+
+proc _string_literal_node_set_value(this: Word, value: Word);
+begin
+	_store_word(value, this + 4)
+end;
+
+proc _string_literal_node_get_length(this: Word);
+	return _load_word(this + 8)
+end;
+
+proc _string_literal_node_set_length(this: Word, value: Word);
+begin
+	_store_word(value, this + 8)
+end;
+
+proc _parse_string_literal();
+var
+	length: Word;
+	token_start: Word;
+	result: Word;
+begin
+	result := memory_free_pointer;
+	memory_free_pointer := memory_free_pointer + _string_literal_node_size();
+
+	token_start := _lexer_global_get_start();
+	length := _string_length(token_start);
+	_lexer_skip_token();
+
+	_string_literal_node_set_value(result, token_start);
+	_string_literal_node_set_length(result, length);
+
+	return result
+end;
+
+proc _compile_string_literal(string_literal_node: Word);
 var
-	token_kind: Word;
 	token_start: Word;
 	length: Word;
 	offset: Word;
 begin
-	_lexer_read_token(@token_kind);
-	token_start := _lexer_global_get_start();
-	length := _string_length(token_start);
+	token_start := _string_literal_node_get_value(string_literal_node);
+	length := _string_literal_node_get_length(string_literal_node);
 	offset := _add_string(token_start);
 
-	_lexer_skip_token();
 	_write_z("\tla t0, strings\n\0");
 
 	_write_z("\tli t1, \0");
@@ -477,22 +735,26 @@ proc _compile_term();
 var
 	current_character: Word;
 	token_kind: Word;
+	parser_node: Word;
 begin
 	_lexer_read_token(@token_kind);
 
-	if token_kind = _lexer_token_kind_character() then
-		_compile_character_literal()
-	elsif token_kind = _lexer_token_kind_string() then
-		_compile_string_literal()
-	elsif token_kind = _lexer_token_kind_integer() then
-		_compile_integer_literal()
-	elsif token_kind = _lexer_token_kind_at() then
+	if token_kind = LexerTokenKind.character then
+		parser_node := _parse_character_literal();
+		_compile_character_literal(parser_node)
+	elsif token_kind = LexerTokenKind.string then
+		parser_node := _parse_string_literal();
+		_compile_string_literal(parser_node)
+	elsif token_kind = LexerTokenKind.integer then
+		parser_node := _parse_integer_literal();
+		_compile_integer_literal(parser_node)
+	elsif token_kind = LexerTokenKind.at then
 		_compile_address_expression()
-	elsif token_kind = _lexer_token_kind_minus() then
+	elsif token_kind = LexerTokenKind.minus then
 		_compile_negate_expression()
-	elsif token_kind = _lexer_token_kind_not() then
+	elsif token_kind = LexerTokenKind.not then
 		_compile_not_expression()
-	elsif token_kind = _lexer_token_kind_identifier() then
+	elsif token_kind = LexerTokenKind.identifier then
 		current_character := _lexer_global_get_start();
 		current_character := _load_byte(current_character);
 
@@ -524,85 +786,85 @@ begin
 
 	_lexer_read_token(@token_kind);
 
-	if token_kind = _lexer_token_kind_plus() then
+	if token_kind = LexerTokenKind.plus then
 		_lexer_skip_token();
 		_compile_binary_rhs();
 
 		(* Execute the operation. *)
 		_write_z("\tadd t0, t0, t1\n\0")
-	elsif token_kind = _lexer_token_kind_minus() then
+	elsif token_kind = LexerTokenKind.minus then
 		_lexer_skip_token();
 		_compile_binary_rhs();
 
 		(* Execute the operation. *)
 		_write_z("\tsub t0, t1, t0\n\0");
-	elsif token_kind = _lexer_token_kind_multiplication() then
+	elsif token_kind = LexerTokenKind.multiplication then
 		_lexer_skip_token();
 		_compile_binary_rhs();
 
 		(* Execute the operation. *)
 		_write_z("\tmul t0, t0, t1\n\0")
-	elsif token_kind = _lexer_token_kind_and() then
+	elsif token_kind = LexerTokenKind.and then
 		_lexer_skip_token();
 		_compile_binary_rhs();
 
 		(* Execute the operation. *)
 		_write_z("\tand t0, t0, t1\n\0")
-	elsif token_kind = _lexer_token_kind_or() then
+	elsif token_kind = LexerTokenKind._or then
 		_lexer_skip_token();
 		_compile_binary_rhs();
 
 		(* Execute the operation. *)
 		_write_z("\tor t0, t0, t1\n\0")
-	elsif token_kind = _lexer_token_kind_xor() then
+	elsif token_kind = LexerTokenKind._xor then
 		_lexer_skip_token();
 		_compile_binary_rhs();
 
 		(* Execute the operation. *)
 		_write_z("\txor t0, t0, t1\n\0")
-	elsif token_kind = _lexer_token_kind_equals() then
+	elsif token_kind = LexerTokenKind.equals then
 		_lexer_skip_token();
 		_compile_binary_rhs();
 
 		(* Execute the operation. *)
 		_write_z("\txor t0, t0, t1\n\tseqz t0, t0\n\0")
-	elsif token_kind = _lexer_token_kind_remainder() then
+	elsif token_kind = LexerTokenKind.remainder then
 		_lexer_skip_token();
 		_compile_binary_rhs();
 
 		(* Execute the operation. *)
 		_write_z("\trem t0, t1, t0\n\0")
-	elsif token_kind = _lexer_token_kind_division() then
+	elsif token_kind = LexerTokenKind.division then
 		_lexer_skip_token();
 		_compile_binary_rhs();
 
 		(* Execute the operation. *)
 		_write_z("\tdiv t0, t1, t0\n\0")
-	elsif token_kind = _lexer_token_kind_less_than() then
+	elsif token_kind = LexerTokenKind.less_than then
 		_lexer_skip_token();
 		_compile_binary_rhs();
 
 		(* Execute the operation. *)
 		_write_z("\tslt t0, t1, t0\n\0")
-	elsif token_kind = _lexer_token_kind_greater_than() then
+	elsif token_kind = LexerTokenKind.greater_than then
 		_lexer_skip_token();
 		_compile_binary_rhs();
 
 		(* Execute the operation. *)
 		_write_z("\tslt t0, t0, t1\n\0")
-	elsif token_kind = _lexer_token_kind_less_equal() then
+	elsif token_kind = LexerTokenKind.less_equal then
 		_lexer_skip_token();
 		_compile_binary_rhs();
 
 		(* Execute the operation. *)
 		_write_z("\tslt t0, t0, t1\n\txori t0, t0, 1\n\0")
-	elsif token_kind = _lexer_token_kind_not_equal() then
+	elsif token_kind = LexerTokenKind.not_equal then
 		_lexer_skip_token();
 		_compile_binary_rhs();
 
 		(* Execute the operation. *)
 		_write_z("\txor t0, t0, t1\n\tsnez t0, t0\n\0")
-	elsif token_kind = _lexer_token_kind_greater_equal() then
+	elsif token_kind = LexerTokenKind.greater_equal then
 		_lexer_skip_token();
 		_compile_binary_rhs();
 
@@ -623,7 +885,7 @@ var
 begin
 	_lexer_read_token(@token_kind);
 	name := _lexer_global_get_start();
-	name_length := _lexer_global_get_end() + -name;
+	name_length := _lexer_global_get_end() - name;
 	argument_count := 0;
 
 	(* Skip the identifier and left paren. *)
@@ -632,8 +894,8 @@ begin
 	_lexer_skip_token();
 
 	_lexer_read_token(@token_kind);
-	if token_kind = _lexer_token_kind_right_paren() then
-		goto .compile_call_finalize
+	if token_kind = LexerTokenKind.right_paren then
+		goto compile_call_finalize
 	end;
 	.compile_call_loop;
 	_compile_expression();
@@ -643,7 +905,7 @@ begin
 
 	(* Calculate the stack offset: 116 - (4 * argument_counter) *)
 	stack_offset := argument_count * 4;
-	_write_i(116 + -stack_offset);
+	_write_i(116 - stack_offset);
 
 	_write_z("(sp)\n\0");
 
@@ -652,17 +914,17 @@ begin
 
 	_lexer_read_token(@token_kind);
 
-	if token_kind <> _lexer_token_kind_comma() then
-		goto .compile_call_finalize
+	if token_kind <> LexerTokenKind.comma then
+		goto compile_call_finalize
 	end;
 	_lexer_skip_token();
-	goto .compile_call_loop;
+	goto compile_call_loop;
 
 	.compile_call_finalize;
 	(* Load the argument from the stack. *)
 	if argument_count <> 0 then
 		(* Decrement the argument counter. *)
-		argument_count := argument_count + -1;
+		argument_count := argument_count - 1;
 
 		_write_z("\tlw a\0");
 		_write_i(argument_count);
@@ -671,11 +933,11 @@ begin
 
 		(* Calculate the stack offset: 116 - (4 * argument_counter) *)
 		stack_offset := argument_count * 4;
-		_write_i(116 + -stack_offset);
+		_write_i(116 - stack_offset);
 
 		_write_z("(sp)\n\0");
 
-		goto .compile_call_finalize
+		goto compile_call_finalize
 	end;
 
 	.compile_call_end;
@@ -697,12 +959,12 @@ begin
 	_lexer_skip_token();
 	_lexer_read_token(@token_kind);
 
-	if token_kind = _lexer_token_kind_dot() then
+	if token_kind = LexerTokenKind.dot then
 		_lexer_skip_token();
 		_lexer_read_token(@token_kind)
 	end;
 	next_token := _lexer_global_get_start();
-	next_length := _lexer_global_get_end() + -next_token;
+	next_length := _lexer_global_get_end() - next_token;
 
 	_write_z("\tj .\0");
 
@@ -731,13 +993,57 @@ begin
 
 	_lexer_read_token(@token_kind);
 	name := _lexer_global_get_start();
-	token_length := _lexer_global_get_end() + -name;
+	token_length := _lexer_global_get_end() - name;
 	_write_s(name, token_length);
 	_lexer_skip_token();
 
 	_write_c('\n')
 end;
 
+proc _compile_enumeration_value(symbol: Word);
+var
+	enumeration_type: Word;
+	members: Word;
+	members_length: Word;
+	token_type: Word;
+	value_name: Word;
+	name_length: Word;
+	member_name: Word;
+	member_length: Word;
+	counter: Word;
+begin
+	enumeration_type := _type_info_get_type(symbol);
+	members := _enumeration_type_get_members(enumeration_type);
+	members_length := _enumeration_type_get_length(enumeration_type);
+
+	(* Skip enumeration type name and dot. Read the enumeration value. *)
+	_lexer_skip_token();
+	_lexer_read_token(@token_type);
+	_lexer_skip_token();
+	_lexer_read_token(@token_type);
+
+	value_name := _lexer_global_get_start();
+	name_length := _lexer_global_get_end() - value_name;
+	_lexer_skip_token();
+	counter := 1;
+
+	.compile_enumeration_value_members;
+	if members_length > 0 then
+		member_name := members^;
+		member_length := _load_word(members + 4);
+
+		if _lexer_compare_keyword(value_name, name_length, member_name, member_length) = 0 then
+			members_length := members_length - 1;
+			members := members + 8;
+			counter := counter + 1;
+			goto compile_enumeration_value_members
+		end;
+		_write_z("\tli t0, \0");
+		_write_i(counter);
+		_write_c('\n')
+	end
+end;
+
 proc _compile_designator();
 var
 	name_token: Word;
@@ -747,7 +1053,7 @@ var
 begin
 	_lexer_read_token(@token_kind);
 	name := _lexer_global_get_start();
-	name_token := _lexer_global_get_end() + -name;
+	name_token := _lexer_global_get_end() - name;
 	lookup_result := _symbol_table_lookup(@symbol_table_local, name, name_token);
 
 	if lookup_result <> 0 then
@@ -756,7 +1062,7 @@ begin
 		_compile_global_designator()
 	end;
 	_lexer_read_token(@token_kind);
-	if token_kind = _lexer_token_kind_hat() then
+	if token_kind = LexerTokenKind.hat then
 		_lexer_skip_token();
 		_write_z("\tlw t0, (t0)\n\0")
 	end
@@ -851,14 +1157,14 @@ begin
 	.compile_if_loop;
 
 	_lexer_read_token(@token_kind);
-	if token_kind = _lexer_token_kind_else() then
+	if token_kind = LexerTokenKind._else then
 		_lexer_skip_token();
 		_compile_statement_list()
-	elsif token_kind = _lexer_token_kind_elsif() then
+	elsif token_kind = LexerTokenKind._elsif then
 		_lexer_skip_token();
 		_compile_condition(after_end_label);
 
-		goto .compile_if_loop
+		goto compile_if_loop
 	end;
 	_lexer_skip_token();
 
@@ -876,7 +1182,7 @@ begin
 	_lexer_skip_token();
 	_lexer_read_token(@token_kind);
 	name := _lexer_global_get_start();
-	label_token := _lexer_global_get_end() + -name;
+	label_token := _lexer_global_get_end() - name;
 	_write_c('.');
 	_write_s(name, label_token);
 	_write_z(":\n\0");
@@ -890,15 +1196,15 @@ var
 begin
 	_lexer_read_token(@token_kind);
 
-	if token_kind = _lexer_token_kind_goto() then
+	if token_kind = LexerTokenKind._goto then
 		_compile_goto()
-	elsif token_kind = _lexer_token_kind_if() then
+	elsif token_kind = LexerTokenKind._if then
 		_compile_if()
-	elsif token_kind = _lexer_token_kind_return() then
+	elsif token_kind = LexerTokenKind._return then
 		_compile_return_statement()
-	elsif token_kind = _lexer_token_kind_dot() then
+	elsif token_kind = LexerTokenKind.dot then
 		_compile_label_declaration()
-	elsif token_kind = _lexer_token_kind_identifier() then
+	elsif token_kind = LexerTokenKind.identifier then
 		current_byte := _lexer_global_get_start();
 		current_byte := _load_byte(current_byte);
 
@@ -920,7 +1226,7 @@ begin
 	_compile_statement();
 	_lexer_read_token(@token_kind);
 
-	if token_kind = _lexer_token_kind_semicolon() then
+	if token_kind = LexerTokenKind.semicolon then
 		_lexer_skip_token();
 		_compile_statement_list()
 	end;
@@ -941,7 +1247,7 @@ begin
 end;
 
 proc _type_get_kind(this: Word);
-	return _load_word(this)
+	return this^
 end;
 
 proc _type_set_kind(this: Word, value: Word);
@@ -1002,14 +1308,14 @@ begin
 	member_count := 0;
 
 	_lexer_read_token(@token_kind);
-	if token_kind = _lexer_token_kind_right_paren() then
-		goto .read_type_enumeration_end
+	if token_kind = LexerTokenKind.right_paren then
+		goto read_type_enumeration_end
 	end;
 	.read_type_enumeration_loop;
 	member_count := member_count + 1;
 
 	enumeration_name := _lexer_global_get_start();
-	name_length := _lexer_global_get_end() + -enumeration_name;
+	name_length := _lexer_global_get_end() - enumeration_name;
 
 	_store_word(enumeration_name, memory_free_pointer);
 	memory_free_pointer := memory_free_pointer + 4;
@@ -1021,10 +1327,10 @@ begin
 	_lexer_skip_token();
 
 	_lexer_read_token(@token_kind);
-	if token_kind = _lexer_token_kind_comma() then
+	if token_kind = LexerTokenKind.comma then
 		_lexer_skip_token();
 		_lexer_read_token(@token_kind);
-		goto .read_type_enumeration_loop
+		goto read_type_enumeration_loop
 	end;
 
 	.read_type_enumeration_end;
@@ -1040,7 +1346,7 @@ begin
 	_enumeration_type_set_members(result, memory_start);
 	_enumeration_type_set_length(result, member_count);
 
-	return result
+	return _type_info_create(result)
 end;
 
 proc _read_type_expression();
@@ -1053,20 +1359,15 @@ begin
 	result := 0;
 	_lexer_read_token(@token_kind);
 
-	if token_kind = _lexer_token_kind_identifier() then
+	if token_kind = LexerTokenKind.identifier then
 		(* Named type. *)
 		type_name := _lexer_global_get_start();
-		name_length := _lexer_global_get_end() + -type_name;
-		_write_c('#');
-		_write_s(type_name, name_length);
-		_write_c(' ');
+		name_length := _lexer_global_get_end() - type_name;
 		result := _symbol_table_lookup(@symbol_table_global, type_name, name_length);
-		_write_i(result);
-		_write_c('\n');
 		result := _type_info_get_type(result);
 
 		_lexer_skip_token()
-	elsif token_kind = _lexer_token_kind_left_paren() then
+	elsif token_kind = LexerTokenKind.left_paren then
 		result := _read_type_enumeration()
 	end;
 
@@ -1096,7 +1397,7 @@ begin
 
 	(* Calculate the stack offset: 88 - (4 * parameter_counter) *)
 	offset := parameter_index * 4;
-	_store_word(88 + -offset, current_word);
+	_store_word(88 - offset, current_word);
 
 	memory_free_pointer := current_word + 4;
 
@@ -1106,7 +1407,25 @@ end;
 proc _parameter_info_get_offset(this: Word);
 begin
 	this := this + 4;
-	return _load_word(this)
+	return this^
+end;
+
+proc _type_info_create(type_representation: Word);
+var
+	result: Word;
+	current_word: Word;
+begin
+	result := memory_free_pointer;
+	current_word := result;
+	(* 1 is INFO_TYPE *)
+	_store_word(1, current_word);
+
+	current_word := current_word + 4;
+	_store_word(type_representation, current_word);
+
+	memory_free_pointer := current_word + 4;
+
+	return result
 end;
 
 (**
@@ -1137,7 +1456,7 @@ end;
 proc _temporary_info_get_offset(this: Word);
 begin
 	this := this + 4;
-	return _load_word(this)
+	return this^
 end;
 
 (**
@@ -1154,7 +1473,7 @@ begin
 	(* Read the parameter name. *)
 	_lexer_read_token(@token_kind);
 	name_position := _lexer_global_get_start();
-	name_length := _lexer_global_get_end() + -name_position;
+	name_length := _lexer_global_get_end() - name_position;
 	_lexer_skip_token();
 
 	(* Skip colon and space in front of the type expression. *)
@@ -1189,14 +1508,14 @@ begin
 	.compile_procedure_prologue_skip;
 	_lexer_read_token(@token_kind);
 
-	if token_kind <> _lexer_token_kind_right_paren() then
+	if token_kind <> LexerTokenKind.right_paren then
 		_read_procedure_parameter(parameter_counter);
 		parameter_counter := parameter_counter + 1;
 		_lexer_read_token(@token_kind);
 
-		if token_kind = _lexer_token_kind_comma() then
+		if token_kind = LexerTokenKind.comma then
 			_lexer_skip_token();
-			goto .compile_procedure_prologue_skip
+			goto compile_procedure_prologue_skip
 		end
 	end;
 	(* Skip close paren. *)
@@ -1216,7 +1535,7 @@ var
 begin
 	_lexer_read_token(@token_kind);
 	name_position := _lexer_global_get_start();
-	name_length := _lexer_global_get_end() + -name_position;
+	name_length := _lexer_global_get_end() - name_position;
 	_lexer_skip_token();
 
 	(* Read and skip variable name, colon and the space *)
@@ -1240,18 +1559,18 @@ var
 begin
 	_lexer_read_token(@token_kind);
 
-	if token_kind = _lexer_token_kind_var() then
+	if token_kind = LexerTokenKind._var then
 		_lexer_skip_token();
 		temporary_counter := 0;
 
 		.read_local_variables_loop;
 		_lexer_read_token(@token_kind);
 
-		if token_kind = _lexer_token_kind_identifier() then
+		if token_kind = LexerTokenKind.identifier then
 			_read_procedure_temporary(temporary_counter);
 
 			temporary_counter := temporary_counter + 1;
-			goto .read_local_variables_loop
+			goto read_local_variables_loop
 		end
 	end
 end;
@@ -1271,7 +1590,7 @@ begin
 
 	_lexer_read_token(@token_kind);
 	name_pointer := _lexer_global_get_start();
-	name_length := _lexer_global_get_end() + -name_pointer;
+	name_length := _lexer_global_get_end() - name_pointer;
 
 	(* Write .type _procedure_name, @function. *)
 	_write_z(".type \0");
@@ -1295,10 +1614,10 @@ begin
 
 	(* Skip semicolon, "begin" and newline. *)
 	_lexer_read_token(@token_kind);
-	if token_kind = _lexer_token_kind_begin() then
+	if token_kind = LexerTokenKind._begin then
 		_lexer_skip_token();
 		_compile_statement_list()
-	elsif token_kind = _lexer_token_kind_return() then
+	elsif token_kind = LexerTokenKind._return then
 		_compile_return_statement()
 	end;
 
@@ -1323,9 +1642,9 @@ begin
 
 	_lexer_read_token(@token_kind);
 
-	if token_kind = _lexer_token_kind_comment() then
+	if token_kind = LexerTokenKind.comment then
 		_lexer_skip_token();
-		goto .skip_empty_lines_rerun
+		goto skip_empty_lines_rerun
 	end
 end;
 
@@ -1343,7 +1662,7 @@ begin
 	token_start := _lexer_global_get_start();
 	current_byte := _load_byte(token_start);
 
-	if token_kind = _lexer_token_kind_string() then
+	if token_kind = LexerTokenKind.string then
 		_write_z("\n\t.word strings + \0");
 		length := _string_length(token_start);
 
@@ -1353,7 +1672,7 @@ begin
 		(* Skip the quoted string. *)
 		_lexer_skip_token();
 
-		goto .compile_global_initializer_end
+		goto compile_global_initializer_end
 	elsif current_byte = 'S' then
 		(* Skip "S(". *)
 		_lexer_skip_token();
@@ -1361,37 +1680,37 @@ begin
 		_lexer_skip_token();
 		_lexer_read_token(@token_kind);
 
-		if token_kind = _lexer_token_kind_right_paren() then
-			goto .compile_global_initializer_closing
+		if token_kind = LexerTokenKind.right_paren then
+			goto compile_global_initializer_closing
 		end;
-		goto .compile_global_initializer_loop
-	elsif token_kind = _lexer_token_kind_at() then
+		goto compile_global_initializer_loop
+	elsif token_kind = LexerTokenKind.at then
 		(* Skip @. *)
 		_lexer_skip_token();
 		_write_z("\n\t.word \0");
 		_lexer_read_token(@token_kind);
 		token_start := _lexer_global_get_start();
-		_write_s(token_start, _lexer_global_get_end() + -token_start);
+		_write_s(token_start, _lexer_global_get_end() - token_start);
 		_lexer_skip_token();
 
-		goto .compile_global_initializer_end
-	elsif token_kind = _lexer_token_kind_integer() then
+		goto compile_global_initializer_end
+	elsif token_kind = LexerTokenKind.integer then
 		_write_z("\n\t.word \0");
-		_write_s(token_start, _lexer_global_get_end() + -token_start);
+		_write_s(token_start, _lexer_global_get_end() - token_start);
 		_lexer_skip_token();
 
-		goto .compile_global_initializer_end
+		goto compile_global_initializer_end
 	end;
 
 	.compile_global_initializer_loop;
 	_compile_global_initializer();
 
 	_lexer_read_token(@token_kind);
-	if token_kind <> _lexer_token_kind_right_paren() then
+	if token_kind <> LexerTokenKind.right_paren then
 		(* Skip comma and whitespace after it. *)
 		_lexer_skip_token();
 
-		goto .compile_global_initializer_loop
+		goto compile_global_initializer_loop
 	end;
 
 	.compile_global_initializer_closing;
@@ -1408,7 +1727,7 @@ var
 	token_kind: Word;
 begin
 	name := _lexer_global_get_start();
-	name_length := _lexer_global_get_end() + -name;
+	name_length := _lexer_global_get_end() - name;
 
 	_write_z(".type \0");
 	_write_s(name, name_length);
@@ -1432,11 +1751,20 @@ end;
 proc _compile_type_declaration();
 var
 	token_kind: Word;
+	type_name: Word;
+	name_length: Word;
+	type_info: Word;
 begin
+	type_name := _lexer_global_get_start();
+	name_length := _lexer_global_get_end() - type_name;
+
 	_lexer_skip_token();
 	_lexer_read_token(@token_kind);
 	_lexer_skip_token();
-	_read_type_expression();
+	type_info := _read_type_expression();
+
+	_symbol_table_enter(@symbol_table_global, type_name, name_length, type_info);
+
 	_lexer_read_token(@token_kind);
 	_lexer_skip_token()
 end;
@@ -1448,8 +1776,8 @@ begin
 	_skip_empty_lines();
 	_lexer_read_token(@token_kind);
 
-	if token_kind <> _lexer_token_kind_type() then
-		goto .compile_type_part_end
+	if token_kind <> LexerTokenKind._type then
+		goto compile_type_part_end
 	end;
 	_lexer_skip_token();
 
@@ -1457,9 +1785,9 @@ begin
 	_skip_empty_lines();
 
 	_lexer_read_token(@token_kind);
-	if token_kind = _lexer_token_kind_identifier() then
+	if token_kind = LexerTokenKind.identifier then
 		_compile_type_declaration();
-		goto .compile_type_part_loop
+		goto compile_type_part_loop
 	end;
 
 	.compile_type_part_end
@@ -1472,8 +1800,8 @@ begin
 	_skip_empty_lines();
 	_lexer_read_token(@token_kind);
 
-	if token_kind <> _lexer_token_kind_const() then
-		goto .compile_const_part_end
+	if token_kind <> LexerTokenKind._const then
+		goto compile_const_part_end
 	end;
 	(* Skip "const" with the newline after it. *)
 	_lexer_skip_token();
@@ -1485,9 +1813,9 @@ begin
 	(* If the character at the line beginning is not indentation,
 	it is probably the next code section. *)
 	_lexer_read_token(@token_kind);
-	if token_kind = _lexer_token_kind_identifier() then
+	if token_kind = LexerTokenKind.identifier then
 		_compile_constant_declaration();
-		goto .compile_const_part_loop
+		goto compile_const_part_loop
 	end;
 
 	.compile_const_part_end
@@ -1501,7 +1829,7 @@ var
 begin
 	_lexer_read_token(@token_kind);
 	name := _lexer_global_get_start();
-	name_length := _lexer_global_get_end() + -name;
+	name_length := _lexer_global_get_end() - name;
 
 	_write_z(".type \0");
 	_write_s(name, name_length);
@@ -1518,7 +1846,7 @@ begin
 
 	_lexer_read_token(@token_kind);
 
-	if token_kind <> _lexer_token_kind_assignment() then
+	if token_kind <> LexerTokenKind.assignment then
 		(* Else we assume this is a zeroed 81920 bytes big array. *)
 		_write_z(" .zero 81920\0")
 	else
@@ -1540,8 +1868,8 @@ var
 begin
 	_lexer_read_token(@token_kind);
 
-	if token_kind <> _lexer_token_kind_var() then
-		goto .compile_var_part_end
+	if token_kind <> LexerTokenKind._var then
+		goto compile_var_part_end
 	end;
 	(* Skip "var" and newline. *)
 	_lexer_skip_token();
@@ -1551,9 +1879,9 @@ begin
 	_skip_empty_lines();
 	_lexer_read_token(@token_kind);
 
-	if token_kind = _lexer_token_kind_identifier() then
+	if token_kind = LexerTokenKind.identifier then
 		_compile_variable_declaration();
-		goto .compile_var_part_loop
+		goto compile_var_part_loop
 	end;
 
 	.compile_var_part_end
@@ -1582,9 +1910,9 @@ begin
 	_skip_empty_lines();
 	_lexer_read_token(@token_kind);
 
-	if token_kind = _lexer_token_kind_proc() then
+	if token_kind = LexerTokenKind._proc then
 		_compile_procedure();
-		goto .compile_module_loop
+		goto compile_module_loop
 	end
 end;
 
@@ -1609,7 +1937,7 @@ begin
 		compiler_strings_copy := compiler_strings_copy + 1;
 		_write_c(current_byte);
 
-		goto .compile_loop
+		goto compile_loop
 	end;
 	_write_c('"');
 	_write_c('\n')
@@ -1646,36 +1974,36 @@ begin
 	result := 0;
 
 	(* The first word in the symbol table is its length, get it. *)
-	symbol_table_length := _load_word(symbol_table);
+	symbol_table_length := symbol_table^;
 
 	(* Go to the first symbol position. *)
 	symbol_table := symbol_table + 4;
 
 	.symbol_table_lookup_loop;
 	if symbol_table_length = 0 then
-		goto .symbol_table_lookup_end
+		goto symbol_table_lookup_end
 	end;
 
 	(* Symbol name pointer and length. *)
-	current_name := _load_word(symbol_table);
+	current_name := symbol_table^;
 	current_length := _load_word(symbol_table + 4);
 
 	(* If lengths don't match, exit and return nil. *)
 	if name_length <> current_length then
-		goto .symbol_table_lookup_repeat
+		goto symbol_table_lookup_repeat
 	end;
 	(* If names don't match, exit and return nil. *)
 	if _memcmp(symbol_name, current_name, name_length) <> 0 then
-		goto .symbol_table_lookup_repeat
+		goto symbol_table_lookup_repeat
 	end;
 	(* Otherwise, the symbol is found. *)
 	result := _load_word(symbol_table + 8);
-	goto .symbol_table_lookup_end;
+	goto symbol_table_lookup_end;
 
 	.symbol_table_lookup_repeat;
 	symbol_table := symbol_table + 12;
-	symbol_table_length := symbol_table_length + -1;
-	goto .symbol_table_lookup_loop;
+	symbol_table_length := symbol_table_length - 1;
+	goto symbol_table_lookup_loop;
 
 	.symbol_table_lookup_end;
 	return result
@@ -1696,7 +2024,7 @@ var
 	symbol_pointer: Word;
 begin
 	(* The first word in the symbol table is its length, get it. *)
-	table_length := _load_word(symbol_table);
+	table_length := symbol_table^;
 
 	(* Calculate the offset for the new symbol. *)
 	symbol_pointer := table_length * 12;
@@ -1727,212 +2055,6 @@ begin
 	_symbol_table_enter(@symbol_table_global, symbol_builtin_name_array, 5, @symbol_type_info_array)
 end;
 
-
-(**
- * Classification table assigns each possible character to a group (class). All
- * characters of the same group a handled equivalently.
- *
- * Transition = record
- *   action: TransitionAction;
- *   next_state: TransitionState
- * end;
- *)
-proc _lexer_class_invalid();
-	return 1
-end;
-
-proc _lexer_class_digit();
-	return 2
-end;
-
-proc _lexer_class_alpha();
-	return 3
-end;
-
-proc _lexer_class_space();
-	return 4
-end;
-
-proc _lexer_class_colon();
-	return 5
-end;
-
-proc _lexer_class_equals();
-	return 6
-end;
-
-proc _lexer_class_left_paren();
-	return 7
-end;
-
-proc _lexer_class_right_paren();
-	return 8
-end;
-
-proc _lexer_class_asterisk();
-	return 9
-end;
-
-proc _lexer_class_backslash();
-	return 10
-end;
-
-proc _lexer_class_single();
-	return 11
-end;
-
-proc _lexer_class_hex();
-	return 12
-end;
-
-proc _lexer_class_zero();
-	return 13
-end;
-
-proc _lexer_class_x();
-	return 14
-end;
-
-proc _lexer_class_eof();
-	return 15
-end;
-
-proc _lexer_class_dot();
-	return 16
-end;
-
-proc _lexer_class_minus();
-	return 17
-end;
-
-proc _lexer_class_single_quote();
-	return 18
-end;
-
-proc _lexer_class_double_quote();
-	return 19
-end;
-
-proc _lexer_class_greater();
-	return 20
-end;
-
-proc _lexer_class_less();
-	return 21
-end;
-
-proc _lexer_class_other();
-	return 22
-end;
-
-proc _lexer_state_start();
-	return 1
-end;
-
-proc _lexer_state_colon();
-	return 2
-end;
-
-proc _lexer_state_identifier();
-	return 3
-end;
-
-proc _lexer_state_decimal();
-	return 4
-end;
-
-proc _lexer_state_leading_zero();
-	return 5
-end;
-
-proc _lexer_state_greater();
-	return 6
-end;
-
-proc _lexer_state_minus();
-	return 7
-end;
-
-proc _lexer_state_left_paren();
-	return 8
-end;
-
-proc _lexer_state_less();
-	return 9
-end;
-
-proc _lexer_state_dot();
-	return 10
-end;
-
-proc _lexer_state_comment();
-	return 11
-end;
-
-proc _lexer_state_closing_comment();
-	return 12
-end;
-
-proc _lexer_state_character();
-	return 13
-end;
-
-proc _lexer_state_character_escape();
-	return 14
-end;
-
-proc _lexer_state_string();
-	return 15
-end;
-
-proc _lexer_state_string_escape();
-	return 16
-end;
-
-proc _lexer_state_end();
-	return 17
-end;
-
-proc _lexer_action_none();
-	return 1
-end;
-
-proc _lexer_action_accumulate();
-	return 2
-end;
-
-proc _lexer_action_skip();
-	return 3
-end;
-
-proc _lexer_action_single();
-	return 4
-end;
-
-proc _lexer_action_eof();
-	return 5
-end;
-
-proc _lexer_action_finalize();
-	return 6
-end;
-
-proc _lexer_action_composite();
-	return 7
-end;
-
-proc _lexer_action_key_id();
-	return 8
-end;
-
-proc _lexer_action_integer();
-	return 9
-end;
-
-proc _lexer_action_delimited();
-	return 10
-end;
-
 (**
  * Assigns some value to at array index.
  *
@@ -1945,7 +2067,7 @@ proc _assign_at(array: Word, index: Word, data: Word);
 var
 	target: Word;
 begin
-	target := index + -1;
+	target := index - 1;
 	target := target * 4;
 	target := array + target;
 
@@ -1956,11 +2078,11 @@ proc _get_at(array: Word, index: Word);
 var
 	target: Word;
 begin
-	target := index + -1;
+	target := index - 1;
 	target := target * 4;
 	target := array + target;
 
-	return _load_word(target)
+	return target^
 end;
 
 (**
@@ -1970,144 +2092,144 @@ proc _lexer_classifications();
 var
 	code: Word;
 begin
-	_assign_at(@classification, 1, _lexer_class_eof());
-	_assign_at(@classification, 2, _lexer_class_invalid());
-	_assign_at(@classification, 3, _lexer_class_invalid());
-	_assign_at(@classification, 4, _lexer_class_invalid());
-	_assign_at(@classification, 5, _lexer_class_invalid());
-	_assign_at(@classification, 6, _lexer_class_invalid());
-	_assign_at(@classification, 7, _lexer_class_invalid());
-	_assign_at(@classification, 8, _lexer_class_invalid());
-	_assign_at(@classification, 9, _lexer_class_invalid());
-	_assign_at(@classification, 10, _lexer_class_space());
-	_assign_at(@classification, 11, _lexer_class_space());
-	_assign_at(@classification, 12, _lexer_class_invalid());
-	_assign_at(@classification, 13, _lexer_class_invalid());
-	_assign_at(@classification, 14, _lexer_class_space());
-	_assign_at(@classification, 15, _lexer_class_invalid());
-	_assign_at(@classification, 16, _lexer_class_invalid());
-	_assign_at(@classification, 17, _lexer_class_invalid());
-	_assign_at(@classification, 18, _lexer_class_invalid());
-	_assign_at(@classification, 19, _lexer_class_invalid());
-	_assign_at(@classification, 20, _lexer_class_invalid());
-	_assign_at(@classification, 21, _lexer_class_invalid());
-	_assign_at(@classification, 22, _lexer_class_invalid());
-	_assign_at(@classification, 23, _lexer_class_invalid());
-	_assign_at(@classification, 24, _lexer_class_invalid());
-	_assign_at(@classification, 25, _lexer_class_invalid());
-	_assign_at(@classification, 26, _lexer_class_invalid());
-	_assign_at(@classification, 27, _lexer_class_invalid());
-	_assign_at(@classification, 28, _lexer_class_invalid());
-	_assign_at(@classification, 29, _lexer_class_invalid());
-	_assign_at(@classification, 30, _lexer_class_invalid());
-	_assign_at(@classification, 31, _lexer_class_invalid());
-	_assign_at(@classification, 32, _lexer_class_invalid());
-	_assign_at(@classification, 33, _lexer_class_space());
-	_assign_at(@classification, 34, _lexer_class_single());
-	_assign_at(@classification, 35, _lexer_class_double_quote());
-	_assign_at(@classification, 36, _lexer_class_other());
-	_assign_at(@classification, 37, _lexer_class_other());
-	_assign_at(@classification, 38, _lexer_class_single());
-	_assign_at(@classification, 39, _lexer_class_single());
-	_assign_at(@classification, 40, _lexer_class_single_quote());
-	_assign_at(@classification, 41, _lexer_class_left_paren());
-	_assign_at(@classification, 42, _lexer_class_right_paren());
-	_assign_at(@classification, 43, _lexer_class_asterisk());
-	_assign_at(@classification, 44, _lexer_class_single());
-	_assign_at(@classification, 45, _lexer_class_single());
-	_assign_at(@classification, 46, _lexer_class_minus());
-	_assign_at(@classification, 47, _lexer_class_dot());
-	_assign_at(@classification, 48, _lexer_class_single());
-	_assign_at(@classification, 49, _lexer_class_zero());
-	_assign_at(@classification, 50, _lexer_class_digit());
-	_assign_at(@classification, 51, _lexer_class_digit());
-	_assign_at(@classification, 52, _lexer_class_digit());
-	_assign_at(@classification, 53, _lexer_class_digit());
-	_assign_at(@classification, 54, _lexer_class_digit());
-	_assign_at(@classification, 55, _lexer_class_digit());
-	_assign_at(@classification, 56, _lexer_class_digit());
-	_assign_at(@classification, 57, _lexer_class_digit());
-	_assign_at(@classification, 58, _lexer_class_digit());
-	_assign_at(@classification, 59, _lexer_class_colon());
-	_assign_at(@classification, 60, _lexer_class_single());
-	_assign_at(@classification, 61, _lexer_class_less());
-	_assign_at(@classification, 62, _lexer_class_equals());
-	_assign_at(@classification, 63, _lexer_class_greater());
-	_assign_at(@classification, 64, _lexer_class_other());
-	_assign_at(@classification, 65, _lexer_class_single());
-	_assign_at(@classification, 66, _lexer_class_alpha());
-	_assign_at(@classification, 67, _lexer_class_alpha());
-	_assign_at(@classification, 68, _lexer_class_alpha());
-	_assign_at(@classification, 69, _lexer_class_alpha());
-	_assign_at(@classification, 70, _lexer_class_alpha());
-	_assign_at(@classification, 71, _lexer_class_alpha());
-	_assign_at(@classification, 72, _lexer_class_alpha());
-	_assign_at(@classification, 73, _lexer_class_alpha());
-	_assign_at(@classification, 74, _lexer_class_alpha());
-	_assign_at(@classification, 75, _lexer_class_alpha());
-	_assign_at(@classification, 76, _lexer_class_alpha());
-	_assign_at(@classification, 77, _lexer_class_alpha());
-	_assign_at(@classification, 78, _lexer_class_alpha());
-	_assign_at(@classification, 79, _lexer_class_alpha());
-	_assign_at(@classification, 80, _lexer_class_alpha());
-	_assign_at(@classification, 81, _lexer_class_alpha());
-	_assign_at(@classification, 82, _lexer_class_alpha());
-	_assign_at(@classification, 83, _lexer_class_alpha());
-	_assign_at(@classification, 84, _lexer_class_alpha());
-	_assign_at(@classification, 85, _lexer_class_alpha());
-	_assign_at(@classification, 86, _lexer_class_alpha());
-	_assign_at(@classification, 87, _lexer_class_alpha());
-	_assign_at(@classification, 88, _lexer_class_alpha());
-	_assign_at(@classification, 89, _lexer_class_alpha());
-	_assign_at(@classification, 90, _lexer_class_alpha());
-	_assign_at(@classification, 91, _lexer_class_alpha());
-	_assign_at(@classification, 92, _lexer_class_single());
-	_assign_at(@classification, 93, _lexer_class_backslash());
-	_assign_at(@classification, 94, _lexer_class_single());
-	_assign_at(@classification, 95, _lexer_class_single());
-	_assign_at(@classification, 96, _lexer_class_alpha());
-	_assign_at(@classification, 97, _lexer_class_other());
-	_assign_at(@classification, 98, _lexer_class_hex());
-	_assign_at(@classification, 99, _lexer_class_hex());
-	_assign_at(@classification, 100, _lexer_class_hex());
-	_assign_at(@classification, 101, _lexer_class_hex());
-	_assign_at(@classification, 102, _lexer_class_hex());
-	_assign_at(@classification, 103, _lexer_class_hex());
-	_assign_at(@classification, 104, _lexer_class_alpha());
-	_assign_at(@classification, 105, _lexer_class_alpha());
-	_assign_at(@classification, 106, _lexer_class_alpha());
-	_assign_at(@classification, 107, _lexer_class_alpha());
-	_assign_at(@classification, 108, _lexer_class_alpha());
-	_assign_at(@classification, 109, _lexer_class_alpha());
-	_assign_at(@classification, 110, _lexer_class_alpha());
-	_assign_at(@classification, 111, _lexer_class_alpha());
-	_assign_at(@classification, 112, _lexer_class_alpha());
-	_assign_at(@classification, 113, _lexer_class_alpha());
-	_assign_at(@classification, 114, _lexer_class_alpha());
-	_assign_at(@classification, 115, _lexer_class_alpha());
-	_assign_at(@classification, 116, _lexer_class_alpha());
-	_assign_at(@classification, 117, _lexer_class_alpha());
-	_assign_at(@classification, 118, _lexer_class_alpha());
-	_assign_at(@classification, 119, _lexer_class_alpha());
-	_assign_at(@classification, 120, _lexer_class_alpha());
-	_assign_at(@classification, 121, _lexer_class_x());
-	_assign_at(@classification, 122, _lexer_class_alpha());
-	_assign_at(@classification, 123, _lexer_class_alpha());
-	_assign_at(@classification, 124, _lexer_class_other());
-	_assign_at(@classification, 125, _lexer_class_single());
-	_assign_at(@classification, 126, _lexer_class_other());
-	_assign_at(@classification, 127, _lexer_class_single());
-	_assign_at(@classification, 128, _lexer_class_invalid());
+	_assign_at(@classification, 1, LexerClass.eof);
+	_assign_at(@classification, 2, LexerClass.invalid);
+	_assign_at(@classification, 3, LexerClass.invalid);
+	_assign_at(@classification, 4, LexerClass.invalid);
+	_assign_at(@classification, 5, LexerClass.invalid);
+	_assign_at(@classification, 6, LexerClass.invalid);
+	_assign_at(@classification, 7, LexerClass.invalid);
+	_assign_at(@classification, 8, LexerClass.invalid);
+	_assign_at(@classification, 9, LexerClass.invalid);
+	_assign_at(@classification, 10, LexerClass.space);
+	_assign_at(@classification, 11, LexerClass.space);
+	_assign_at(@classification, 12, LexerClass.invalid);
+	_assign_at(@classification, 13, LexerClass.invalid);
+	_assign_at(@classification, 14, LexerClass.space);
+	_assign_at(@classification, 15, LexerClass.invalid);
+	_assign_at(@classification, 16, LexerClass.invalid);
+	_assign_at(@classification, 17, LexerClass.invalid);
+	_assign_at(@classification, 18, LexerClass.invalid);
+	_assign_at(@classification, 19, LexerClass.invalid);
+	_assign_at(@classification, 20, LexerClass.invalid);
+	_assign_at(@classification, 21, LexerClass.invalid);
+	_assign_at(@classification, 22, LexerClass.invalid);
+	_assign_at(@classification, 23, LexerClass.invalid);
+	_assign_at(@classification, 24, LexerClass.invalid);
+	_assign_at(@classification, 25, LexerClass.invalid);
+	_assign_at(@classification, 26, LexerClass.invalid);
+	_assign_at(@classification, 27, LexerClass.invalid);
+	_assign_at(@classification, 28, LexerClass.invalid);
+	_assign_at(@classification, 29, LexerClass.invalid);
+	_assign_at(@classification, 30, LexerClass.invalid);
+	_assign_at(@classification, 31, LexerClass.invalid);
+	_assign_at(@classification, 32, LexerClass.invalid);
+	_assign_at(@classification, 33, LexerClass.space);
+	_assign_at(@classification, 34, LexerClass.single);
+	_assign_at(@classification, 35, LexerClass.double_quote);
+	_assign_at(@classification, 36, LexerClass.other);
+	_assign_at(@classification, 37, LexerClass.other);
+	_assign_at(@classification, 38, LexerClass.single);
+	_assign_at(@classification, 39, LexerClass.single);
+	_assign_at(@classification, 40, LexerClass.single_quote);
+	_assign_at(@classification, 41, LexerClass.left_paren);
+	_assign_at(@classification, 42, LexerClass.right_paren);
+	_assign_at(@classification, 43, LexerClass.asterisk);
+	_assign_at(@classification, 44, LexerClass.single);
+	_assign_at(@classification, 45, LexerClass.single);
+	_assign_at(@classification, 46, LexerClass.minus);
+	_assign_at(@classification, 47, LexerClass.dot);
+	_assign_at(@classification, 48, LexerClass.single);
+	_assign_at(@classification, 49, LexerClass.zero);
+	_assign_at(@classification, 50, LexerClass.digit);
+	_assign_at(@classification, 51, LexerClass.digit);
+	_assign_at(@classification, 52, LexerClass.digit);
+	_assign_at(@classification, 53, LexerClass.digit);
+	_assign_at(@classification, 54, LexerClass.digit);
+	_assign_at(@classification, 55, LexerClass.digit);
+	_assign_at(@classification, 56, LexerClass.digit);
+	_assign_at(@classification, 57, LexerClass.digit);
+	_assign_at(@classification, 58, LexerClass.digit);
+	_assign_at(@classification, 59, LexerClass.colon);
+	_assign_at(@classification, 60, LexerClass.single);
+	_assign_at(@classification, 61, LexerClass.less);
+	_assign_at(@classification, 62, LexerClass.equals);
+	_assign_at(@classification, 63, LexerClass.greater);
+	_assign_at(@classification, 64, LexerClass.other);
+	_assign_at(@classification, 65, LexerClass.single);
+	_assign_at(@classification, 66, LexerClass.alpha);
+	_assign_at(@classification, 67, LexerClass.alpha);
+	_assign_at(@classification, 68, LexerClass.alpha);
+	_assign_at(@classification, 69, LexerClass.alpha);
+	_assign_at(@classification, 70, LexerClass.alpha);
+	_assign_at(@classification, 71, LexerClass.alpha);
+	_assign_at(@classification, 72, LexerClass.alpha);
+	_assign_at(@classification, 73, LexerClass.alpha);
+	_assign_at(@classification, 74, LexerClass.alpha);
+	_assign_at(@classification, 75, LexerClass.alpha);
+	_assign_at(@classification, 76, LexerClass.alpha);
+	_assign_at(@classification, 77, LexerClass.alpha);
+	_assign_at(@classification, 78, LexerClass.alpha);
+	_assign_at(@classification, 79, LexerClass.alpha);
+	_assign_at(@classification, 80, LexerClass.alpha);
+	_assign_at(@classification, 81, LexerClass.alpha);
+	_assign_at(@classification, 82, LexerClass.alpha);
+	_assign_at(@classification, 83, LexerClass.alpha);
+	_assign_at(@classification, 84, LexerClass.alpha);
+	_assign_at(@classification, 85, LexerClass.alpha);
+	_assign_at(@classification, 86, LexerClass.alpha);
+	_assign_at(@classification, 87, LexerClass.alpha);
+	_assign_at(@classification, 88, LexerClass.alpha);
+	_assign_at(@classification, 89, LexerClass.alpha);
+	_assign_at(@classification, 90, LexerClass.alpha);
+	_assign_at(@classification, 91, LexerClass.alpha);
+	_assign_at(@classification, 92, LexerClass.single);
+	_assign_at(@classification, 93, LexerClass.backslash);
+	_assign_at(@classification, 94, LexerClass.single);
+	_assign_at(@classification, 95, LexerClass.single);
+	_assign_at(@classification, 96, LexerClass.alpha);
+	_assign_at(@classification, 97, LexerClass.other);
+	_assign_at(@classification, 98, LexerClass.hex);
+	_assign_at(@classification, 99, LexerClass.hex);
+	_assign_at(@classification, 100, LexerClass.hex);
+	_assign_at(@classification, 101, LexerClass.hex);
+	_assign_at(@classification, 102, LexerClass.hex);
+	_assign_at(@classification, 103, LexerClass.hex);
+	_assign_at(@classification, 104, LexerClass.alpha);
+	_assign_at(@classification, 105, LexerClass.alpha);
+	_assign_at(@classification, 106, LexerClass.alpha);
+	_assign_at(@classification, 107, LexerClass.alpha);
+	_assign_at(@classification, 108, LexerClass.alpha);
+	_assign_at(@classification, 109, LexerClass.alpha);
+	_assign_at(@classification, 110, LexerClass.alpha);
+	_assign_at(@classification, 111, LexerClass.alpha);
+	_assign_at(@classification, 112, LexerClass.alpha);
+	_assign_at(@classification, 113, LexerClass.alpha);
+	_assign_at(@classification, 114, LexerClass.alpha);
+	_assign_at(@classification, 115, LexerClass.alpha);
+	_assign_at(@classification, 116, LexerClass.alpha);
+	_assign_at(@classification, 117, LexerClass.alpha);
+	_assign_at(@classification, 118, LexerClass.alpha);
+	_assign_at(@classification, 119, LexerClass.alpha);
+	_assign_at(@classification, 120, LexerClass.alpha);
+	_assign_at(@classification, 121, LexerClass.x);
+	_assign_at(@classification, 122, LexerClass.alpha);
+	_assign_at(@classification, 123, LexerClass.alpha);
+	_assign_at(@classification, 124, LexerClass.other);
+	_assign_at(@classification, 125, LexerClass.single);
+	_assign_at(@classification, 126, LexerClass.other);
+	_assign_at(@classification, 127, LexerClass.single);
+	_assign_at(@classification, 128, LexerClass.invalid);
 
 	code := 129;
 
 	(* Set the remaining 129 - 256 bytes to transitionClassOther. *)
 	.create_classification_loop;
-	_assign_at(@classification, code, _lexer_class_other());
+	_assign_at(@classification, code, LexerClass.other);
 	code := code + 1;
 
 	if code < 257 then
-		goto .create_classification_loop
+		goto create_classification_loop
 	end
 end;
 
@@ -2120,10 +2242,10 @@ var
 begin
 	(* Each state is 8 bytes long (2 words: action and next state).
 	There are 22 character classes, so a transition row 8 * 22 = 176 bytes long. *)
-	row_position := current_state + -1;
+	row_position := current_state - 1;
 	row_position := row_position * 176;
 
-	column_position := character_class + -1;
+	column_position := character_class - 1;
 	column_position := column_position * 8;
 
 	target := _lexer_get_transition_table() + row_position;
@@ -2158,28 +2280,28 @@ end;
  *)
 proc _lexer_default_transition(current_state: Word, default_action: Word, next_state: Word);
 begin
-	_lexer_set_transition(current_state, _lexer_class_invalid(), default_action, next_state);
-	_lexer_set_transition(current_state, _lexer_class_digit(), default_action, next_state);
-	_lexer_set_transition(current_state, _lexer_class_alpha(), default_action, next_state);
-	_lexer_set_transition(current_state, _lexer_class_space(), default_action, next_state);
-	_lexer_set_transition(current_state, _lexer_class_colon(), default_action, next_state);
-	_lexer_set_transition(current_state, _lexer_class_equals(), default_action, next_state);
-	_lexer_set_transition(current_state, _lexer_class_left_paren(), default_action, next_state);
-	_lexer_set_transition(current_state, _lexer_class_right_paren(), default_action, next_state);
-	_lexer_set_transition(current_state, _lexer_class_asterisk(), default_action, next_state);
-	_lexer_set_transition(current_state, _lexer_class_backslash(), default_action, next_state);
-	_lexer_set_transition(current_state, _lexer_class_single(), default_action, next_state);
-	_lexer_set_transition(current_state, _lexer_class_hex(), default_action, next_state);
-	_lexer_set_transition(current_state, _lexer_class_zero(), default_action, next_state);
-	_lexer_set_transition(current_state, _lexer_class_x(), default_action, next_state);
-	_lexer_set_transition(current_state, _lexer_class_eof(), default_action, next_state);
-	_lexer_set_transition(current_state, _lexer_class_dot(), default_action, next_state);
-	_lexer_set_transition(current_state, _lexer_class_minus(), default_action, next_state);
-	_lexer_set_transition(current_state, _lexer_class_single_quote(), default_action, next_state);
-	_lexer_set_transition(current_state, _lexer_class_double_quote(), default_action, next_state);
-	_lexer_set_transition(current_state, _lexer_class_greater(), default_action, next_state);
-	_lexer_set_transition(current_state, _lexer_class_less(), default_action, next_state);
-	_lexer_set_transition(current_state, _lexer_class_other(), default_action, next_state)
+	_lexer_set_transition(current_state, LexerClass.invalid, default_action, next_state);
+	_lexer_set_transition(current_state, LexerClass.digit, default_action, next_state);
+	_lexer_set_transition(current_state, LexerClass.alpha, default_action, next_state);
+	_lexer_set_transition(current_state, LexerClass.space, default_action, next_state);
+	_lexer_set_transition(current_state, LexerClass.colon, default_action, next_state);
+	_lexer_set_transition(current_state, LexerClass.equals, default_action, next_state);
+	_lexer_set_transition(current_state, LexerClass.left_paren, default_action, next_state);
+	_lexer_set_transition(current_state, LexerClass.right_paren, default_action, next_state);
+	_lexer_set_transition(current_state, LexerClass.asterisk, default_action, next_state);
+	_lexer_set_transition(current_state, LexerClass.backslash, default_action, next_state);
+	_lexer_set_transition(current_state, LexerClass.single, default_action, next_state);
+	_lexer_set_transition(current_state, LexerClass.hex, default_action, next_state);
+	_lexer_set_transition(current_state, LexerClass.zero, default_action, next_state);
+	_lexer_set_transition(current_state, LexerClass.x, default_action, next_state);
+	_lexer_set_transition(current_state, LexerClass.eof, default_action, next_state);
+	_lexer_set_transition(current_state, LexerClass.dot, default_action, next_state);
+	_lexer_set_transition(current_state, LexerClass.minus, default_action, next_state);
+	_lexer_set_transition(current_state, LexerClass.single_quote, default_action, next_state);
+	_lexer_set_transition(current_state, LexerClass.double_quote, default_action, next_state);
+	_lexer_set_transition(current_state, LexerClass.greater, default_action, next_state);
+	_lexer_set_transition(current_state, LexerClass.less, default_action, next_state);
+	_lexer_set_transition(current_state, LexerClass.other, default_action, next_state)
 end;
 
 (**
@@ -2193,113 +2315,113 @@ end;
 proc _lexer_transitions();
 begin
 	(* Start state. *)
-	_lexer_set_transition(_lexer_state_start(), _lexer_class_invalid(), _lexer_action_none(), _lexer_state_end());
-	_lexer_set_transition(_lexer_state_start(), _lexer_class_digit(), _lexer_action_accumulate(), _lexer_state_decimal());
-	_lexer_set_transition(_lexer_state_start(), _lexer_class_alpha(), _lexer_action_accumulate(), _lexer_state_identifier());
-	_lexer_set_transition(_lexer_state_start(), _lexer_class_space(), _lexer_action_skip(), _lexer_state_start());
-	_lexer_set_transition(_lexer_state_start(), _lexer_class_colon(), _lexer_action_accumulate(), _lexer_state_colon());
-	_lexer_set_transition(_lexer_state_start(), _lexer_class_equals(), _lexer_action_single(), _lexer_state_end());
-	_lexer_set_transition(_lexer_state_start(), _lexer_class_left_paren(), _lexer_action_accumulate(), _lexer_state_left_paren());
-	_lexer_set_transition(_lexer_state_start(), _lexer_class_right_paren(), _lexer_action_single(), _lexer_state_end());
-	_lexer_set_transition(_lexer_state_start(), _lexer_class_asterisk(), _lexer_action_single(), _lexer_state_end());
-	_lexer_set_transition(_lexer_state_start(), _lexer_class_backslash(), _lexer_action_none(), _lexer_state_end());
-	_lexer_set_transition(_lexer_state_start(), _lexer_class_single(), _lexer_action_single(), _lexer_state_end());
-	_lexer_set_transition(_lexer_state_start(), _lexer_class_hex(), _lexer_action_accumulate(), _lexer_state_identifier());
-	_lexer_set_transition(_lexer_state_start(), _lexer_class_zero(), _lexer_action_accumulate(), _lexer_state_leading_zero());
-	_lexer_set_transition(_lexer_state_start(), _lexer_class_x(), _lexer_action_accumulate(), _lexer_state_identifier());
-	_lexer_set_transition(_lexer_state_start(), _lexer_class_eof(), _lexer_action_eof(), _lexer_state_end());
-	_lexer_set_transition(_lexer_state_start(), _lexer_class_dot(), _lexer_action_single(), _lexer_state_end());
-	_lexer_set_transition(_lexer_state_start(), _lexer_class_minus(), _lexer_action_accumulate(), _lexer_state_minus());
-	_lexer_set_transition(_lexer_state_start(), _lexer_class_single_quote(), _lexer_action_accumulate(), _lexer_state_character());
-	_lexer_set_transition(_lexer_state_start(), _lexer_class_double_quote(), _lexer_action_accumulate(), _lexer_state_string());
-	_lexer_set_transition(_lexer_state_start(), _lexer_class_greater(), _lexer_action_accumulate(), _lexer_state_greater());
-	_lexer_set_transition(_lexer_state_start(), _lexer_class_less(), _lexer_action_accumulate(), _lexer_state_less());
-	_lexer_set_transition(_lexer_state_start(), _lexer_class_other(), _lexer_action_none(), _lexer_state_end());
+	_lexer_set_transition(LexerState.start, LexerClass.invalid, LexerAction.none, LexerState.finish);
+	_lexer_set_transition(LexerState.start, LexerClass.digit, LexerAction.accumulate, LexerState.decimal);
+	_lexer_set_transition(LexerState.start, LexerClass.alpha, LexerAction.accumulate, LexerState.identifier);
+	_lexer_set_transition(LexerState.start, LexerClass.space, LexerAction.skip, LexerState.start);
+	_lexer_set_transition(LexerState.start, LexerClass.colon, LexerAction.accumulate, LexerState.colon);
+	_lexer_set_transition(LexerState.start, LexerClass.equals, LexerAction.single, LexerState.finish);
+	_lexer_set_transition(LexerState.start, LexerClass.left_paren, LexerAction.accumulate, LexerState.left_paren);
+	_lexer_set_transition(LexerState.start, LexerClass.right_paren, LexerAction.single, LexerState.finish);
+	_lexer_set_transition(LexerState.start, LexerClass.asterisk, LexerAction.single, LexerState.finish);
+	_lexer_set_transition(LexerState.start, LexerClass.backslash, LexerAction.none, LexerState.finish);
+	_lexer_set_transition(LexerState.start, LexerClass.single, LexerAction.single, LexerState.finish);
+	_lexer_set_transition(LexerState.start, LexerClass.hex, LexerAction.accumulate, LexerState.identifier);
+	_lexer_set_transition(LexerState.start, LexerClass.zero, LexerAction.accumulate, LexerState.leading_zero);
+	_lexer_set_transition(LexerState.start, LexerClass.x, LexerAction.accumulate, LexerState.identifier);
+	_lexer_set_transition(LexerState.start, LexerClass.eof, LexerAction.eof, LexerState.finish);
+	_lexer_set_transition(LexerState.start, LexerClass.dot, LexerAction.single, LexerState.finish);
+	_lexer_set_transition(LexerState.start, LexerClass.minus, LexerAction.accumulate, LexerState.minus);
+	_lexer_set_transition(LexerState.start, LexerClass.single_quote, LexerAction.accumulate, LexerState.character);
+	_lexer_set_transition(LexerState.start, LexerClass.double_quote, LexerAction.accumulate, LexerState.string);
+	_lexer_set_transition(LexerState.start, LexerClass.greater, LexerAction.accumulate, LexerState.greater);
+	_lexer_set_transition(LexerState.start, LexerClass.less, LexerAction.accumulate, LexerState.less);
+	_lexer_set_transition(LexerState.start, LexerClass.other, LexerAction.none, LexerState.finish);
 
 	(* Colon state. *)
-	_lexer_default_transition(_lexer_state_colon(), _lexer_action_finalize(), _lexer_state_end());
-	_lexer_set_transition(_lexer_state_colon(), _lexer_class_equals(), _lexer_action_composite(), _lexer_state_end());
+	_lexer_default_transition(LexerState.colon, LexerAction.finalize, LexerState.finish);
+	_lexer_set_transition(LexerState.colon, LexerClass.equals, LexerAction.composite, LexerState.finish);
 
 	(* Identifier state. *)
-	_lexer_default_transition(_lexer_state_identifier(), _lexer_action_key_id(), _lexer_state_end());
-	_lexer_set_transition(_lexer_state_identifier(), _lexer_class_digit(), _lexer_action_accumulate(), _lexer_state_identifier());
-	_lexer_set_transition(_lexer_state_identifier(), _lexer_class_alpha(), _lexer_action_accumulate(), _lexer_state_identifier());
-	_lexer_set_transition(_lexer_state_identifier(), _lexer_class_hex(), _lexer_action_accumulate(), _lexer_state_identifier());
-	_lexer_set_transition(_lexer_state_identifier(), _lexer_class_zero(), _lexer_action_accumulate(), _lexer_state_identifier());
-	_lexer_set_transition(_lexer_state_identifier(), _lexer_class_x(), _lexer_action_accumulate(), _lexer_state_identifier());
+	_lexer_default_transition(LexerState.identifier, LexerAction.key_id, LexerState.finish);
+	_lexer_set_transition(LexerState.identifier, LexerClass.digit, LexerAction.accumulate, LexerState.identifier);
+	_lexer_set_transition(LexerState.identifier, LexerClass.alpha, LexerAction.accumulate, LexerState.identifier);
+	_lexer_set_transition(LexerState.identifier, LexerClass.hex, LexerAction.accumulate, LexerState.identifier);
+	_lexer_set_transition(LexerState.identifier, LexerClass.zero, LexerAction.accumulate, LexerState.identifier);
+	_lexer_set_transition(LexerState.identifier, LexerClass.x, LexerAction.accumulate, LexerState.identifier);
 
 	(* Decimal state. *)
-	_lexer_default_transition(_lexer_state_decimal(), _lexer_action_integer(), _lexer_state_end());
-	_lexer_set_transition(_lexer_state_decimal(), _lexer_class_digit(), _lexer_action_accumulate(), _lexer_state_decimal());
-	_lexer_set_transition(_lexer_state_decimal(), _lexer_class_alpha(), _lexer_action_none(), _lexer_state_end());
-	_lexer_set_transition(_lexer_state_decimal(), _lexer_class_hex(), _lexer_action_none(), _lexer_state_end());
-	_lexer_set_transition(_lexer_state_decimal(), _lexer_class_zero(), _lexer_action_accumulate(), _lexer_state_decimal());
-	_lexer_set_transition(_lexer_state_decimal(), _lexer_class_x(), _lexer_action_none(), _lexer_state_end());
+	_lexer_default_transition(LexerState.decimal, LexerAction.integer, LexerState.finish);
+	_lexer_set_transition(LexerState.decimal, LexerClass.digit, LexerAction.accumulate, LexerState.decimal);
+	_lexer_set_transition(LexerState.decimal, LexerClass.alpha, LexerAction.none, LexerState.finish);
+	_lexer_set_transition(LexerState.decimal, LexerClass.hex, LexerAction.none, LexerState.finish);
+	_lexer_set_transition(LexerState.decimal, LexerClass.zero, LexerAction.accumulate, LexerState.decimal);
+	_lexer_set_transition(LexerState.decimal, LexerClass.x, LexerAction.none, LexerState.finish);
 
 	(* Leading zero. *)
-	_lexer_default_transition(_lexer_state_leading_zero(), _lexer_action_integer(), _lexer_state_end());
-	_lexer_set_transition(_lexer_state_leading_zero(), _lexer_class_digit(), _lexer_action_none(), _lexer_state_end());
-	_lexer_set_transition(_lexer_state_leading_zero(), _lexer_class_alpha(), _lexer_action_none(), _lexer_state_end());
-	_lexer_set_transition(_lexer_state_leading_zero(), _lexer_class_hex(), _lexer_action_none(), _lexer_state_end());
-	_lexer_set_transition(_lexer_state_leading_zero(), _lexer_class_zero(), _lexer_action_none(), _lexer_state_end());
-	_lexer_set_transition(_lexer_state_leading_zero(), _lexer_class_x(), _lexer_action_none(), _lexer_state_dot());
+	_lexer_default_transition(LexerState.leading_zero, LexerAction.integer, LexerState.finish);
+	_lexer_set_transition(LexerState.leading_zero, LexerClass.digit, LexerAction.none, LexerState.finish);
+	_lexer_set_transition(LexerState.leading_zero, LexerClass.alpha, LexerAction.none, LexerState.finish);
+	_lexer_set_transition(LexerState.leading_zero, LexerClass.hex, LexerAction.none, LexerState.finish);
+	_lexer_set_transition(LexerState.leading_zero, LexerClass.zero, LexerAction.none, LexerState.finish);
+	_lexer_set_transition(LexerState.leading_zero, LexerClass.x, LexerAction.none, LexerState.dot);
 
 	(* Greater state. *)
-	_lexer_default_transition(_lexer_state_greater(), _lexer_action_finalize(), _lexer_state_end());
-	_lexer_set_transition(_lexer_state_greater(), _lexer_class_equals(), _lexer_action_composite(), _lexer_state_end());
+	_lexer_default_transition(LexerState.greater, LexerAction.finalize, LexerState.finish);
+	_lexer_set_transition(LexerState.greater, LexerClass.equals, LexerAction.composite, LexerState.finish);
 
 	(* Minus state. *)
-	_lexer_default_transition(_lexer_state_minus(), _lexer_action_finalize(), _lexer_state_end());
-	_lexer_set_transition(_lexer_state_minus(), _lexer_class_greater(), _lexer_action_composite(), _lexer_state_end());
+	_lexer_default_transition(LexerState.minus, LexerAction.finalize, LexerState.finish);
+	_lexer_set_transition(LexerState.minus, LexerClass.greater, LexerAction.composite, LexerState.finish);
 
 	(* Left paren state. *)
-	_lexer_default_transition(_lexer_state_left_paren(), _lexer_action_finalize(), _lexer_state_end());
-	_lexer_set_transition(_lexer_state_left_paren(), _lexer_class_asterisk(), _lexer_action_accumulate(), _lexer_state_comment());
+	_lexer_default_transition(LexerState.left_paren, LexerAction.finalize, LexerState.finish);
+	_lexer_set_transition(LexerState.left_paren, LexerClass.asterisk, LexerAction.accumulate, LexerState.comment);
 
 	(* Less state. *)
-	_lexer_default_transition(_lexer_state_less(), _lexer_action_finalize(), _lexer_state_end());
-	_lexer_set_transition(_lexer_state_less(), _lexer_class_equals(), _lexer_action_composite(), _lexer_state_end());
-	_lexer_set_transition(_lexer_state_less(), _lexer_class_greater(), _lexer_action_composite(), _lexer_state_end());
+	_lexer_default_transition(LexerState.less, LexerAction.finalize, LexerState.finish);
+	_lexer_set_transition(LexerState.less, LexerClass.equals, LexerAction.composite, LexerState.finish);
+	_lexer_set_transition(LexerState.less, LexerClass.greater, LexerAction.composite, LexerState.finish);
 
 	(* Hexadecimal after 0x. *)
-	_lexer_default_transition(_lexer_state_dot(), _lexer_action_finalize(), _lexer_state_end());
-	_lexer_set_transition(_lexer_state_dot(), _lexer_class_dot(), _lexer_action_composite(), _lexer_state_end());
+	_lexer_default_transition(LexerState.dot, LexerAction.finalize, LexerState.finish);
+	_lexer_set_transition(LexerState.dot, LexerClass.dot, LexerAction.composite, LexerState.finish);
 
 	(* Comment. *)
-	_lexer_default_transition(_lexer_state_comment(), _lexer_action_accumulate(), _lexer_state_comment());
-	_lexer_set_transition(_lexer_state_comment(), _lexer_class_asterisk(), _lexer_action_accumulate(), _lexer_state_closing_comment());
-	_lexer_set_transition(_lexer_state_comment(), _lexer_class_eof(), _lexer_action_none(), _lexer_state_end());
+	_lexer_default_transition(LexerState.comment, LexerAction.accumulate, LexerState.comment);
+	_lexer_set_transition(LexerState.comment, LexerClass.asterisk, LexerAction.accumulate, LexerState.closing_comment);
+	_lexer_set_transition(LexerState.comment, LexerClass.eof, LexerAction.none, LexerState.finish);
 
 	(* Closing comment. *)
-	_lexer_default_transition(_lexer_state_closing_comment(), _lexer_action_accumulate(), _lexer_state_comment());
-	_lexer_set_transition(_lexer_state_closing_comment(), _lexer_class_invalid(), _lexer_action_none(), _lexer_state_end());
-	_lexer_set_transition(_lexer_state_closing_comment(), _lexer_class_right_paren(), _lexer_action_delimited(), _lexer_state_end());
-	_lexer_set_transition(_lexer_state_closing_comment(), _lexer_class_asterisk(), _lexer_action_accumulate(), _lexer_state_closing_comment());
-	_lexer_set_transition(_lexer_state_closing_comment(), _lexer_class_eof(), _lexer_action_none(), _lexer_state_end());
+	_lexer_default_transition(LexerState.closing_comment, LexerAction.accumulate, LexerState.comment);
+	_lexer_set_transition(LexerState.closing_comment, LexerClass.invalid, LexerAction.none, LexerState.finish);
+	_lexer_set_transition(LexerState.closing_comment, LexerClass.right_paren, LexerAction.delimited, LexerState.finish);
+	_lexer_set_transition(LexerState.closing_comment, LexerClass.asterisk, LexerAction.accumulate, LexerState.closing_comment);
+	_lexer_set_transition(LexerState.closing_comment, LexerClass.eof, LexerAction.none, LexerState.finish);
 
 	(* Character. *)
-	_lexer_default_transition(_lexer_state_character(), _lexer_action_accumulate(), _lexer_state_character());
-	_lexer_set_transition(_lexer_state_character(), _lexer_class_invalid(), _lexer_action_none(), _lexer_state_end());
-	_lexer_set_transition(_lexer_state_character(), _lexer_class_eof(), _lexer_action_none(), _lexer_state_end());
-	_lexer_set_transition(_lexer_state_character(), _lexer_class_single_quote(), _lexer_action_delimited(), _lexer_state_end());
-	_lexer_set_transition(_lexer_state_character(), _lexer_class_backslash(), _lexer_action_accumulate(), _lexer_state_character_escape());
+	_lexer_default_transition(LexerState.character, LexerAction.accumulate, LexerState.character);
+	_lexer_set_transition(LexerState.character, LexerClass.invalid, LexerAction.none, LexerState.finish);
+	_lexer_set_transition(LexerState.character, LexerClass.eof, LexerAction.none, LexerState.finish);
+	_lexer_set_transition(LexerState.character, LexerClass.single_quote, LexerAction.delimited, LexerState.finish);
+	_lexer_set_transition(LexerState.character, LexerClass.backslash, LexerAction.accumulate, LexerState.character_escape);
 
 	(* Escape sequence in a character. *)
-	_lexer_default_transition(_lexer_state_character_escape(), _lexer_action_accumulate(), _lexer_state_character());
-	_lexer_set_transition(_lexer_state_character_escape(), _lexer_class_invalid(), _lexer_action_none(), _lexer_state_end());
-	_lexer_set_transition(_lexer_state_character_escape(), _lexer_class_eof(), _lexer_action_none(), _lexer_state_end());
+	_lexer_default_transition(LexerState.character_escape, LexerAction.accumulate, LexerState.character);
+	_lexer_set_transition(LexerState.character_escape, LexerClass.invalid, LexerAction.none, LexerState.finish);
+	_lexer_set_transition(LexerState.character_escape, LexerClass.eof, LexerAction.none, LexerState.finish);
 
 	(* String. *)
-	_lexer_default_transition(_lexer_state_string(), _lexer_action_accumulate(), _lexer_state_string());
-	_lexer_set_transition(_lexer_state_string(), _lexer_class_invalid(), _lexer_action_none(), _lexer_state_end());
-	_lexer_set_transition(_lexer_state_string(), _lexer_class_eof(), _lexer_action_none(), _lexer_state_end());
-	_lexer_set_transition(_lexer_state_string(), _lexer_class_double_quote(), _lexer_action_delimited(), _lexer_state_end());
-	_lexer_set_transition(_lexer_state_string(), _lexer_class_backslash(), _lexer_action_accumulate(), _lexer_state_string_escape());
+	_lexer_default_transition(LexerState.string, LexerAction.accumulate, LexerState.string);
+	_lexer_set_transition(LexerState.string, LexerClass.invalid, LexerAction.none, LexerState.finish);
+	_lexer_set_transition(LexerState.string, LexerClass.eof, LexerAction.none, LexerState.finish);
+	_lexer_set_transition(LexerState.string, LexerClass.double_quote, LexerAction.delimited, LexerState.finish);
+	_lexer_set_transition(LexerState.string, LexerClass.backslash, LexerAction.accumulate, LexerState.string_escape);
 
 	(* Escape sequence in a string. *)
-	_lexer_default_transition(_lexer_state_string_escape(), _lexer_action_accumulate(), _lexer_state_string());
-	_lexer_set_transition(_lexer_state_string_escape(), _lexer_class_invalid(), _lexer_action_none(), _lexer_state_end());
-	_lexer_set_transition(_lexer_state_string_escape(), _lexer_class_eof(), _lexer_action_none(), _lexer_state_end())
+	_lexer_default_transition(LexerState.string_escape, LexerAction.accumulate, LexerState.string);
+	_lexer_set_transition(LexerState.string_escape, LexerClass.invalid, LexerAction.none, LexerState.finish);
+	_lexer_set_transition(LexerState.string_escape, LexerClass.eof, LexerAction.none, LexerState.finish)
 end;
 
 (**
@@ -2328,7 +2450,7 @@ var
 	target: Word;
 begin
 	target := _lexer_global_state() + 4;
-	return _load_word(target)
+	return target^
 end;
 
 (**
@@ -2350,7 +2472,7 @@ var
 	target: Word;
 begin
 	target := _lexer_global_state() + 8;
-	return _load_word(target)
+	return target^
 end;
 
 (**
@@ -2365,7 +2487,7 @@ begin
 end;
 
 proc _lexer_transition_get_action(transition: Word);
-	return _load_word(transition)
+	return transition^
 end;
 
 proc _lexer_transition_set_action(transition: Word, action: Word);
@@ -2391,7 +2513,7 @@ var
 begin
 	(* Transition start state is 1. *)
 	state := _lexer_global_state();
-	_store_word(_lexer_state_start(), state);
+	_store_word(LexerState.start, state);
 
 	state := _lexer_global_get_start();
 	_lexer_global_set_end(state)
@@ -2421,271 +2543,11 @@ begin
 	character_class := _get_at(@classification, current_character + 1);
 
 	current_state := _lexer_global_state();
-	current_state := _load_word(current_state);
+	current_state := current_state^;
 
 	return _lexer_get_transition(current_state, character_class)
 end;
 
-proc _lexer_token_kind_identifier();
-	return 1
-end;
-
-proc _lexer_token_kind_const();
-	return 2
-end;
-
-proc _lexer_token_kind_var();
-	return 3
-end;
-
-proc _lexer_token_kind_proc();
-	return 4
-end;
-
-proc _lexer_token_kind_type();
-	return 5
-end;
-
-proc _lexer_token_kind_begin();
-	return 6
-end;
-
-proc _lexer_token_kind_end();
-	return 7
-end;
-
-proc _lexer_token_kind_if();
-	return 8
-end;
-
-proc _lexer_token_kind_then();
-	return 9
-end;
-
-proc _lexer_token_kind_else();
-	return 10
-end;
-
-proc _lexer_token_kind_elsif();
-	return 11
-end;
-
-proc _lexer_token_kind_while();
-	return 12
-end;
-
-proc _lexer_token_kind_do();
-	return 13
-end;
-
-proc _lexer_token_kind_extern();
-	return 14
-end;
-
-proc _lexer_token_kind_record();
-	return 15
-end;
-
-proc _lexer_token_kind_union();
-	return 16
-end;
-
-proc _lexer_token_kind_true();
-	return 17
-end;
-
-proc _lexer_token_kind_false();
-	return 18
-end;
-
-proc _lexer_token_kind_nil();
-	return 19
-end;
-
-proc _lexer_token_kind_and();
-	return 20
-end;
-
-proc _lexer_token_kind_or();
-	return 21
-end;
-
-proc _lexer_token_kind_xor();
-	return 22
-end;
-
-proc _lexer_token_kind_pipe();
-	return 23
-end;
-
-proc _lexer_token_kind_not();
-	return 24
-end;
-
-proc _lexer_token_kind_return();
-	return 24
-end;
-
-proc _lexer_token_kind_module();
-	return 25
-end;
-
-proc _lexer_token_kind_program();
-	return 26
-end;
-
-proc _lexer_token_kind_import();
-	return 27
-end;
-
-proc _lexer_token_kind_cast();
-	return 28
-end;
-
-proc _lexer_token_kind_defer();
-	return 29
-end;
-
-proc _lexer_token_kind_case();
-	return 30
-end;
-
-proc _lexer_token_kind_of();
-	return 31
-end;
-
-proc _lexer_token_kind_trait();
-	return 32
-end;
-
-proc _lexer_token_kind_left_paren();
-	return 33
-end;
-
-proc _lexer_token_kind_right_paren();
-	return 34
-end;
-
-proc _lexer_token_kind_left_square();
-	return 35
-end;
-
-proc _lexer_token_kind_right_square();
-	return 36
-end;
-
-proc _lexer_token_kind_shift_left();
-	return 37
-end;
-
-proc _lexer_token_kind_shift_right();
-	return 38
-end;
-
-proc _lexer_token_kind_greater_equal();
-	return 39
-end;
-
-proc _lexer_token_kind_less_equal();
-	return 40
-end;
-
-proc _lexer_token_kind_greater_than();
-	return 41
-end;
-
-proc _lexer_token_kind_less_than();
-	return 42
-end;
-
-proc _lexer_token_kind_not_equal();
-	return 43
-end;
-
-proc _lexer_token_kind_equals();
-	return 44
-end;
-
-proc _lexer_token_kind_semicolon();
-	return 45
-end;
-
-proc _lexer_token_kind_dot();
-	return 46
-end;
-
-proc _lexer_token_kind_comma();
-	return 47
-end;
-
-proc _lexer_token_kind_plus();
-	return 48
-end;
-
-proc _lexer_token_kind_arrow();
-	return 49
-end;
-
-proc _lexer_token_kind_minus();
-	return 50
-end;
-
-proc _lexer_token_kind_multiplication();
-	return 51
-end;
-
-proc _lexer_token_kind_division();
-	return 52
-end;
-
-proc _lexer_token_kind_remainder();
-	return 53
-end;
-
-proc _lexer_token_kind_assignment();
-	return 54
-end;
-
-proc _lexer_token_kind_colon();
-	return 55
-end;
-
-proc _lexer_token_kind_hat();
-	return 56
-end;
-
-proc _lexer_token_kind_at();
-	return 57
-end;
-
-proc _lexer_token_kind_comment();
-	return 58
-end;
-
-proc _lexer_token_kind_string();
-	return 59
-end;
-
-proc _lexer_token_kind_character();
-	return 60
-end;
-
-proc _lexer_token_kind_integer();
-	return 61
-end;
-
-proc _lexer_token_kind_word();
-	return 62
-end;
-
-proc _lexer_token_kind_goto();
-	return 63
-end;
-
-proc _lexer_token_kind_eof();
-	return 64
-end;
-
 proc _lexer_compare_keyword(lhs_pointer: Word, lhs_length: Word, rhs_pointer: Word, rhs_length: Word);
 var
 	result: Word;
@@ -2703,39 +2565,39 @@ var
 	result: Word;
 	token_length: Word;
 begin
-	result := _lexer_token_kind_identifier();
-	token_length := position_end + -position_start;
+	result := LexerTokenKind.identifier;
+	token_length := position_end - position_start;
 
 	if _lexer_compare_keyword(position_start, token_length, "const", 5) = 1 then
-		result := _lexer_token_kind_const()
+		result := LexerTokenKind._const
 	elsif _lexer_compare_keyword(position_start, token_length, "var", 3) = 1 then
-		result := _lexer_token_kind_var()
+		result := LexerTokenKind._var
 	elsif _lexer_compare_keyword(position_start, token_length, "proc", 4) = 1 then
-		result := _lexer_token_kind_proc()
+		result := LexerTokenKind._proc
 	elsif _lexer_compare_keyword(position_start, token_length, "type", 4) = 1 then
-		result := _lexer_token_kind_type()
+		result := LexerTokenKind._type
 	elsif _lexer_compare_keyword(position_start, token_length, "begin", 5) = 1 then
-		result := _lexer_token_kind_begin()
+		result := LexerTokenKind._begin
 	elsif _lexer_compare_keyword(position_start, token_length, "end", 3) = 1 then
-		result := _lexer_token_kind_end()
+		result := LexerTokenKind._end
 	elsif _lexer_compare_keyword(position_start, token_length, "return", 6) = 1 then
-		result := _lexer_token_kind_return()
+		result := LexerTokenKind._return
 	elsif _lexer_compare_keyword(position_start, token_length, "goto", 4) = 1 then
-		result := _lexer_token_kind_goto()
+		result := LexerTokenKind._goto
 	elsif _lexer_compare_keyword(position_start, token_length, "if", 2) = 1 then
-		result := _lexer_token_kind_if()
+		result := LexerTokenKind._if
 	elsif _lexer_compare_keyword(position_start, token_length, "while", 5) = 1 then
-		result := _lexer_token_kind_while()
+		result := LexerTokenKind._while
 	elsif _lexer_compare_keyword(position_start, token_length, "then", 4) = 1 then
-		result := _lexer_token_kind_then()
+		result := LexerTokenKind._then
 	elsif _lexer_compare_keyword(position_start, token_length, "else", 4) = 1 then
-		result := _lexer_token_kind_else()
+		result := LexerTokenKind._else
 	elsif _lexer_compare_keyword(position_start, token_length, "elsif", 5) = 1 then
-		result := _lexer_token_kind_elsif()
+		result := LexerTokenKind._elsif
 	elsif _lexer_compare_keyword(position_start, token_length, "or", 2) = 1 then
-		result := _lexer_token_kind_or()
+		result := LexerTokenKind._or
 	elsif _lexer_compare_keyword(position_start, token_length, "xor", 2) = 1 then
-		result := _lexer_token_kind_xor()
+		result := LexerTokenKind._xor
 	end;
 	return result
 end;
@@ -2749,17 +2611,17 @@ begin
 	character := _load_byte(start_position);
 
 	if character = ':' then
-		result := _lexer_token_kind_colon()
+		result := LexerTokenKind.colon
 	elsif character = '.' then
-		result := _lexer_token_kind_dot()
+		result := LexerTokenKind.dot
 	elsif character = '(' then
-		result := _lexer_token_kind_left_paren()
+		result := LexerTokenKind.left_paren
 	elsif character = '-' then
-		result := _lexer_token_kind_minus()
+		result := LexerTokenKind.minus
 	elsif character = '<' then
-		result := _lexer_token_kind_less_than()
+		result := LexerTokenKind.less_than
 	elsif character = '>' then
-		result := _lexer_token_kind_greater_than()
+		result := LexerTokenKind.greater_than
 	end;
 	return result
 end;
@@ -2773,31 +2635,31 @@ begin
 	character := _load_byte(start_position);
 
 	if character = ';' then
-		result := _lexer_token_kind_semicolon()
+		result := LexerTokenKind.semicolon
 	elsif character = ',' then
-		result := _lexer_token_kind_comma()
+		result := LexerTokenKind.comma
 	elsif character = ')' then
-		result := _lexer_token_kind_right_paren()
+		result := LexerTokenKind.right_paren
 	elsif character = '@' then
-		result := _lexer_token_kind_at()
+		result := LexerTokenKind.at
 	elsif character = '~' then
-		result := _lexer_token_kind_not()
+		result := LexerTokenKind.not
 	elsif character = '&' then
-		result := _lexer_token_kind_and()
+		result := LexerTokenKind.and
 	elsif character = '+' then
-		result := _lexer_token_kind_plus()
+		result := LexerTokenKind.plus
 	elsif character = '*' then
-		result := _lexer_token_kind_multiplication()
+		result := LexerTokenKind.multiplication
 	elsif character = '=' then
-		result := _lexer_token_kind_equals()
+		result := LexerTokenKind.equals
 	elsif character = '%' then
-		result := _lexer_token_kind_remainder()
+		result := LexerTokenKind.remainder
 	elsif character = '/' then
-		result := _lexer_token_kind_division()
+		result := LexerTokenKind.division
 	elsif character = '.' then
-		result := _lexer_token_kind_dot()
+		result := LexerTokenKind.dot
 	elsif character = '^' then
-		result := _lexer_token_kind_hat()
+		result := LexerTokenKind.hat
 	end;
 	return result
 end;
@@ -2812,16 +2674,16 @@ begin
 	last_character := _load_byte(one_before_last);
 
 	if first_character = ':' then
-		result := _lexer_token_kind_assignment()
+		result := LexerTokenKind.assignment
 	elsif first_character = '<' then
 		if last_character = '=' then
-			result := _lexer_token_kind_less_equal()
+			result := LexerTokenKind.less_equal
 		elsif last_character = '>' then
-			result := _lexer_token_kind_not_equal()
+			result := LexerTokenKind.not_equal
 		end
 	elsif first_character = '>' then
 		if last_character = '=' then
-			result := _lexer_token_kind_greater_equal()
+			result := LexerTokenKind.greater_equal
 		end
 	end;
 
@@ -2834,22 +2696,22 @@ var
 	delimiter: Word;
 	result: Word;
 begin
-	token_length := end_position + -start_position;
+	token_length := end_position - start_position;
 	delimiter := _load_byte(start_position);
 
 	if delimiter = '(' then
-		result := _lexer_token_kind_comment()
+		result := LexerTokenKind.comment
 	elsif delimiter = '\'' then
-		result := _lexer_token_kind_character()
+		result := LexerTokenKind.character
 	elsif delimiter = '"' then
-		result := _lexer_token_kind_string()
+		result := LexerTokenKind.string
 	end;
 	return result
 end;
 
 proc _lexer_classify_integer(start_position: Word, end_position: Word);
 begin
-	return _lexer_token_kind_integer()
+	return LexerTokenKind.integer
 end;
 
 proc _lexer_execute_action(action_to_perform: Word, kind: Word);
@@ -2861,35 +2723,35 @@ begin
 	position_start := _lexer_global_get_start();
 	position_end := _lexer_global_get_end();
 
-	if action_to_perform = _lexer_action_none() then
-	elsif action_to_perform = _lexer_action_accumulate() then
+	if action_to_perform = LexerAction.none then
+	elsif action_to_perform = LexerAction.accumulate then
 		_lexer_global_set_end(position_end + 1)
-	elsif action_to_perform = _lexer_action_skip() then
+	elsif action_to_perform = LexerAction.skip then
 		_lexer_global_set_start(position_start + 1);
 		_lexer_global_set_end(position_end + 1)
-	elsif action_to_perform = _lexer_action_single() then
+	elsif action_to_perform = LexerAction.single then
 		_lexer_global_set_end(position_end + 1);
 
 		intermediate := _lexer_classify_single(position_start);
 		_store_word(intermediate, kind)
-	elsif action_to_perform = _lexer_action_eof() then
-		intermediate := _lexer_token_kind_eof();
+	elsif action_to_perform = LexerAction.eof then
+		intermediate := LexerTokenKind.eof;
 		_store_word(intermediate, kind)
-	elsif action_to_perform = _lexer_action_finalize() then
+	elsif action_to_perform = LexerAction.finalize then
 		intermediate := _lexer_classify_finalize(position_start);
 		_store_word(intermediate, kind)
-	elsif action_to_perform = _lexer_action_composite() then
+	elsif action_to_perform = LexerAction.composite then
 		_lexer_global_set_end(position_end + 1);
 
 		intermediate := _lexer_classify_composite(position_start, position_end);
 		_store_word(intermediate, kind)
-	elsif action_to_perform = _lexer_action_key_id() then
+	elsif action_to_perform = LexerAction.key_id then
 		intermediate := _lexer_classify_keyword(position_start, position_end);
 		_store_word(intermediate, kind)
-	elsif action_to_perform = _lexer_action_integer() then
+	elsif action_to_perform = LexerAction.integer then
 		intermediate := _lexer_classify_integer(position_start, position_end);
 		_store_word(intermediate, kind)
-	elsif action_to_perform = _lexer_action_delimited() then
+	elsif action_to_perform = LexerAction.delimited then
 		_lexer_global_set_end(position_end + 1);
 
 		intermediate := _lexer_classify_delimited(position_start, position_end + 1);
@@ -2918,7 +2780,7 @@ end;
 
 proc _lexer_advance_token(kind: Word);
 begin
-	if _lexer_execute_transition(kind) <> _lexer_state_end() then
+	if _lexer_execute_transition(kind) <> LexerState.finish then
 		_lexer_advance_token(kind)
 	end
 end;
@@ -2962,7 +2824,7 @@ begin
 	last_read := _read_file(offset, 81920);
 	if last_read > 0 then
 		offset := offset + last_read;
-		goto .start_read
+		goto start_read
 	end;
 	_compile();