Implement enumeration
This commit is contained in:
@@ -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;
|
||||
|
||||
@@ -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;
|
||||
|
||||
Reference in New Issue
Block a user