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..0f8e0c8 100644 --- a/boot/stage15.elna +++ b/boot/stage15.elna @@ -4,12 +4,63 @@ * 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 + ); const symbol_builtin_name_int := "Int"; @@ -416,9 +467,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 +801,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 +1147,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(); @@ -1057,12 +1164,7 @@ begin (* 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(' '); 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() @@ -1109,6 +1211,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. @@ -1432,11 +1552,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; @@ -1727,212 +1856,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. * @@ -1970,140 +1893,140 @@ 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 @@ -2158,28 +2081,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 +2116,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; (** @@ -2391,7 +2314,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) @@ -2861,35 +2784,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 + elsif action_to_perform = LexerAction.eof then intermediate := _lexer_token_kind_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 +2841,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;