raphael/minishell
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

changed grammar

Browse source
This commit is contained in:
Maieul BOYER 2024-07-01 18:36:14 +02:00
parent 0b5b5e4d7e
commit e5b22489e1
No known key found for this signature in database
1219 changed files with 96283 additions and 113028 deletions
Download patch file Download diff file Expand all files Collapse all files

27
ast/include/ast/ast_raw_structs.h
View file

@ -60,14 +60,17 @@ enum e_ast_expansion_operator
enum e_ast_redirection_kind
{
AST_REDIR_INPUT, // <
AST_REDIR_OUTPUT, // >
AST_REDIR_APPEND, // >>
AST_REDIR_HEREDOC, // <<
AST_REDIR_HEREDOC_INDENT, // <<-
AST_REDIR_DUP_INPUT, // <&
AST_REDIR_DUP_OUTPUT, // >&
AST_REDIR_DUP_ERROR, // &>
AST_REDIR_INPUT, // <
AST_REDIR_OUTPUT, // >
AST_REDIR_APPEND, // >>
AST_REDIR_HEREDOC, // <<
AST_REDIR_HEREDOC_INDENT, // <<-
AST_REDIR_DUP_INPUT, // <&
AST_REDIR_DUP_OUTPUT, // >&
AST_REDIR_OUTPUT_CLOBBER, // >|
AST_REDIR_INPUT_OUTPUT, // <>
AST_REDIR_CLOSE_INPUT, // <&
AST_REDIR_CLOSE_OUTPUT, // >&
};
struct s_ast_empty
@ -317,9 +320,9 @@ struct s_ast_variable_assignment
/// ```
struct s_ast_file_redirection
{
t_ast_node output;
t_ast_node output;
t_ast_redirection_kind op;
t_ast_node input;
t_str input;
};
/// File Redirection
@ -330,9 +333,9 @@ struct s_ast_file_redirection
/// ```
struct s_ast_heredoc_redirection
{
t_ast_node output;
t_ast_node output;
t_ast_redirection_kind op;
t_ast_node delimiter;
t_ast_node delimiter;
};
/// Variable Expension

110
ast/src/from_node.c
View file

@ -128,7 +128,7 @@ void ast_free(t_ast_node elem)
}
if (elem->kind == AST_FILE_REDIRECTION)
{
ast_free(elem->data.file_redirection.input);
mem_free(elem->data.file_redirection.input);
ast_free(elem->data.file_redirection.output);
}
if (elem->kind == AST_FOR)
@ -467,7 +467,7 @@ t_ast_terminator_kind _select_term(t_parse_node node)
{
t_symbol symbol;
symbol = ts_node_grammar_symbol(node);
symbol = ts_node_grammar_symbol(ts_node_child(node, 0));
if (symbol == anon_sym_AMP)
return (AST_TERM_FORK);
if (symbol == anon_sym_SEMI)
@ -478,6 +478,44 @@ t_ast_terminator_kind _select_term(t_parse_node node)
return (AST_TERM_NONE);
}
t_str _extract_str(t_parse_node self, t_const_str input)
{
t_usize start;
t_usize end;
t_str result;
start = ts_node_start_byte(self);
end = ts_node_end_byte(self);
result = str_substring(input, start, end - start);
return (result);
}
t_ast_redirection_kind _get_redirection_op(t_parse_node self)
{
t_symbol symbol;
symbol = ts_node_grammar_symbol(self);
if (symbol == anon_sym_LT)
return (AST_REDIR_INPUT);
if (symbol == anon_sym_GT)
return (AST_REDIR_OUTPUT);
if (symbol == anon_sym_GT_GT)
return (AST_REDIR_APPEND);
if (symbol == anon_sym_LT_LT)
return (AST_REDIR_HEREDOC);
if (symbol == anon_sym_LT_LT_DASH)
return (AST_REDIR_HEREDOC_INDENT);
if (symbol == anon_sym_LT_AMP)
return (AST_REDIR_DUP_INPUT);
if (symbol == anon_sym_GT_AMP)
return (AST_REDIR_DUP_OUTPUT);
if (symbol == anon_sym_GT_PIPE)
return (AST_REDIR_OUTPUT_CLOBBER);
if (symbol == anon_sym_LT_GT)
return (AST_REDIR_INPUT_OUTPUT);
return (me_abort("invalid redirection symbol"), 0);
}
t_error ast_from_node(t_parse_node node, t_const_str input, t_ast_node *out);
/* FUNCTION THAT ARE DONE */
@ -537,6 +575,45 @@ t_error build_sym_heredoc_start(t_parse_node self, t_const_str input, t_ast_node
#include <stdio.h>
t_error build_sym_file_redirect(t_parse_node self, t_const_str input, t_ast_node *out)
{
t_ast_node ret;
t_ast_node tmp;
t_usize i;
(void)(out);
(void)(input);
(void)(self);
if (out == NULL)
return (ERROR);
if (ts_node_symbol(self) != sym_file_redirect)
return (ERROR);
ret = ast_alloc(AST_FILE_REDIRECTION);
i = 0;
while (i < ts_node_child_count(self))
{
if (!ts_node_is_named(ts_node_child(self, i)) && (i++, true))
continue;
if (ts_node_field_id_for_child(self, i) == field_fd)
{
ret->data.file_redirection.input = _extract_str(ts_node_child(self, i), input);
}
if (ts_node_field_id_for_child(self, i) == field_op)
{
ret->data.file_redirection.op = _get_redirection_op(ts_node_child(self, i));
}
if (ts_node_field_id_for_child(self, i) == field_dest)
{
if (ast_from_node(ts_node_child(self, i), input, &tmp))
return (ast_free(ret), ERROR);
ret->data.file_redirection.output = tmp;
}
i++;
}
return (*out = ret, NO_ERROR);
}
t_error build_sym_regex(t_parse_node self, t_const_str input, t_ast_node *out)
{
t_ast_node ret;
@ -549,7 +626,7 @@ t_error build_sym_regex(t_parse_node self, t_const_str input, t_ast_node *out)
if (ts_node_symbol(self) != sym_regex)
return (ERROR);
ret = ast_alloc(AST_REGEX);
ret->data.regex.pattern = str_substring(input, ts_node_start_byte(self), ts_node_end_byte(self) - ts_node_start_byte(self));
ret->data.regex.pattern = _extract_str(self, input);
return (*out = ret, NO_ERROR);
}
@ -565,7 +642,7 @@ t_error build_sym_extglob_pattern(t_parse_node self, t_const_str input, t_ast_no
if (ts_node_symbol(self) != sym_extglob_pattern)
return (ERROR);
ret = ast_alloc(AST_EXTGLOB);
ret->data.extglob.pattern = str_substring(input, ts_node_start_byte(self), ts_node_end_byte(self) - ts_node_start_byte(self));
ret->data.extglob.pattern = _extract_str(self, input);
return (*out = ret, NO_ERROR);
}
@ -590,9 +667,7 @@ t_error build_sym_function_definition(t_parse_node self, t_const_str input, t_as
continue;
if (ts_node_field_id_for_child(self, i) == field_name)
{
ret->data.function_definition.name =
str_substring(input, ts_node_start_byte(ts_node_child(self, i)),
ts_node_end_byte(ts_node_child(self, i)) - ts_node_start_byte(ts_node_child(self, i)));
ret->data.function_definition.name = _extract_str(ts_node_child(self, i), input);
}
if (ts_node_field_id_for_child(self, i) == field_body)
{
@ -833,10 +908,9 @@ t_error build_sym_else_clause(t_parse_node self, t_const_str input, t_ast_node *
t_error build_sym_for_statement(t_parse_node self, t_const_str input, t_ast_node *out)
{
t_ast_node ret;
t_ast_node tmp;
t_parse_node temp_ast;
t_usize i;
t_ast_node ret;
t_ast_node tmp;
t_usize i;
(void)(out);
(void)(input);
@ -853,9 +927,7 @@ t_error build_sym_for_statement(t_parse_node self, t_const_str input, t_ast_node
continue;
if (ts_node_field_id_for_child(self, i) == field_variable)
{
temp_ast = ts_node_child(self, i);
ret->data.for_.var_name =
str_substring(input, ts_node_start_byte(temp_ast), ts_node_end_byte(temp_ast) - ts_node_start_byte(temp_ast));
ret->data.for_.var_name = _extract_str(ts_node_child(self, i), input);
}
if (ts_node_field_id_for_child(self, i) == field_value)
{
@ -1146,14 +1218,12 @@ t_error build_sym_variable_assignment(t_parse_node self, t_const_str input, t_as
if (ts_node_symbol(self) != sym_variable_assignment)
return (ERROR);
ret = ast_alloc(AST_VARIABLE_ASSIGNMENT);
// temp_str = str_substring(input, ts_node_start_byte(self), ts_node_end_byte(self) - ts_node_start_byte(self));
if (ts_node_child_count(self) >= 2)
{
temp_ast = ts_node_child(self, 0);
if (ts_node_symbol(temp_ast) != sym_variable_name)
return (ast_free(ret), ERROR);
ret->data.variable_assignment.name =
str_substring(input, ts_node_start_byte(temp_ast), ts_node_end_byte(temp_ast) - ts_node_start_byte(temp_ast));
ret->data.variable_assignment.name = _extract_str(temp_ast, input);
}
if (ts_node_child_count(self) > 2)
{
@ -1228,7 +1298,7 @@ t_error build_sym_string_content(t_parse_node self, t_const_str input, t_ast_nod
if (ts_node_symbol(self) != sym_string_content)
return (ERROR);
ret = ast_alloc(AST_RAW_STRING);
temp_str = str_substring(input, ts_node_start_byte(self), ts_node_end_byte(self) - ts_node_start_byte(self));
temp_str = _extract_str(self, input);
ret->data.raw_string.str = temp_str;
ret->data.raw_string.len = str_len(temp_str);
return (*out = ret, NO_ERROR);
@ -1246,7 +1316,7 @@ t_error build_sym_raw_string(t_parse_node self, t_const_str input, t_ast_node *o
return (ERROR);
ret = ast_alloc(AST_WORD);
temp = ast_alloc(AST_RAW_STRING);
temp_str = str_substring(input, ts_node_start_byte(self), ts_node_end_byte(self) - ts_node_start_byte(self));
temp_str = _extract_str(self, input);
temp->data.raw_string.str = temp_str;
temp->data.raw_string.len = str_len(temp_str);
ret->data.word.kind = AST_WORD_SINGLE_QUOTE;
@ -1309,7 +1379,7 @@ t_error build_sym_word(t_parse_node self, t_const_str input, t_ast_node *out)
ret = ast_alloc(AST_WORD);
ret->data.word.kind = AST_WORD_NO_QUOTE;
temp = ast_alloc(AST_RAW_STRING);
temp_str = str_substring(input, ts_node_start_byte(self), ts_node_end_byte(self) - ts_node_start_byte(self));
temp_str = _extract_str(self, input);
temp->data.raw_string.str = temp_str;
temp->data.raw_string.len = str_len(temp_str);
vec_ast_push(&ret->data.word.inner, temp);

115
parser/Filelist.mk
View file

@ -141,8 +141,6 @@ lex_funcs/lex_normal/state_95 \
lex_funcs/lex_normal/state_96 \
lex_funcs/lex_normal/state_97 \
lex_funcs/lex_normal/state_98 \
lex_funcs/lex_normal/state_99 \
lex_funcs/lex_normal/state_100 \
lex_modes/lex_modes_0 \
lex_modes/lex_modes_1 \
lex_modes/lex_modes_2 \
@ -165,8 +163,6 @@ lex_modes/lex_modes_18 \
lex_modes/lex_modes_19 \
lex_modes/lex_modes_20 \
lex_modes/lex_modes_21 \
lex_modes/lex_modes_22 \
lex_modes/lex_modes_23 \
non_terminal_alias_map/non_terminal_alias_map_0 \
parse_actions_entries/parse_actions_entries_0 \
parse_actions_entries/parse_actions_entries_1 \
@ -210,10 +206,6 @@ parse_actions_entries/parse_actions_entries_38 \
parse_actions_entries/parse_actions_entries_39 \
parse_actions_entries/parse_actions_entries_40 \
parse_actions_entries/parse_actions_entries_41 \
parse_actions_entries/parse_actions_entries_42 \
parse_actions_entries/parse_actions_entries_43 \
parse_actions_entries/parse_actions_entries_44 \
parse_actions_entries/parse_actions_entries_45 \
parse_table/parse_table_0 \
parse_table/parse_table_1 \
primary_state_ids/primary_state_ids_0 \
@ -238,8 +230,6 @@ primary_state_ids/primary_state_ids_18 \
primary_state_ids/primary_state_ids_19 \
primary_state_ids/primary_state_ids_20 \
primary_state_ids/primary_state_ids_21 \
primary_state_ids/primary_state_ids_22 \
primary_state_ids/primary_state_ids_23 \
small_parse_table/small_parse_table_0 \
small_parse_table/small_parse_table_1 \
small_parse_table/small_parse_table_2 \
@ -1077,109 +1067,6 @@ small_parse_table/small_parse_table_833 \
small_parse_table/small_parse_table_834 \
small_parse_table/small_parse_table_835 \
small_parse_table/small_parse_table_836 \
small_parse_table/small_parse_table_837 \
small_parse_table/small_parse_table_838 \
small_parse_table/small_parse_table_839 \
small_parse_table/small_parse_table_840 \
small_parse_table/small_parse_table_841 \
small_parse_table/small_parse_table_842 \
small_parse_table/small_parse_table_843 \
small_parse_table/small_parse_table_844 \
small_parse_table/small_parse_table_845 \
small_parse_table/small_parse_table_846 \
small_parse_table/small_parse_table_847 \
small_parse_table/small_parse_table_848 \
small_parse_table/small_parse_table_849 \
small_parse_table/small_parse_table_850 \
small_parse_table/small_parse_table_851 \
small_parse_table/small_parse_table_852 \
small_parse_table/small_parse_table_853 \
small_parse_table/small_parse_table_854 \
small_parse_table/small_parse_table_855 \
small_parse_table/small_parse_table_856 \
small_parse_table/small_parse_table_857 \
small_parse_table/small_parse_table_858 \
small_parse_table/small_parse_table_859 \
small_parse_table/small_parse_table_860 \
small_parse_table/small_parse_table_861 \
small_parse_table/small_parse_table_862 \
small_parse_table/small_parse_table_863 \
small_parse_table/small_parse_table_864 \
small_parse_table/small_parse_table_865 \
small_parse_table/small_parse_table_866 \
small_parse_table/small_parse_table_867 \
small_parse_table/small_parse_table_868 \
small_parse_table/small_parse_table_869 \
small_parse_table/small_parse_table_870 \
small_parse_table/small_parse_table_871 \
small_parse_table/small_parse_table_872 \
small_parse_table/small_parse_table_873 \
small_parse_table/small_parse_table_874 \
small_parse_table/small_parse_table_875 \
small_parse_table/small_parse_table_876 \
small_parse_table/small_parse_table_877 \
small_parse_table/small_parse_table_878 \
small_parse_table/small_parse_table_879 \
small_parse_table/small_parse_table_880 \
small_parse_table/small_parse_table_881 \
small_parse_table/small_parse_table_882 \
small_parse_table/small_parse_table_883 \
small_parse_table/small_parse_table_884 \
small_parse_table/small_parse_table_885 \
small_parse_table/small_parse_table_886 \
small_parse_table/small_parse_table_887 \
small_parse_table/small_parse_table_888 \
small_parse_table/small_parse_table_889 \
small_parse_table/small_parse_table_890 \
small_parse_table/small_parse_table_891 \
small_parse_table/small_parse_table_892 \
small_parse_table/small_parse_table_893 \
small_parse_table/small_parse_table_894 \
small_parse_table/small_parse_table_895 \
small_parse_table/small_parse_table_896 \
small_parse_table/small_parse_table_897 \
small_parse_table/small_parse_table_898 \
small_parse_table/small_parse_table_899 \
small_parse_table/small_parse_table_900 \
small_parse_table/small_parse_table_901 \
small_parse_table/small_parse_table_902 \
small_parse_table/small_parse_table_903 \
small_parse_table/small_parse_table_904 \
small_parse_table/small_parse_table_905 \
small_parse_table/small_parse_table_906 \
small_parse_table/small_parse_table_907 \
small_parse_table/small_parse_table_908 \
small_parse_table/small_parse_table_909 \
small_parse_table/small_parse_table_910 \
small_parse_table/small_parse_table_911 \
small_parse_table/small_parse_table_912 \
small_parse_table/small_parse_table_913 \
small_parse_table/small_parse_table_914 \
small_parse_table/small_parse_table_915 \
small_parse_table/small_parse_table_916 \
small_parse_table/small_parse_table_917 \
small_parse_table/small_parse_table_918 \
small_parse_table/small_parse_table_919 \
small_parse_table/small_parse_table_920 \
small_parse_table/small_parse_table_921 \
small_parse_table/small_parse_table_922 \
small_parse_table/small_parse_table_923 \
small_parse_table/small_parse_table_924 \
small_parse_table/small_parse_table_925 \
small_parse_table/small_parse_table_926 \
small_parse_table/small_parse_table_927 \
small_parse_table/small_parse_table_928 \
small_parse_table/small_parse_table_929 \
small_parse_table/small_parse_table_930 \
small_parse_table/small_parse_table_931 \
small_parse_table/small_parse_table_932 \
small_parse_table/small_parse_table_933 \
small_parse_table/small_parse_table_934 \
small_parse_table/small_parse_table_935 \
small_parse_table/small_parse_table_936 \
small_parse_table/small_parse_table_937 \
small_parse_table/small_parse_table_938 \
small_parse_table/small_parse_table_939 \
small_parse_table_map/small_parse_table_map_0 \
small_parse_table_map/small_parse_table_map_1 \
small_parse_table_map/small_parse_table_map_2 \
@ -1202,8 +1089,6 @@ small_parse_table_map/small_parse_table_map_18 \
small_parse_table_map/small_parse_table_map_19 \
small_parse_table_map/small_parse_table_map_20 \
small_parse_table_map/small_parse_table_map_21 \
small_parse_table_map/small_parse_table_map_22 \
small_parse_table_map/small_parse_table_map_23 \
symbols_metadata/symbols_metadata_0 \
symbols_metadata/symbols_metadata_1 \
symbols_names/symbols_names_0 \

5478
parser/src/lex.c
View file

File diff suppressed because it is too large Load diff

34
parser/static/alias_sequences/alias_sequences_0.c
View file

@ -14,33 +14,33 @@
void alias_sequences_0(t_alias_sequences_array *v)
{
v->a[8][1] = anon_sym_POUND;
v->a[9][0] = anon_sym_POUND;
v->a[12][0] = anon_sym_DOLLAR;
v->a[23][0] = sym__immediate_double_hash;
v->a[25][1] = sym_string_content;
v->a[27][0] = anon_sym_POUND;
v->a[35][1] = alias_sym_statements;
v->a[38][1] = sym__immediate_double_hash;
v->a[39][2] = sym_string_content;
v->a[40][3] = sym_word;
v->a[41][0] = sym_regex;
v->a[6][1] = anon_sym_POUND;
v->a[7][0] = anon_sym_POUND;
v->a[10][0] = anon_sym_DOLLAR;
v->a[21][0] = sym__immediate_double_hash;
v->a[23][1] = sym_string_content;
v->a[26][0] = anon_sym_POUND;
v->a[34][1] = alias_sym_statements;
v->a[37][1] = sym__immediate_double_hash;
v->a[38][2] = sym_string_content;
v->a[39][3] = sym_word;
v->a[40][0] = sym_regex;
v->a[42][1] = alias_sym_statements;
v->a[43][1] = alias_sym_statements;
v->a[43][3] = alias_sym_statements;
v->a[44][1] = alias_sym_statements;
v->a[44][3] = alias_sym_statements;
v->a[45][1] = alias_sym_statements;
v->a[46][1] = alias_sym_statements;
v->a[50][1] = alias_sym_statements;
v->a[50][3] = alias_sym_statements;
v->a[51][1] = alias_sym_statements;
v->a[51][3] = alias_sym_statements;
v->a[52][1] = alias_sym_statements;
v->a[52][3] = alias_sym_statements;
alias_sequences_1(v);
}
void alias_sequences_1(t_alias_sequences_array *v)
{
v->a[53][1] = alias_sym_statements;
v->a[54][2] = alias_sym_statements;
v->a[52][1] = alias_sym_statements;
v->a[53][2] = alias_sym_statements;
v->a[62][1] = alias_sym_statements;
v->a[62][3] = alias_sym_statements;
v->a[63][3] = alias_sym_statements;

18
parser/static/external_scanner_states/external_scanner_states_0.c
View file

@ -48,6 +48,7 @@ void external_scanner_states_1(t_external_scanner_states_array *v)
v->a[3][ts_external_token_LT_LT_DASH] = true;
v->a[3][ts_external_token_heredoc_redirect_token1] = true;
v->a[3][ts_external_token_LPAREN] = true;
v->a[3][ts_external_token_esac] = true;
v->a[4][ts_external_token_file_descriptor] = true;
v->a[4][ts_external_token_variable_name] = true;
v->a[4][ts_external_token__bare_dollar] = true;
@ -55,7 +56,6 @@ void external_scanner_states_1(t_external_scanner_states_array *v)
v->a[4][ts_external_token_LT_LT_DASH] = true;
v->a[4][ts_external_token_heredoc_redirect_token1] = true;
v->a[4][ts_external_token_LPAREN] = true;
v->a[4][ts_external_token_esac] = true;
v->a[5][ts_external_token_file_descriptor] = true;
v->a[5][ts_external_token_variable_name] = true;
v->a[5][ts_external_token__bare_dollar] = true;
@ -67,29 +67,29 @@ void external_scanner_states_2(t_external_scanner_states_array *v)
v->a[5][ts_external_token_LT_LT] = true;
v->a[5][ts_external_token_LT_LT_DASH] = true;
v->a[5][ts_external_token_heredoc_redirect_token1] = true;
v->a[5][ts_external_token_esac] = true;
v->a[6][ts_external_token_file_descriptor] = true;
v->a[6][ts_external_token_variable_name] = true;
v->a[6][ts_external_token__bare_dollar] = true;
v->a[6][ts_external_token_LT_LT] = true;
v->a[6][ts_external_token_LT_LT_DASH] = true;
v->a[6][ts_external_token_heredoc_redirect_token1] = true;
v->a[6][ts_external_token_esac] = true;
v->a[7][ts_external_token_file_descriptor] = true;
v->a[7][ts_external_token_variable_name] = true;
v->a[7][ts_external_token_LT_LT] = true;
v->a[7][ts_external_token_LT_LT_DASH] = true;
v->a[7][ts_external_token_heredoc_redirect_token1] = true;
v->a[7][ts_external_token_esac] = true;
v->a[8][ts_external_token_file_descriptor] = true;
v->a[8][ts_external_token_variable_name] = true;
v->a[8][ts_external_token_LT_LT] = true;
v->a[8][ts_external_token_LT_LT_DASH] = true;
v->a[8][ts_external_token_heredoc_redirect_token1] = true;
external_scanner_states_3(v);
}
void external_scanner_states_3(t_external_scanner_states_array *v)
{
v->a[8][ts_external_token_esac] = true;
v->a[8][ts_external_token_heredoc_redirect_token1] = true;
v->a[9][ts_external_token_file_descriptor] = true;
v->a[9][ts_external_token__bare_dollar] = true;
v->a[9][ts_external_token_LT_LT] = true;
@ -108,32 +108,32 @@ void external_scanner_states_3(t_external_scanner_states_array *v)
v->a[11][ts_external_token_LT_LT] = true;
v->a[11][ts_external_token_LT_LT_DASH] = true;
v->a[11][ts_external_token_heredoc_redirect_token1] = true;
v->a[11][ts_external_token_esac] = true;
v->a[12][ts_external_token_file_descriptor] = true;
external_scanner_states_4(v);
}
void external_scanner_states_4(t_external_scanner_states_array *v)
{
v->a[12][ts_external_token_file_descriptor] = true;
v->a[12][ts_external_token__bare_dollar] = true;
v->a[12][ts_external_token_LT_LT] = true;
v->a[12][ts_external_token_LT_LT_DASH] = true;
v->a[12][ts_external_token_heredoc_redirect_token1] = true;
v->a[12][ts_external_token_esac] = true;
v->a[13][ts_external_token_file_descriptor] = true;
v->a[13][ts_external_token_variable_name] = true;
v->a[13][ts_external_token__bare_dollar] = true;
v->a[13][ts_external_token_LT_LT] = true;
v->a[13][ts_external_token_LT_LT_DASH] = true;
v->a[13][ts_external_token_LPAREN] = true;
v->a[14][ts_external_token_file_descriptor] = true;
v->a[14][ts_external_token_LT_LT] = true;
v->a[14][ts_external_token_LT_LT_DASH] = true;
v->a[14][ts_external_token_heredoc_redirect_token1] = true;
v->a[15][ts_external_token_file_descriptor] = true;
v->a[15][ts_external_token_LT_LT] = true;
v->a[15][ts_external_token_LT_LT_DASH] = true;
v->a[15][ts_external_token_heredoc_redirect_token1] = true;
v->a[15][ts_external_token_esac] = true;
v->a[16][ts_external_token_file_descriptor] = true;
v->a[16][ts_external_token_LT_LT] = true;
v->a[16][ts_external_token_LT_LT_DASH] = true;
external_scanner_states_5(v);
}

70
parser/static/external_scanner_states/external_scanner_states_1.c
View file

@ -14,97 +14,97 @@
void external_scanner_states_5(t_external_scanner_states_array *v)
{
v->a[16][ts_external_token_file_descriptor] = true;
v->a[16][ts_external_token_variable_name] = true;
v->a[16][ts_external_token__bare_dollar] = true;
v->a[16][ts_external_token_LT_LT] = true;
v->a[16][ts_external_token_LT_LT_DASH] = true;
v->a[16][ts_external_token_heredoc_redirect_token1] = true;
v->a[17][ts_external_token_file_descriptor] = true;
v->a[17][ts_external_token_variable_name] = true;
v->a[17][ts_external_token__bare_dollar] = true;
v->a[17][ts_external_token_LT_LT] = true;
v->a[17][ts_external_token_LT_LT_DASH] = true;
v->a[18][ts_external_token_file_descriptor] = true;
v->a[18][ts_external_token_variable_name] = true;
v->a[18][ts_external_token_LT_LT] = true;
v->a[18][ts_external_token_LT_LT_DASH] = true;
v->a[19][ts_external_token_file_descriptor] = true;
v->a[19][ts_external_token__concat] = true;
v->a[19][ts_external_token__bare_dollar] = true;
v->a[19][ts_external_token_LT_LT] = true;
v->a[19][ts_external_token_LT_LT_DASH] = true;
v->a[19][ts_external_token_heredoc_redirect_token1] = true;
v->a[19][ts_external_token_LPAREN] = true;
v->a[20][ts_external_token_file_descriptor] = true;
v->a[20][ts_external_token__concat] = true;
v->a[20][ts_external_token__bare_dollar] = true;
v->a[20][ts_external_token_LT_LT] = true;
v->a[20][ts_external_token_LT_LT_DASH] = true;
v->a[20][ts_external_token_heredoc_redirect_token1] = true;
v->a[20][ts_external_token_LPAREN] = true;
v->a[21][ts_external_token_file_descriptor] = true;
external_scanner_states_6(v);
}
void external_scanner_states_6(t_external_scanner_states_array *v)
{
v->a[21][ts_external_token__concat] = true;
v->a[21][ts_external_token__bare_dollar] = true;
v->a[21][ts_external_token_LT_LT] = true;
v->a[21][ts_external_token_LT_LT_DASH] = true;
v->a[21][ts_external_token_heredoc_redirect_token1] = true;
v->a[21][ts_external_token_LPAREN] = true;
v->a[21][ts_external_token_esac] = true;
v->a[22][ts_external_token_file_descriptor] = true;
v->a[22][ts_external_token__concat] = true;
v->a[22][ts_external_token__bare_dollar] = true;
v->a[22][ts_external_token_LT_LT] = true;
v->a[22][ts_external_token_LT_LT_DASH] = true;
v->a[22][ts_external_token_heredoc_redirect_token1] = true;
v->a[22][ts_external_token_LPAREN] = true;
v->a[22][ts_external_token_esac] = true;
v->a[23][ts_external_token_file_descriptor] = true;
v->a[23][ts_external_token__concat] = true;
v->a[23][ts_external_token_variable_name] = true;
v->a[23][ts_external_token__bare_dollar] = true;
v->a[23][ts_external_token_LT_LT] = true;
v->a[23][ts_external_token_LT_LT_DASH] = true;
v->a[23][ts_external_token_heredoc_redirect_token1] = true;
v->a[24][ts_external_token_file_descriptor] = true;
v->a[24][ts_external_token__concat] = true;
v->a[24][ts_external_token_variable_name] = true;
external_scanner_states_7(v);
}
void external_scanner_states_7(t_external_scanner_states_array *v)
{
v->a[24][ts_external_token_variable_name] = true;
v->a[24][ts_external_token_LT_LT] = true;
v->a[24][ts_external_token_LT_LT_DASH] = true;
v->a[24][ts_external_token_heredoc_redirect_token1] = true;
v->a[24][ts_external_token_esac] = true;
v->a[25][ts_external_token_file_descriptor] = true;
v->a[25][ts_external_token__concat] = true;
v->a[25][ts_external_token__bare_dollar] = true;
v->a[25][ts_external_token_variable_name] = true;
v->a[25][ts_external_token_LT_LT] = true;
v->a[25][ts_external_token_LT_LT_DASH] = true;
v->a[25][ts_external_token_heredoc_redirect_token1] = true;
v->a[25][ts_external_token_esac] = true;
v->a[26][ts_external_token_file_descriptor] = true;
v->a[26][ts_external_token__concat] = true;
v->a[26][ts_external_token__bare_dollar] = true;
v->a[26][ts_external_token_variable_name] = true;
v->a[26][ts_external_token_LT_LT] = true;
v->a[26][ts_external_token_LT_LT_DASH] = true;
v->a[26][ts_external_token_heredoc_redirect_token1] = true;
v->a[26][ts_external_token_esac] = true;
v->a[27][ts_external_token_file_descriptor] = true;
v->a[27][ts_external_token_variable_name] = true;
v->a[27][ts_external_token__concat] = true;
v->a[27][ts_external_token__bare_dollar] = true;
v->a[27][ts_external_token_LT_LT] = true;
v->a[27][ts_external_token_LT_LT_DASH] = true;
v->a[27][ts_external_token_heredoc_redirect_token1] = true;
external_scanner_states_8(v);
}
void external_scanner_states_8(t_external_scanner_states_array *v)
{
v->a[27][ts_external_token_heredoc_redirect_token1] = true;
v->a[27][ts_external_token_esac] = true;
v->a[28][ts_external_token_file_descriptor] = true;
v->a[28][ts_external_token__concat] = true;
v->a[28][ts_external_token__bare_dollar] = true;
v->a[28][ts_external_token_LT_LT] = true;
v->a[28][ts_external_token_LT_LT_DASH] = true;
v->a[28][ts_external_token_heredoc_redirect_token1] = true;
v->a[29][ts_external_token_file_descriptor] = true;
v->a[29][ts_external_token__bare_dollar] = true;
v->a[29][ts_external_token__concat] = true;
v->a[29][ts_external_token_LT_LT] = true;
v->a[29][ts_external_token_LT_LT_DASH] = true;
v->a[29][ts_external_token_heredoc_redirect_token1] = true;
v->a[29][ts_external_token_esac] = true;
v->a[30][ts_external_token_file_descriptor] = true;
v->a[30][ts_external_token__concat] = true;
v->a[30][ts_external_token_LT_LT] = true;
v->a[30][ts_external_token_LT_LT_DASH] = true;
v->a[30][ts_external_token_heredoc_redirect_token1] = true;
v->a[30][ts_external_token_esac] = true;
v->a[31][ts_external_token_file_descriptor] = true;
v->a[31][ts_external_token_LT_LT] = true;
v->a[31][ts_external_token_LT_LT_DASH] = true;
@ -119,13 +119,13 @@ void external_scanner_states_9(t_external_scanner_states_array *v)
v->a[33][ts_external_token_variable_name] = true;
v->a[33][ts_external_token_LPAREN] = true;
v->a[33][ts_external_token_esac] = true;
v->a[34][ts_external_token_file_descriptor] = true;
v->a[34][ts_external_token__concat] = true;
v->a[34][ts_external_token__bare_dollar] = true;
v->a[34][ts_external_token_LT_LT] = true;
v->a[34][ts_external_token_LT_LT_DASH] = true;
v->a[34][ts_external_token_variable_name] = true;
v->a[34][ts_external_token_LPAREN] = true;
v->a[35][ts_external_token_variable_name] = true;
v->a[35][ts_external_token_file_descriptor] = true;
v->a[35][ts_external_token__concat] = true;
v->a[35][ts_external_token__bare_dollar] = true;
v->a[35][ts_external_token_LT_LT] = true;
v->a[35][ts_external_token_LT_LT_DASH] = true;
v->a[35][ts_external_token_LPAREN] = true;
v->a[36][ts_external_token_extglob_pattern] = true;
v->a[36][ts_external_token_heredoc_redirect_token1] = true;
@ -133,7 +133,7 @@ void external_scanner_states_9(t_external_scanner_states_array *v)
v->a[36][ts_external_token_esac] = true;
v->a[37][ts_external_token_file_descriptor] = true;
v->a[37][ts_external_token__concat] = true;
v->a[37][ts_external_token_variable_name] = true;
v->a[37][ts_external_token__bare_dollar] = true;
external_scanner_states_10(v);
}

20
parser/static/external_scanner_states/external_scanner_states_2.c
View file

@ -18,32 +18,32 @@ void external_scanner_states_10(t_external_scanner_states_array *v)
v->a[37][ts_external_token_LT_LT_DASH] = true;
v->a[38][ts_external_token_file_descriptor] = true;
v->a[38][ts_external_token__concat] = true;
v->a[38][ts_external_token__bare_dollar] = true;
v->a[38][ts_external_token_variable_name] = true;
v->a[38][ts_external_token_LT_LT] = true;
v->a[38][ts_external_token_LT_LT_DASH] = true;
v->a[39][ts_external_token_file_descriptor] = true;
v->a[39][ts_external_token__concat] = true;
v->a[39][ts_external_token_LT_LT] = true;
v->a[39][ts_external_token_LT_LT_DASH] = true;
v->a[40][ts_external_token_file_descriptor] = true;
v->a[40][ts_external_token__concat] = true;
v->a[40][ts_external_token_variable_name] = true;
v->a[40][ts_external_token_heredoc_redirect_token1] = true;
v->a[41][ts_external_token_variable_name] = true;
v->a[41][ts_external_token_file_descriptor] = true;
v->a[41][ts_external_token__concat] = true;
v->a[41][ts_external_token_heredoc_redirect_token1] = true;
v->a[42][ts_external_token_extglob_pattern] = true;
v->a[42][ts_external_token_LPAREN] = true;
v->a[42][ts_external_token_esac] = true;
v->a[43][ts_external_token_file_descriptor] = true;
v->a[43][ts_external_token_heredoc_redirect_token1] = true;
external_scanner_states_11(v);
}
void external_scanner_states_11(t_external_scanner_states_array *v)
{
v->a[43][ts_external_token__concat] = true;
v->a[43][ts_external_token_variable_name] = true;
v->a[44][ts_external_token_extglob_pattern] = true;
v->a[44][ts_external_token_LPAREN] = true;
v->a[45][ts_external_token_heredoc_redirect_token1] = true;
v->a[44][ts_external_token_file_descriptor] = true;
v->a[44][ts_external_token__concat] = true;
v->a[44][ts_external_token_variable_name] = true;
v->a[45][ts_external_token_extglob_pattern] = true;
v->a[45][ts_external_token_LPAREN] = true;
v->a[46][ts_external_token__bare_dollar] = true;
v->a[47][ts_external_token__empty_value] = true;
v->a[48][ts_external_token_extglob_pattern] = true;

194
parser/static/field_map_entries/field_map_entries_0.c
View file

@ -14,126 +14,126 @@
void field_map_entries_0(t_field_map_entries_array *v)
{
v->a[0] = fmap_entry(field_op, 0, false);
v->a[1] = fmap_entry(field_stmt, 0, true);
v->a[2] = fmap_entry(field_terminator, 0, true);
v->a[3] = fmap_entry(field_stmt, 0, false);
v->a[4] = fmap_entry(field_name, 0, false);
v->a[5] = fmap_entry(field_redirect, 0, false);
v->a[6] = fmap_entry(field_fd, 0, false);
v->a[7] = fmap_entry(field_op, 1, false);
v->a[8] = fmap_entry(field_dest, 1, false);
v->a[9] = fmap_entry(field_op, 0, false);
v->a[10] = fmap_entry(field_stmt, 0, false);
v->a[11] = fmap_entry(field_terminator, 1, false);
v->a[12] = fmap_entry(field_body, 0, false);
v->a[13] = fmap_entry(field_redirect, 1, false);
v->a[14] = fmap_entry(field_arg, 0, false);
v->a[15] = fmap_entry(field_arg, 1, true);
v->a[16] = fmap_entry(field_name, 0, false);
v->a[0] = fmap_entry(field_stmt, 0, true);
v->a[1] = fmap_entry(field_terminator, 0, true);
v->a[2] = fmap_entry(field_stmt, 0, false);
v->a[3] = fmap_entry(field_name, 0, false);
v->a[4] = fmap_entry(field_redirect, 0, false);
v->a[5] = fmap_entry(field_dest, 1, false);
v->a[6] = fmap_entry(field_op, 0, false);
v->a[7] = fmap_entry(field_stmt, 0, false);
v->a[8] = fmap_entry(field_terminator, 1, false);
v->a[9] = fmap_entry(field_body, 0, false);
v->a[10] = fmap_entry(field_redirect, 1, false);
v->a[11] = fmap_entry(field_arg, 0, false);
v->a[12] = fmap_entry(field_arg, 1, true);
v->a[13] = fmap_entry(field_name, 0, false);
v->a[14] = fmap_entry(field_stmt, 0, true);
v->a[15] = fmap_entry(field_stmt, 1, false);
v->a[16] = fmap_entry(field_terminator, 0, true);
v->a[17] = fmap_entry(field_stmt, 0, true);
v->a[18] = fmap_entry(field_stmt, 1, false);
v->a[18] = fmap_entry(field_stmt, 1, true);
v->a[19] = fmap_entry(field_terminator, 0, true);
field_map_entries_1(v);
}
void field_map_entries_1(t_field_map_entries_array *v)
{
v->a[20] = fmap_entry(field_stmt, 0, true);
v->a[21] = fmap_entry(field_stmt, 1, true);
v->a[22] = fmap_entry(field_terminator, 0, true);
v->a[23] = fmap_entry(field_terminator, 1, true);
v->a[24] = fmap_entry(field_name, 1, false);
v->a[25] = fmap_entry(field_redirect, 0, true);
v->a[26] = fmap_entry(field_redirect, 0, true);
v->a[27] = fmap_entry(field_redirect, 1, true);
v->a[28] = fmap_entry(field_dest, 2, false);
v->a[29] = fmap_entry(field_fd, 0, false);
v->a[30] = fmap_entry(field_op, 1, false);
v->a[31] = fmap_entry(field_name, 0, false);
v->a[32] = fmap_entry(field_value, 2, false);
v->a[33] = fmap_entry(field_body, 2, false);
v->a[34] = fmap_entry(field_condition, 1, false);
v->a[35] = fmap_entry(field_stmt, 1, true);
v->a[36] = fmap_entry(field_terminator, 1, true);
v->a[37] = fmap_entry(field_stmt, 1, true);
v->a[38] = fmap_entry(field_terminator, 1, true);
v->a[20] = fmap_entry(field_terminator, 1, true);
v->a[21] = fmap_entry(field_name, 1, false);
v->a[22] = fmap_entry(field_redirect, 0, true);
v->a[23] = fmap_entry(field_redirect, 0, true);
v->a[24] = fmap_entry(field_redirect, 1, true);
v->a[25] = fmap_entry(field_dest, 2, false);
v->a[26] = fmap_entry(field_fd, 0, false);
v->a[27] = fmap_entry(field_op, 1, false);
v->a[28] = fmap_entry(field_name, 0, false);
v->a[29] = fmap_entry(field_value, 2, false);
v->a[30] = fmap_entry(field_body, 2, false);
v->a[31] = fmap_entry(field_condition, 1, false);
v->a[32] = fmap_entry(field_stmt, 1, true);
v->a[33] = fmap_entry(field_terminator, 1, true);
v->a[34] = fmap_entry(field_stmt, 1, true);
v->a[35] = fmap_entry(field_terminator, 1, true);
v->a[36] = fmap_entry(field_op, 0, false);
v->a[37] = fmap_entry(field_op, 1, false);
v->a[38] = fmap_entry(field_name, 0, false);
v->a[39] = fmap_entry(field_op, 1, false);
field_map_entries_2(v);
}
void field_map_entries_2(t_field_map_entries_array *v)
{
v->a[40] = fmap_entry(field_name, 0, false);
v->a[41] = fmap_entry(field_op, 1, false);
v->a[42] = fmap_entry(field_name, 1, true);
v->a[43] = fmap_entry(field_op, 1, true);
v->a[44] = fmap_entry(field_redirect, 1, false);
v->a[45] = fmap_entry(field_cmd, 0, false);
v->a[46] = fmap_entry(field_cmd, 2, false);
v->a[47] = fmap_entry(field_op, 1, false);
v->a[48] = fmap_entry(field_arg, 0, true);
v->a[49] = fmap_entry(field_arg, 1, true);
v->a[50] = fmap_entry(field_stmt, 0, true);
v->a[51] = fmap_entry(field_stmt, 1, false);
v->a[52] = fmap_entry(field_terminator, 0, true);
v->a[53] = fmap_entry(field_terminator, 2, false);
v->a[54] = fmap_entry(field_arg, 2, true);
v->a[55] = fmap_entry(field_name, 1, false);
v->a[56] = fmap_entry(field_redirect, 0, true);
v->a[57] = fmap_entry(field_body, 3, false);
v->a[58] = fmap_entry(field_variable, 1, false);
v->a[59] = fmap_entry(field_condition, 1, false);
v->a[40] = fmap_entry(field_name, 1, true);
v->a[41] = fmap_entry(field_op, 1, true);
v->a[42] = fmap_entry(field_redirect, 1, false);
v->a[43] = fmap_entry(field_cmd, 0, false);
v->a[44] = fmap_entry(field_cmd, 2, false);
v->a[45] = fmap_entry(field_op, 1, false);
v->a[46] = fmap_entry(field_arg, 0, true);
v->a[47] = fmap_entry(field_arg, 1, true);
v->a[48] = fmap_entry(field_stmt, 0, true);
v->a[49] = fmap_entry(field_stmt, 1, false);
v->a[50] = fmap_entry(field_terminator, 0, true);
v->a[51] = fmap_entry(field_terminator, 2, false);
v->a[52] = fmap_entry(field_arg, 2, true);
v->a[53] = fmap_entry(field_name, 1, false);
v->a[54] = fmap_entry(field_redirect, 0, true);
v->a[55] = fmap_entry(field_body, 3, false);
v->a[56] = fmap_entry(field_variable, 1, false);
v->a[57] = fmap_entry(field_condition, 1, false);
v->a[58] = fmap_entry(field_stmt, 1, true);
v->a[59] = fmap_entry(field_terminator, 1, true);
field_map_entries_3(v);
}
void field_map_entries_3(t_field_map_entries_array *v)
{
v->a[60] = fmap_entry(field_stmt, 1, true);
v->a[61] = fmap_entry(field_terminator, 1, true);
v->a[62] = fmap_entry(field_value, 1, false);
v->a[63] = fmap_entry(field_cases, 0, false);
v->a[64] = fmap_entry(field_left, 0, false);
v->a[65] = fmap_entry(field_op, 1, false);
v->a[66] = fmap_entry(field_right, 2, false);
v->a[67] = fmap_entry(field_body, 3, false);
v->a[68] = fmap_entry(field_name, 0, false);
v->a[69] = fmap_entry(field_body, 1, false);
v->a[70] = fmap_entry(field_stmt, 1, true);
v->a[71] = fmap_entry(field_terminator, 1, true);
v->a[72] = fmap_entry(field_body, 3, false);
v->a[73] = fmap_entry(field_condition, 1, false);
v->a[74] = fmap_entry(field_stmt, 1, true);
v->a[75] = fmap_entry(field_stmt, 3, true);
v->a[76] = fmap_entry(field_terminator, 1, true);
v->a[77] = fmap_entry(field_terminator, 3, true);
v->a[78] = fmap_entry(field_condition, 1, false);
v->a[79] = fmap_entry(field_else, 3, false);
v->a[60] = fmap_entry(field_value, 1, false);
v->a[61] = fmap_entry(field_cases, 0, false);
v->a[62] = fmap_entry(field_left, 0, false);
v->a[63] = fmap_entry(field_op, 1, false);
v->a[64] = fmap_entry(field_right, 2, false);
v->a[65] = fmap_entry(field_body, 3, false);
v->a[66] = fmap_entry(field_name, 0, false);
v->a[67] = fmap_entry(field_body, 1, false);
v->a[68] = fmap_entry(field_stmt, 1, true);
v->a[69] = fmap_entry(field_terminator, 1, true);
v->a[70] = fmap_entry(field_body, 3, false);
v->a[71] = fmap_entry(field_condition, 1, false);
v->a[72] = fmap_entry(field_stmt, 1, true);
v->a[73] = fmap_entry(field_stmt, 3, true);
v->a[74] = fmap_entry(field_terminator, 1, true);
v->a[75] = fmap_entry(field_terminator, 3, true);
v->a[76] = fmap_entry(field_condition, 1, false);
v->a[77] = fmap_entry(field_else, 3, false);
v->a[78] = fmap_entry(field_stmt, 1, true);
v->a[79] = fmap_entry(field_terminator, 1, true);
field_map_entries_4(v);
}
void field_map_entries_4(t_field_map_entries_array *v)
{
v->a[80] = fmap_entry(field_stmt, 1, true);
v->a[81] = fmap_entry(field_terminator, 1, true);
v->a[82] = fmap_entry(field_condition, 1, false);
v->a[83] = fmap_entry(field_elif, 3, false);
v->a[84] = fmap_entry(field_stmt, 1, true);
v->a[85] = fmap_entry(field_terminator, 1, true);
v->a[86] = fmap_entry(field_body, 3, true);
v->a[87] = fmap_entry(field_cases, 3, false);
v->a[88] = fmap_entry(field_value, 1, false);
v->a[89] = fmap_entry(field_value, 3, true);
v->a[90] = fmap_entry(field_cases, 0, true);
v->a[91] = fmap_entry(field_cases, 1, true);
v->a[92] = fmap_entry(field_op, 0, false);
v->a[93] = fmap_entry(field_right, 1, false);
v->a[94] = fmap_entry(field_body, 5, false);
v->a[95] = fmap_entry(field_value, 3, false);
v->a[96] = fmap_entry(field_variable, 1, false);
v->a[97] = fmap_entry(field_body, 3, false);
v->a[98] = fmap_entry(field_condition, 1, false);
v->a[99] = fmap_entry(field_else, 4, false);
v->a[80] = fmap_entry(field_condition, 1, false);
v->a[81] = fmap_entry(field_elif, 3, false);
v->a[82] = fmap_entry(field_stmt, 1, true);
v->a[83] = fmap_entry(field_terminator, 1, true);
v->a[84] = fmap_entry(field_body, 3, true);
v->a[85] = fmap_entry(field_cases, 3, false);
v->a[86] = fmap_entry(field_value, 1, false);
v->a[87] = fmap_entry(field_value, 3, true);
v->a[88] = fmap_entry(field_cases, 0, true);
v->a[89] = fmap_entry(field_cases, 1, true);
v->a[90] = fmap_entry(field_op, 0, false);
v->a[91] = fmap_entry(field_right, 1, false);
v->a[92] = fmap_entry(field_body, 5, false);
v->a[93] = fmap_entry(field_value, 3, false);
v->a[94] = fmap_entry(field_variable, 1, false);
v->a[95] = fmap_entry(field_body, 3, false);
v->a[96] = fmap_entry(field_condition, 1, false);
v->a[97] = fmap_entry(field_else, 4, false);
v->a[98] = fmap_entry(field_stmt, 1, true);
v->a[99] = fmap_entry(field_stmt, 3, true);
field_map_entries_5(v);
}

68
parser/static/field_map_entries/field_map_entries_1.c
View file

@ -14,45 +14,45 @@
void field_map_entries_5(t_field_map_entries_array *v)
{
v->a[100] = fmap_entry(field_stmt, 1, true);
v->a[101] = fmap_entry(field_stmt, 3, true);
v->a[102] = fmap_entry(field_terminator, 1, true);
v->a[103] = fmap_entry(field_terminator, 3, true);
v->a[104] = fmap_entry(field_body, 3, false);
v->a[105] = fmap_entry(field_condition, 1, false);
v->a[106] = fmap_entry(field_elif, 4, false);
v->a[107] = fmap_entry(field_stmt, 1, true);
v->a[108] = fmap_entry(field_stmt, 3, true);
v->a[109] = fmap_entry(field_terminator, 1, true);
v->a[110] = fmap_entry(field_terminator, 3, true);
v->a[111] = fmap_entry(field_condition, 1, false);
v->a[112] = fmap_entry(field_elif, 3, false);
v->a[113] = fmap_entry(field_else, 4, false);
v->a[114] = fmap_entry(field_stmt, 1, true);
v->a[115] = fmap_entry(field_terminator, 1, true);
v->a[116] = fmap_entry(field_body, 2, false);
v->a[117] = fmap_entry(field_stmt, 2, true);
v->a[118] = fmap_entry(field_terminator, 2, true);
v->a[119] = fmap_entry(field_value, 0, false);
v->a[100] = fmap_entry(field_terminator, 1, true);
v->a[101] = fmap_entry(field_terminator, 3, true);
v->a[102] = fmap_entry(field_body, 3, false);
v->a[103] = fmap_entry(field_condition, 1, false);
v->a[104] = fmap_entry(field_elif, 4, false);
v->a[105] = fmap_entry(field_stmt, 1, true);
v->a[106] = fmap_entry(field_stmt, 3, true);
v->a[107] = fmap_entry(field_terminator, 1, true);
v->a[108] = fmap_entry(field_terminator, 3, true);
v->a[109] = fmap_entry(field_condition, 1, false);
v->a[110] = fmap_entry(field_elif, 3, false);
v->a[111] = fmap_entry(field_else, 4, false);
v->a[112] = fmap_entry(field_stmt, 1, true);
v->a[113] = fmap_entry(field_terminator, 1, true);
v->a[114] = fmap_entry(field_body, 2, false);
v->a[115] = fmap_entry(field_stmt, 2, true);
v->a[116] = fmap_entry(field_terminator, 2, true);
v->a[117] = fmap_entry(field_value, 0, false);
v->a[118] = fmap_entry(field_value, 0, true);
v->a[119] = fmap_entry(field_value, 1, true);
field_map_entries_6(v);
}
void field_map_entries_6(t_field_map_entries_array *v)
{
v->a[120] = fmap_entry(field_value, 0, true);
v->a[121] = fmap_entry(field_value, 1, true);
v->a[122] = fmap_entry(field_body, 4, true);
v->a[123] = fmap_entry(field_cases, 4, false);
v->a[124] = fmap_entry(field_value, 1, false);
v->a[125] = fmap_entry(field_value, 4, true);
v->a[126] = fmap_entry(field_body, 4, true);
v->a[127] = fmap_entry(field_cases, 3, true);
v->a[128] = fmap_entry(field_cases, 4, false);
v->a[129] = fmap_entry(field_value, 1, false);
v->a[130] = fmap_entry(field_value, 4, true);
v->a[131] = fmap_entry(field_alternative, 4, false);
v->a[132] = fmap_entry(field_condition, 0, false);
v->a[133] = fmap_entry(field_consequence, 2, false);
v->a[120] = fmap_entry(field_body, 4, true);
v->a[121] = fmap_entry(field_cases, 4, false);
v->a[122] = fmap_entry(field_value, 1, false);
v->a[123] = fmap_entry(field_value, 4, true);
v->a[124] = fmap_entry(field_body, 4, true);
v->a[125] = fmap_entry(field_cases, 3, true);
v->a[126] = fmap_entry(field_cases, 4, false);
v->a[127] = fmap_entry(field_value, 1, false);
v->a[128] = fmap_entry(field_value, 4, true);
v->a[129] = fmap_entry(field_alternative, 4, false);
v->a[130] = fmap_entry(field_condition, 0, false);
v->a[131] = fmap_entry(field_consequence, 2, false);
v->a[132] = fmap_entry(field_fd, 0, false);
v->a[133] = fmap_entry(field_op, 1, false);
v->a[134] = fmap_entry(field_op, 0, false);
v->a[135] = fmap_entry(field_op, 2, true);
v->a[136] = fmap_entry(field_right, 2, true);

98
parser/static/field_map_slices/field_map_slices_0.c
View file

@ -14,69 +14,69 @@
void field_map_slices_0(t_field_map_slices_array *v)
{
v->a[1] = fmap_slice(0, 1);
v->a[2] = fmap_slice(1, 2);
v->a[1] = fmap_slice(0, 2);
v->a[2] = fmap_slice(2, 1);
v->a[3] = fmap_slice(3, 1);
v->a[4] = fmap_slice(4, 1);
v->a[5] = fmap_slice(5, 1);
v->a[6] = fmap_slice(6, 2);
v->a[7] = fmap_slice(8, 2);
v->a[9] = fmap_slice(4, 1);
v->a[10] = fmap_slice(10, 2);
v->a[11] = fmap_slice(12, 2);
v->a[12] = fmap_slice(14, 1);
v->a[13] = fmap_slice(14, 1);
v->a[14] = fmap_slice(15, 2);
v->a[15] = fmap_slice(17, 3);
v->a[16] = fmap_slice(20, 4);
v->a[17] = fmap_slice(24, 2);
v->a[18] = fmap_slice(26, 2);
v->a[19] = fmap_slice(28, 3);
v->a[20] = fmap_slice(31, 2);
v->a[21] = fmap_slice(33, 4);
v->a[5] = fmap_slice(5, 2);
v->a[7] = fmap_slice(3, 1);
v->a[8] = fmap_slice(7, 2);
v->a[9] = fmap_slice(9, 2);
v->a[10] = fmap_slice(11, 1);
v->a[11] = fmap_slice(11, 1);
v->a[12] = fmap_slice(12, 2);
v->a[13] = fmap_slice(14, 3);
v->a[14] = fmap_slice(17, 4);
v->a[15] = fmap_slice(21, 2);
v->a[16] = fmap_slice(23, 2);
v->a[17] = fmap_slice(25, 3);
v->a[18] = fmap_slice(28, 2);
v->a[19] = fmap_slice(30, 4);
v->a[20] = fmap_slice(34, 2);
v->a[21] = fmap_slice(36, 1);
field_map_slices_1(v);
}
void field_map_slices_1(t_field_map_slices_array *v)
{
v->a[22] = fmap_slice(37, 2);
v->a[23] = fmap_slice(0, 1);
v->a[24] = fmap_slice(39, 1);
v->a[26] = fmap_slice(40, 2);
v->a[22] = fmap_slice(37, 1);
v->a[24] = fmap_slice(36, 1);
v->a[25] = fmap_slice(38, 2);
v->a[26] = fmap_slice(38, 2);
v->a[27] = fmap_slice(40, 2);
v->a[28] = fmap_slice(42, 2);
v->a[29] = fmap_slice(44, 1);
v->a[30] = fmap_slice(45, 3);
v->a[31] = fmap_slice(48, 2);
v->a[32] = fmap_slice(50, 4);
v->a[33] = fmap_slice(54, 3);
v->a[34] = fmap_slice(57, 2);
v->a[35] = fmap_slice(59, 3);
v->a[36] = fmap_slice(62, 1);
v->a[37] = fmap_slice(63, 1);
v->a[38] = fmap_slice(64, 3);
v->a[42] = fmap_slice(67, 2);
v->a[43] = fmap_slice(69, 3);
v->a[44] = fmap_slice(72, 6);
v->a[45] = fmap_slice(78, 4);
v->a[28] = fmap_slice(42, 1);
v->a[29] = fmap_slice(43, 3);
v->a[30] = fmap_slice(46, 2);
v->a[31] = fmap_slice(48, 4);
v->a[32] = fmap_slice(52, 3);
v->a[33] = fmap_slice(55, 2);
v->a[34] = fmap_slice(57, 3);
v->a[35] = fmap_slice(60, 1);
v->a[36] = fmap_slice(61, 1);
v->a[37] = fmap_slice(62, 3);
v->a[41] = fmap_slice(65, 2);
v->a[42] = fmap_slice(67, 3);
v->a[43] = fmap_slice(70, 6);
v->a[44] = fmap_slice(76, 4);
v->a[45] = fmap_slice(80, 4);
field_map_slices_2(v);
}
void field_map_slices_2(t_field_map_slices_array *v)
{
v->a[46] = fmap_slice(82, 4);
v->a[47] = fmap_slice(86, 4);
v->a[46] = fmap_slice(84, 4);
v->a[47] = fmap_slice(88, 2);
v->a[48] = fmap_slice(90, 2);
v->a[49] = fmap_slice(92, 2);
v->a[50] = fmap_slice(94, 3);
v->a[51] = fmap_slice(97, 7);
v->a[52] = fmap_slice(104, 7);
v->a[53] = fmap_slice(111, 5);
v->a[54] = fmap_slice(116, 4);
v->a[55] = fmap_slice(120, 2);
v->a[56] = fmap_slice(122, 4);
v->a[57] = fmap_slice(126, 5);
v->a[58] = fmap_slice(131, 3);
v->a[49] = fmap_slice(92, 3);
v->a[50] = fmap_slice(95, 7);
v->a[51] = fmap_slice(102, 7);
v->a[52] = fmap_slice(109, 5);
v->a[53] = fmap_slice(114, 4);
v->a[54] = fmap_slice(118, 2);
v->a[55] = fmap_slice(120, 4);
v->a[56] = fmap_slice(124, 5);
v->a[57] = fmap_slice(129, 3);
v->a[58] = fmap_slice(132, 2);
v->a[59] = fmap_slice(134, 3);
v->a[60] = fmap_slice(137, 2);
v->a[61] = fmap_slice(139, 2);

16
parser/static/field_names/field_names_0.c
View file

@ -12,15 +12,15 @@
#include "./field_names.h"
void field_names_0(t_field_names_array *v)
void field_names_0(t_field_names_array *v)
{
v->a[field_alternative] = "alternative";
v->a[field_alternative] = "alt";
v->a[field_arg] = "arg";
v->a[field_body] = "body";
v->a[field_cases] = "cases";
v->a[field_cases] = "case";
v->a[field_cmd] = "cmd";
v->a[field_condition] = "condition";
v->a[field_consequence] = "consequence";
v->a[field_condition] = "cond";
v->a[field_consequence] = "cnsq";
v->a[field_dest] = "dest";
v->a[field_elif] = "elif";
v->a[field_else] = "else";
@ -28,12 +28,12 @@ void field_names_0(t_field_names_array *v)
v->a[field_left] = "left";
v->a[field_name] = "name";
v->a[field_op] = "op";
v->a[field_redirect] = "redirect";
v->a[field_redirect] = "redir";
v->a[field_right] = "right";
v->a[field_stmt] = "stmt";
v->a[field_terminator] = "terminator";
v->a[field_terminator] = "term";
v->a[field_value] = "value";
v->a[field_variable] = "variable";
v->a[field_variable] = "var";
}
/* EOF field_names_0.c */

6
parser/static/headers/constants.h
View file

@ -14,11 +14,11 @@
# define CONSTANTS_H
# define LANGUAGE_VERSION 14
# define STATE_COUNT 2340
# define STATE_COUNT 2118
# define LARGE_STATE_COUNT 2
# define SYMBOL_COUNT 181
# define SYMBOL_COUNT 179
# define ALIAS_COUNT 1
# define TOKEN_COUNT 113
# define TOKEN_COUNT 111
# define EXTERNAL_TOKEN_COUNT 20
# define FIELD_COUNT 20
# define MAX_ALIAS_SEQUENCE_LENGTH 8

298
parser/static/headers/symbols.h
View file

@ -45,156 +45,154 @@ enum e_symbols {
anon_sym_LT_AMP = 29,
anon_sym_GT_AMP = 30,
anon_sym_GT_PIPE = 31,
anon_sym_LT_AMP_DASH = 32,
anon_sym_GT_AMP_DASH = 33,
anon_sym_LT_LT = 34,
anon_sym_LT_LT_DASH = 35,
aux_sym_heredoc_redirect_token1 = 36,
anon_sym_PIPE_AMP = 37,
anon_sym_DOLLAR_LPAREN_LPAREN = 38,
anon_sym_RPAREN_RPAREN = 39,
anon_sym_PLUS_EQ = 40,
anon_sym_DASH_EQ = 41,
anon_sym_STAR_EQ = 42,
anon_sym_SLASH_EQ = 43,
anon_sym_PERCENT_EQ = 44,
anon_sym_LT_LT_EQ = 45,
anon_sym_GT_GT_EQ = 46,
anon_sym_AMP_EQ = 47,
anon_sym_CARET_EQ = 48,
anon_sym_PIPE_EQ = 49,
anon_sym_CARET = 50,
anon_sym_AMP = 51,
anon_sym_EQ_EQ = 52,
anon_sym_BANG_EQ = 53,
anon_sym_LT_EQ = 54,
anon_sym_GT_EQ = 55,
anon_sym_PLUS = 56,
anon_sym_DASH = 57,
anon_sym_STAR = 58,
anon_sym_SLASH = 59,
anon_sym_PERCENT = 60,
anon_sym_QMARK = 61,
anon_sym_COLON = 62,
anon_sym_PLUS_PLUS = 63,
anon_sym_DASH_DASH = 64,
anon_sym_DASH2 = 65,
anon_sym_PLUS2 = 66,
anon_sym_TILDE = 67,
anon_sym_PLUS_PLUS2 = 68,
anon_sym_DASH_DASH2 = 69,
aux_sym_concatenation_token1 = 70,
anon_sym_DOLLAR = 71,
anon_sym_DQUOTE = 72,
sym_string_content = 73,
sym_raw_string = 74,
sym_number = 75,
anon_sym_POUND = 76,
anon_sym_DOLLAR_LBRACE = 77,
anon_sym_COLON_DASH = 78,
anon_sym_DASH3 = 79,
anon_sym_COLON_EQ = 80,
anon_sym_EQ2 = 81,
anon_sym_COLON_QMARK = 82,
anon_sym_QMARK2 = 83,
anon_sym_COLON_PLUS = 84,
anon_sym_PLUS3 = 85,
anon_sym_PERCENT_PERCENT = 86,
aux_sym_expansion_regex_token1 = 87,
anon_sym_DOLLAR_LPAREN = 88,
anon_sym_BQUOTE = 89,
sym_comment = 90,
sym__comment_word = 91,
aux_sym__simple_variable_name_token1 = 92,
aux_sym__multiline_variable_name_token1 = 93,
anon_sym_AT = 94,
anon_sym_0 = 95,
anon_sym__ = 96,
anon_sym_SEMI = 97,
sym_heredoc_start = 98,
sym_simple_heredoc_body = 99,
sym__heredoc_body_beginning = 100,
sym_heredoc_content = 101,
sym_heredoc_end = 102,
sym_file_descriptor = 103,
sym__empty_value = 104,
sym__concat = 105,
sym_variable_name = 106,
sym_regex = 107,
sym__expansion_word = 108,
sym_extglob_pattern = 109,
sym__bare_dollar = 110,
sym__immediate_double_hash = 111,
sym___error_recovery = 112,
sym_program = 113,
sym__statements = 114,
aux_sym__terminated_statement = 115,
sym__statement_not_pipeline = 116,
sym_redirected_statement = 117,
sym_for_statement = 118,
sym_while_statement = 119,
sym_do_group = 120,
sym_if_statement = 121,
sym_elif_clause = 122,
sym_else_clause = 123,
sym_case_statement = 124,
sym__case_item_last = 125,
sym_case_item = 126,
sym_function_definition = 127,
sym_compound_statement = 128,
sym_subshell = 129,
sym_pipeline = 130,
sym_list = 131,
sym_negated_command = 132,
sym_command = 133,
sym_command_name = 134,
sym_variable_assignment = 135,
sym__variable_assignments = 136,
sym_file_redirect = 137,
sym_heredoc_redirect = 138,
sym__heredoc_pipeline = 139,
sym__heredoc_expression = 140,
aux_sym__heredoc_command = 141,
sym__heredoc_body = 142,
sym_heredoc_body = 143,
sym__simple_heredoc_body = 144,
sym_arithmetic_expansion = 145,
sym__arithmetic_expression = 146,
sym_arithmetic_literal = 147,
sym_arithmetic_binary_expression = 148,
sym_arithmetic_ternary_expression = 149,
sym_arithmetic_unary_expression = 150,
sym_arithmetic_postfix_expression = 151,
sym_arithmetic_parenthesized_expression = 152,
sym_concatenation = 153,
sym_string = 154,
sym_simple_expansion = 155,
sym_expansion = 156,
sym__expansion_body = 157,
sym_expansion_expression = 158,
sym_expansion_regex = 159,
sym__concatenation_in_expansion = 160,
sym_command_substitution = 161,
sym__extglob_blob = 162,
sym_terminator = 163,
aux_sym__statements_repeat1 = 164,
aux_sym_redirected_statement_repeat1 = 165,
aux_sym_redirected_statement_repeat2 = 166,
aux_sym_for_statement_repeat1 = 167,
aux_sym_if_statement_repeat1 = 168,
aux_sym_case_statement_repeat1 = 169,
aux_sym__case_item_last_repeat1 = 170,
aux_sym__case_item_last_repeat2 = 171,
aux_sym_pipeline_repeat1 = 172,
aux_sym_command_repeat1 = 173,
aux_sym_command_repeat2 = 174,
aux_sym__variable_assignments_repeat1 = 175,
aux_sym_heredoc_body_repeat1 = 176,
aux_sym_concatenation_repeat1 = 177,
aux_sym_string_repeat1 = 178,
aux_sym_expansion_regex_repeat1 = 179,
aux_sym__concatenation_in_expansion_repeat1 = 180,
alias_sym_statements = 181,
anon_sym_LT_GT = 32,
anon_sym_LT_LT = 33,
anon_sym_LT_LT_DASH = 34,
aux_sym_heredoc_redirect_token1 = 35,
anon_sym_DOLLAR_LPAREN_LPAREN = 36,
anon_sym_RPAREN_RPAREN = 37,
anon_sym_PLUS_EQ = 38,
anon_sym_DASH_EQ = 39,
anon_sym_STAR_EQ = 40,
anon_sym_SLASH_EQ = 41,
anon_sym_PERCENT_EQ = 42,
anon_sym_LT_LT_EQ = 43,
anon_sym_GT_GT_EQ = 44,
anon_sym_AMP_EQ = 45,
anon_sym_CARET_EQ = 46,
anon_sym_PIPE_EQ = 47,
anon_sym_CARET = 48,
anon_sym_AMP = 49,
anon_sym_EQ_EQ = 50,
anon_sym_BANG_EQ = 51,
anon_sym_LT_EQ = 52,
anon_sym_GT_EQ = 53,
anon_sym_PLUS = 54,
anon_sym_DASH = 55,
anon_sym_STAR = 56,
anon_sym_SLASH = 57,
anon_sym_PERCENT = 58,
anon_sym_QMARK = 59,
anon_sym_COLON = 60,
anon_sym_PLUS_PLUS = 61,
anon_sym_DASH_DASH = 62,
anon_sym_DASH2 = 63,
anon_sym_PLUS2 = 64,
anon_sym_TILDE = 65,
anon_sym_PLUS_PLUS2 = 66,
anon_sym_DASH_DASH2 = 67,
aux_sym_concatenation_token1 = 68,
anon_sym_DOLLAR = 69,
anon_sym_DQUOTE = 70,
sym_string_content = 71,
sym_raw_string = 72,
sym_number = 73,
anon_sym_POUND = 74,
anon_sym_DOLLAR_LBRACE = 75,
anon_sym_COLON_DASH = 76,
anon_sym_DASH3 = 77,
anon_sym_COLON_EQ = 78,
anon_sym_EQ2 = 79,
anon_sym_COLON_QMARK = 80,
anon_sym_QMARK2 = 81,
anon_sym_COLON_PLUS = 82,
anon_sym_PLUS3 = 83,
anon_sym_PERCENT_PERCENT = 84,
aux_sym_expansion_regex_token1 = 85,
anon_sym_DOLLAR_LPAREN = 86,
anon_sym_BQUOTE = 87,
sym_comment = 88,
sym__comment_word = 89,
aux_sym__simple_variable_name_token1 = 90,
aux_sym__multiline_variable_name_token1 = 91,
anon_sym_AT = 92,
anon_sym_0 = 93,
anon_sym__ = 94,
anon_sym_SEMI = 95,
sym_heredoc_start = 96,
sym_simple_heredoc_body = 97,
sym__heredoc_body_beginning = 98,
sym_heredoc_content = 99,
sym_heredoc_end = 100,
sym_file_descriptor = 101,
sym__empty_value = 102,
sym__concat = 103,
sym_variable_name = 104,
sym_regex = 105,
sym__expansion_word = 106,
sym_extglob_pattern = 107,
sym__bare_dollar = 108,
sym__immediate_double_hash = 109,
sym___error_recovery = 110,
sym_program = 111,
sym__statements = 112,
aux_sym__terminated_statement = 113,
sym__statement_not_pipeline = 114,
sym_redirected_statement = 115,
sym_for_statement = 116,
sym_while_statement = 117,
sym_do_group = 118,
sym_if_statement = 119,
sym_elif_clause = 120,
sym_else_clause = 121,
sym_case_statement = 122,
sym__case_item_last = 123,
sym_case_item = 124,
sym_function_definition = 125,
sym_compound_statement = 126,
sym_subshell = 127,
sym_pipeline = 128,
sym_list = 129,
sym_negated_command = 130,
sym_command = 131,
sym_command_name = 132,
sym_variable_assignment = 133,
sym__variable_assignments = 134,
sym_file_redirect = 135,
sym_heredoc_redirect = 136,
sym__heredoc_pipeline = 137,
sym__heredoc_expression = 138,
aux_sym__heredoc_command = 139,
sym__heredoc_body = 140,
sym_heredoc_body = 141,
sym__simple_heredoc_body = 142,
sym_arithmetic_expansion = 143,
sym__arithmetic_expression = 144,
sym_arithmetic_literal = 145,
sym_arithmetic_binary_expression = 146,
sym_arithmetic_ternary_expression = 147,
sym_arithmetic_unary_expression = 148,
sym_arithmetic_postfix_expression = 149,
sym_arithmetic_parenthesized_expression = 150,
sym_concatenation = 151,
sym_string = 152,
sym_simple_expansion = 153,
sym_expansion = 154,
sym__expansion_body = 155,
sym_expansion_expression = 156,
sym_expansion_regex = 157,
sym__concatenation_in_expansion = 158,
sym_command_substitution = 159,
sym__extglob_blob = 160,
sym_terminator = 161,
aux_sym__statements_repeat1 = 162,
aux_sym_redirected_statement_repeat1 = 163,
aux_sym_redirected_statement_repeat2 = 164,
aux_sym_for_statement_repeat1 = 165,
aux_sym_if_statement_repeat1 = 166,
aux_sym_case_statement_repeat1 = 167,
aux_sym__case_item_last_repeat1 = 168,
aux_sym__case_item_last_repeat2 = 169,
aux_sym_pipeline_repeat1 = 170,
aux_sym_command_repeat1 = 171,
aux_sym_command_repeat2 = 172,
aux_sym__variable_assignments_repeat1 = 173,
aux_sym_heredoc_body_repeat1 = 174,
aux_sym_concatenation_repeat1 = 175,
aux_sym_string_repeat1 = 176,
aux_sym_expansion_regex_repeat1 = 177,
aux_sym__concatenation_in_expansion_repeat1 = 178,
alias_sym_statements = 179,
};
#endif // SYMBOLS_H

9
parser/static/lex_funcs/lex_normal/create_table/lex_normal_array_4.c
View file

@ -130,14 +130,5 @@ void lex_normal_array_24(t_lex_normal_array *v)
v->a[488] = lex_normal_s488;
v->a[489] = lex_normal_s489;
v->a[490] = lex_normal_s490;
v->a[491] = lex_normal_s491;
v->a[492] = lex_normal_s492;
v->a[493] = lex_normal_s493;
v->a[494] = lex_normal_s494;
v->a[495] = lex_normal_s495;
v->a[496] = lex_normal_s496;
v->a[497] = lex_normal_s497;
v->a[498] = lex_normal_s498;
v->a[499] = lex_normal_s499;
}
/* EOF lex_normal_array_4.c */

48
parser/static/lex_funcs/lex_normal/inline/inline_impl0.h
View file

@ -22,13 +22,13 @@
static inline bool lex_normal_map0(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 266, '"', 368, '#', 383, \
'$', 366, '%', 347, '&', 332, '\'', 200, '(', 251, ')', \
257, '*', 342, '+', 359, '-', 357, '/', 345, '0', 446, \
':', 353, ';', 499, '<', 271, '=', 391, '>', 274, '?', \
395, '@', 445, '\\', 119, '^', 328, '_', 449, '`', 404, \
'd', 495, 'e', 492, 'f', 490, 'i', 494, '{', 260, '|', \
253, '}', 262, '~', 361};
static uint32_t map[] = {'!', 261, '"', 360, '#', 375, \
'$', 358, '%', 339, '&', 324, '\'', 197, '(', 248, ')', \
252, '*', 334, '+', 351, '-', 349, '/', 337, '0', 437, \
':', 345, ';', 490, '<', 265, '=', 383, '>', 269, '?', \
387, '@', 436, '\\', 116, '^', 320, '_', 440, '`', 396, \
'd', 486, 'e', 483, 'f', 481, 'i', 485, '{', 255, '|', \
250, '}', 257, '~', 353};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -37,9 +37,9 @@ static inline bool lex_normal_map0(t_lexer *lexer, \
static inline bool lex_normal_map5(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 258, '!', 266, '"', 368, \
'#', 408, '$', 366, '\'', 200, '(', 251, '<', 270, '>', \
275, '\\', 127, '`', 403, '{', 260};
static uint32_t map[] = {'\n', 253, '!', 261, '"', 360, \
'#', 400, '$', 358, '\'', 197, '(', 248, '<', 267, '>', \
270, '\\', 124, '`', 395, '{', 255};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -48,11 +48,11 @@ static inline bool lex_normal_map5(t_lexer *lexer, \
static inline bool lex_normal_map10(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 288, '!', 266, '"', 368, \
'#', 383, '$', 366, '&', 331, '\'', 200, '(', 251, '*', \
344, '-', 340, '0', 447, ';', 499, '<', 272, '>', 275, \
'?', 351, '@', 445, '\\', 13, '_', 450, '`', 403, '|', \
256};
static uint32_t map[] = {'\n', 282, '!', 261, '"', 360, \
'#', 375, '$', 358, '&', 323, '\'', 197, '(', 248, '*', \
336, '-', 332, '0', 438, ';', 490, '<', 266, '>', 270, \
'?', 343, '@', 436, '\\', 13, '_', 441, '`', 395, 'e', \
404, '|', 251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -61,10 +61,10 @@ static inline bool lex_normal_map10(t_lexer *lexer, \
static inline bool lex_normal_map48(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 289, '!', 265, '#', 383, \
'$', 365, '&', 331, ')', 257, '*', 341, '-', 338, '0', \
448, ';', 499, '<', 272, '>', 275, '?', 350, '@', 444, \
'\\', 50, '_', 451, '|', 256};
static uint32_t map[] = {'\n', 283, '!', 260, '#', 375, \
'$', 357, '&', 323, ')', 252, '*', 333, '-', 330, '0', \
439, ';', 490, '<', 266, '>', 270, '?', 342, '@', 435, \
'\\', 50, '_', 442, '|', 251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -73,11 +73,11 @@ static inline bool lex_normal_map48(t_lexer *lexer, \
static inline bool lex_normal_map89(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 291, '!', 266, '"', 368, \
'#', 383, '$', 366, '&', 331, '\'', 200, '(', 251, '*', \
344, '-', 340, '0', 447, ';', 499, '<', 272, '>', 275, \
'?', 351, '@', 445, '\\', 22, '_', 450, '`', 403, 'e', \
412, '|', 256};
static uint32_t map[] = {'\n', 285, '!', 261, '"', 360, \
'#', 375, '$', 358, '&', 323, '\'', 197, '(', 248, '*', \
336, '-', 332, '0', 438, ';', 490, '<', 266, '>', 270, \
'?', 343, '@', 436, '\\', 19, '_', 441, '`', 395, '|', \
251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));

72
parser/static/lex_funcs/lex_normal/inline/inline_impl1.h
View file

@ -19,12 +19,36 @@
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map97(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 286, '"', 360, '#', 400, \
'$', 358, '&', 323, '\'', 197, '(', 248, ')', 252, ';', \
490, '<', 266, '>', 270, '\\', 134, '`', 395, '|', 251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map98(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 287, '"', 360, '#', 400, \
'$', 358, '&', 323, '\'', 197, '(', 248, ';', 490, '<', \
266, '>', 270, '\\', 136, '`', 395, 'e', 487, '|', 251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map99(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 292, '"', 368, '#', 408, \
'$', 366, '&', 331, '\'', 200, '(', 251, ')', 257, ';', \
499, '<', 272, '>', 275, '\\', 137, '`', 403, '|', 254};
static uint32_t map[] = {'\n', 288, '!', 261, '"', 360, \
'#', 375, '$', 358, '&', 323, '\'', 197, '*', 336, '-', \
332, '0', 438, ';', 490, '<', 266, '>', 270, '?', 343, \
'@', 436, '\\', 25, '_', 441, '`', 395, 'e', 404, '|', \
251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -33,9 +57,10 @@ static inline bool lex_normal_map99(t_lexer *lexer, \
static inline bool lex_normal_map100(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 293, '"', 368, '#', 408, \
'$', 366, '&', 331, '\'', 200, '(', 251, ';', 499, '<', \
272, '>', 275, '\\', 139, '`', 403, 'e', 496, '|', 256};
static uint32_t map[] = {'\n', 289, '!', 260, '#', 375, \
'$', 357, '&', 323, '*', 333, '-', 330, '0', 439, ';', \
490, '<', 266, '>', 270, '?', 342, '@', 435, '\\', 52, \
'_', 442, 'e', 409, '|', 251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -44,36 +69,11 @@ static inline bool lex_normal_map100(t_lexer *lexer, \
static inline bool lex_normal_map101(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 294, '!', 266, '"', 368, \
'#', 383, '$', 366, '&', 331, '\'', 200, '(', 251, ')', \
257, '*', 344, '-', 340, '0', 447, ';', 499, '<', 272, \
'>', 275, '?', 351, '@', 445, '\\', 19, '_', 450, '`', \
403, '|', 256};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map102(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 295, '!', 265, '#', 383, \
'$', 365, '&', 331, '*', 341, '-', 338, '0', 448, ';', \
499, '<', 272, '>', 275, '?', 350, '@', 444, '\\', 52, \
'_', 451, 'e', 417, '|', 256};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map103(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 296, '!', 266, '"', 368, \
'#', 383, '$', 366, '&', 331, '\'', 200, '*', 344, '-', \
340, '0', 447, ';', 499, '<', 272, '>', 275, '?', 351, \
'@', 445, '\\', 28, '_', 450, '`', 403, 'e', 412, '|', \
256};
static uint32_t map[] = {'\n', 290, '!', 261, '"', 360, \
'#', 375, '$', 358, '&', 323, '\'', 197, '(', 248, ')', \
252, '*', 336, '-', 332, '0', 438, ';', 490, '<', 266, \
'>', 270, '?', 343, '@', 436, '\\', 22, '_', 441, '`', \
395, '|', 251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));

51
parser/static/lex_funcs/lex_normal/inline/inline_impl10.h
View file

@ -19,62 +19,61 @@
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map228(t_lexer *lexer, \
static inline bool lex_normal_map229(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 302, '!', 265, '#', 383, \
'$', 365, '&', 331, '*', 341, '-', 338, '0', 448, ';', \
499, '<', 272, '>', 275, '?', 350, '@', 444, '\\', 56, \
'_', 451, '|', 256};
static uint32_t map[] = {'!', 261, '"', 360, '#', 375, \
'$', 358, '%', 339, '&', 324, '\'', 197, '(', 248, ')', \
252, '*', 334, '+', 351, '-', 349, '/', 337, '0', 437, \
':', 346, ';', 490, '<', 265, '=', 264, '>', 269, '?', \
343, '@', 436, '\\', 116, '^', 320, '_', 440, '`', 396, \
'd', 486, 'e', 483, 'f', 481, 'i', 485, '{', 255, '|', \
250, '}', 257, '~', 353};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map232(t_lexer *lexer, \
static inline bool lex_normal_map230(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 266, '"', 368, '#', 383, \
'$', 366, '%', 347, '&', 332, '\'', 200, '(', 251, ')', \
257, '*', 342, '+', 359, '-', 357, '/', 345, '0', 446, \
':', 354, ';', 499, '<', 271, '=', 269, '>', 274, '?', \
351, '@', 445, '\\', 119, '^', 328, '_', 449, '`', 404, \
'd', 495, 'e', 492, 'f', 490, 'i', 494, '{', 260, '|', \
253, '}', 262, '~', 361};
static uint32_t map[] = {'!', 261, '"', 360, '#', 400, \
'$', 358, '\'', 197, '(', 248, ')', 252, ';', 201, '<', \
267, '>', 270, '\\', 119, '`', 395, '{', 255};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map233(t_lexer *lexer, \
static inline bool lex_normal_map231(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 266, '"', 368, '#', 408, \
'$', 366, '\'', 200, '(', 251, ')', 257, ';', 204, '<', \
270, '>', 275, '\\', 122, '`', 403, '{', 260};
static uint32_t map[] = {'!', 202, '#', 400, '$', 359, \
'%', 341, '&', 324, ')', 199, '*', 335, '+', 329, '-', \
331, '/', 338, ':', 344, ';', 201, '<', 268, '=', 263, \
'>', 271, '?', 342};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map234(t_lexer *lexer, \
static inline bool lex_normal_map365(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 205, '#', 408, '$', 367, \
'%', 349, '&', 332, ')', 202, '*', 343, '+', 337, '-', \
339, '/', 346, ':', 352, ';', 204, '<', 273, '=', 268, \
'>', 276, '?', 350};
static uint32_t map[] = {'!', 260, '"', 360, '#', 375, \
'$', 357, '*', 333, '-', 330, '0', 439, '?', 342, '@', \
435, '\\', 79, '_', 442};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map373(t_lexer *lexer, \
static inline bool lex_normal_map366(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 265, '"', 368, '#', 383, \
'$', 365, '*', 341, '-', 338, '0', 448, '?', 350, '@', \
444, '\\', 81, '_', 451};
static uint32_t map[] = {'!', 260, '#', 375, '$', 357, \
'*', 333, '-', 330, '0', 439, '?', 342, '@', 435, '\\', \
83, '_', 442};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));

55
parser/static/lex_funcs/lex_normal/inline/inline_impl11.h
View file

@ -19,63 +19,64 @@
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map374(t_lexer *lexer, \
static inline bool lex_normal_map411(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 265, '#', 383, '$', 365, \
'*', 341, '-', 338, '0', 448, '?', 350, '@', 444, '\\', \
83, '_', 451};
static uint32_t map[] = {'\n', 282, '!', 261, '"', 360, \
'#', 375, '$', 358, '&', 323, '\'', 197, '(', 248, '*', \
336, '-', 332, '0', 438, ';', 490, '<', 266, '>', 270, \
'?', 343, '@', 436, '\\', 13, '_', 441, '`', 395, 'e', \
404, '|', 251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map419(t_lexer *lexer, \
static inline bool lex_normal_map412(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 288, '!', 266, '"', 368, \
'#', 383, '$', 366, '&', 331, '\'', 200, '(', 251, '*', \
344, '-', 340, '0', 447, ';', 499, '<', 272, '>', 275, \
'?', 351, '@', 445, '\\', 13, '_', 450, '`', 403, '|', \
256};
static uint32_t map[] = {'\n', 283, '!', 260, '#', 375, \
'$', 357, '&', 323, ')', 252, '*', 333, '-', 330, '0', \
439, ';', 490, '<', 266, '>', 270, '?', 342, '@', 435, \
'\\', 50, '_', 442, '|', 251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map420(t_lexer *lexer, \
static inline bool lex_normal_map413(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 289, '!', 265, '#', 383, \
'$', 365, '&', 331, ')', 257, '*', 341, '-', 338, '0', \
448, ';', 499, '<', 272, '>', 275, '?', 350, '@', 444, \
'\\', 50, '_', 451, '|', 256};
static uint32_t map[] = {'\n', 285, '!', 261, '"', 360, \
'#', 375, '$', 358, '&', 323, '\'', 197, '(', 248, '*', \
336, '-', 332, '0', 438, ';', 490, '<', 266, '>', 270, \
'?', 343, '@', 436, '\\', 19, '_', 441, '`', 395, '|', \
251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map421(t_lexer *lexer, \
static inline bool lex_normal_map414(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 291, '!', 266, '"', 368, \
'#', 383, '$', 366, '&', 331, '\'', 200, '(', 251, '*', \
344, '-', 340, '0', 447, ';', 499, '<', 272, '>', 275, \
'?', 351, '@', 445, '\\', 22, '_', 450, '`', 403, 'e', \
412, '|', 256};
static uint32_t map[] = {'\n', 288, '!', 261, '"', 360, \
'#', 375, '$', 358, '&', 323, '\'', 197, '*', 336, '-', \
332, '0', 438, ';', 490, '<', 266, '>', 270, '?', 343, \
'@', 436, '\\', 25, '_', 441, '`', 395, 'e', 404, '|', \
251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map422(t_lexer *lexer, \
static inline bool lex_normal_map415(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 294, '!', 266, '"', 368, \
'#', 383, '$', 366, '&', 331, '\'', 200, '(', 251, ')', \
257, '*', 344, '-', 340, '0', 447, ';', 499, '<', 272, \
'>', 275, '?', 351, '@', 445, '\\', 19, '_', 450, '`', \
403, '|', 256};
static uint32_t map[] = {'\n', 289, '!', 260, '#', 375, \
'$', 357, '&', 323, '*', 333, '-', 330, '0', 439, ';', \
490, '<', 266, '>', 270, '?', 342, '@', 435, '\\', 52, \
'_', 442, 'e', 409, '|', 251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));

54
parser/static/lex_funcs/lex_normal/inline/inline_impl12.h
View file

@ -19,63 +19,63 @@
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map423(t_lexer *lexer, \
static inline bool lex_normal_map416(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 295, '!', 265, '#', 383, \
'$', 365, '&', 331, '*', 341, '-', 338, '0', 448, ';', \
499, '<', 272, '>', 275, '?', 350, '@', 444, '\\', 52, \
'_', 451, 'e', 417, '|', 256};
static uint32_t map[] = {'\n', 290, '!', 261, '"', 360, \
'#', 375, '$', 358, '&', 323, '\'', 197, '(', 248, ')', \
252, '*', 336, '-', 332, '0', 438, ';', 490, '<', 266, \
'>', 270, '?', 343, '@', 436, '\\', 22, '_', 441, '`', \
395, '|', 251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map424(t_lexer *lexer, \
static inline bool lex_normal_map417(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 296, '!', 266, '"', 368, \
'#', 383, '$', 366, '&', 331, '\'', 200, '*', 344, '-', \
340, '0', 447, ';', 499, '<', 272, '>', 275, '?', 351, \
'@', 445, '\\', 28, '_', 450, '`', 403, 'e', 412, '|', \
256};
static uint32_t map[] = {'\n', 293, '!', 260, '#', 375, \
'$', 357, '&', 323, '*', 333, '-', 330, '0', 439, ';', \
490, '<', 266, '>', 270, '?', 342, '@', 435, '\\', 54, \
'_', 442, '`', 395, '|', 251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map425(t_lexer *lexer, \
static inline bool lex_normal_map418(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 299, '!', 266, '"', 368, \
'#', 383, '$', 366, '&', 331, '\'', 200, '*', 344, '-', \
340, '0', 447, ';', 499, '<', 272, '>', 275, '?', 351, \
'@', 445, '\\', 25, '_', 450, '`', 403, '|', 256};
static uint32_t map[] = {'\n', 294, '!', 261, '"', 360, \
'#', 375, '$', 358, '&', 323, '\'', 197, '*', 336, '-', \
332, '0', 438, ';', 490, '<', 266, '>', 270, '?', 343, \
'@', 436, '\\', 28, '_', 441, '`', 395, '|', 251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map426(t_lexer *lexer, \
static inline bool lex_normal_map419(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 300, '!', 265, '#', 383, \
'$', 365, '&', 331, '*', 341, '-', 338, '0', 448, ';', \
499, '<', 272, '>', 275, '?', 350, '@', 444, '\\', 54, \
'_', 451, '`', 403, '|', 256};
static uint32_t map[] = {'\n', 295, '!', 260, '#', 375, \
'$', 357, '&', 323, '*', 333, '-', 330, '0', 439, ';', \
490, '<', 266, '>', 270, '?', 342, '@', 435, '\\', 56, \
'_', 442, '|', 251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map427(t_lexer *lexer, \
static inline bool lex_normal_map420(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 301, '!', 266, '"', 368, \
'#', 383, '$', 366, '&', 331, '\'', 200, ')', 257, '*', \
344, '-', 340, '0', 447, ';', 499, '<', 272, '>', 275, \
'?', 351, '@', 445, '\\', 31, '_', 450, '`', 403, '|', \
256};
static uint32_t map[] = {'\n', 296, '!', 261, '"', 360, \
'#', 375, '$', 358, '&', 323, '\'', 197, ')', 252, '*', \
336, '-', 332, '0', 438, ';', 490, '<', 266, '>', 270, \
'?', 343, '@', 436, '\\', 31, '_', 441, '`', 395, '|', \
251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));

49
parser/static/lex_funcs/lex_normal/inline/inline_impl13.h
View file

@ -19,61 +19,60 @@
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map428(t_lexer *lexer, \
static inline bool lex_normal_map421(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 302, '!', 265, '#', 383, \
'$', 365, '&', 331, '*', 341, '-', 338, '0', 448, ';', \
499, '<', 272, '>', 275, '?', 350, '@', 444, '\\', 56, \
'_', 451, '|', 256};
static uint32_t map[] = {'\n', 297, '!', 260, '#', 375, \
'$', 357, '&', 196, '*', 333, '-', 330, '0', 439, '<', \
266, '>', 270, '?', 342, '@', 435, '\\', 63, '_', 442, \
'|', 251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map429(t_lexer *lexer, \
static inline bool lex_normal_map422(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 303, '!', 266, '"', 368, \
'#', 383, '$', 366, '&', 199, '\'', 200, '(', 251, '*', \
344, '-', 340, '0', 447, '<', 272, '>', 275, '?', 351, \
'@', 445, '\\', 36, '_', 450, '`', 403, '|', 256};
static uint32_t map[] = {'\n', 298, '!', 261, '"', 360, \
'#', 375, '$', 358, '&', 196, '\'', 197, '(', 248, '*', \
336, '-', 332, '0', 438, '<', 266, '>', 270, '?', 343, \
'@', 436, '\\', 36, '_', 441, '`', 395, '|', 251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map430(t_lexer *lexer, \
static inline bool lex_normal_map423(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 304, '!', 265, '#', 383, \
'$', 365, '&', 199, '*', 341, '-', 338, '0', 448, '<', \
272, '>', 275, '?', 350, '@', 444, '\\', 63, '_', 451, \
'|', 256};
static uint32_t map[] = {'\n', 299, '!', 260, '#', 375, \
'$', 357, '&', 322, '*', 333, '-', 330, '0', 439, ';', \
490, '?', 342, '@', 435, '\\', 76, '_', 442, 'i', 408};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map431(t_lexer *lexer, \
static inline bool lex_normal_map424(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 305, '!', 266, '"', 368, \
'#', 383, '$', 366, '&', 199, '\'', 200, '*', 344, '-', \
340, '0', 447, '<', 272, '>', 275, '?', 351, '@', 445, \
'\\', 39, '_', 450, '`', 403, '|', 256};
static uint32_t map[] = {'\n', 300, '!', 261, '"', 360, \
'#', 375, '$', 358, '&', 196, '\'', 197, '*', 336, '-', \
332, '0', 438, '<', 266, '>', 270, '?', 343, '@', 436, \
'\\', 39, '_', 441, '`', 395, '|', 251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map432(t_lexer *lexer, \
static inline bool lex_normal_map425(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 306, '!', 265, '#', 383, \
'$', 365, '&', 199, '*', 341, '-', 338, '0', 448, '<', \
270, '>', 275, '?', 350, '@', 444, '\\', 97, '_', 451, \
'|', 217};
static uint32_t map[] = {'\n', 301, '!', 261, '"', 360, \
'#', 375, '$', 358, '&', 196, '\'', 197, '*', 336, '-', \
332, '0', 438, '<', 267, '>', 270, '?', 343, '@', 436, \
'\\', 94, '_', 441, '`', 395, '|', 214};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));

47
parser/static/lex_funcs/lex_normal/inline/inline_impl14.h
View file

@ -19,59 +19,60 @@
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map433(t_lexer *lexer, \
static inline bool lex_normal_map426(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 307, '!', 266, '"', 368, \
'#', 383, '$', 366, '&', 199, '\'', 200, '*', 344, '-', \
340, '0', 447, '<', 270, '>', 275, '?', 351, '@', 445, \
'\\', 94, '_', 450, '`', 403, '|', 217};
static uint32_t map[] = {'\n', 302, '!', 261, '"', 360, \
'#', 375, '$', 358, '&', 322, '\'', 197, '*', 336, '-', \
332, '0', 438, ';', 490, '?', 343, '@', 436, '\\', 68, \
'_', 441, '`', 395};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map434(t_lexer *lexer, \
static inline bool lex_normal_map427(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 308, '!', 265, '#', 383, \
'$', 365, '&', 330, '*', 341, '-', 338, '0', 448, ';', \
499, '?', 350, '@', 444, '\\', 76, '_', 451, 'i', 416};
static uint32_t map[] = {'\n', 303, '!', 261, '"', 360, \
'#', 375, '$', 358, '\'', 197, '*', 336, '-', 332, '0', \
438, '?', 343, '@', 436, '\\', 72, '_', 441, '`', 395};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map435(t_lexer *lexer, \
static inline bool lex_normal_map428(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 309, '!', 266, '"', 368, \
'#', 383, '$', 366, '&', 330, '\'', 200, '*', 344, '-', \
340, '0', 447, ';', 499, '?', 351, '@', 445, '\\', 68, \
'_', 450, '`', 403};
static uint32_t map[] = {'!', 261, '"', 360, '#', 375, \
'$', 358, '&', 196, '\'', 197, '(', 248, '*', 336, '-', \
332, '0', 438, '<', 266, '>', 270, '?', 343, '@', 436, \
'\\', 42, '_', 441, '`', 395, '|', 251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map436(t_lexer *lexer, \
static inline bool lex_normal_map429(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 310, '!', 266, '"', 368, \
'#', 383, '$', 366, '\'', 200, '*', 344, '-', 340, '0', \
447, '?', 351, '@', 445, '\\', 72, '_', 450, '`', 403};
static uint32_t map[] = {'!', 261, '"', 360, '#', 375, \
'$', 358, '&', 196, '\'', 197, '*', 336, '-', 332, '0', \
438, '<', 266, '>', 270, '?', 343, '@', 436, '\\', 45, \
'_', 441, '`', 395, '|', 251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map437(t_lexer *lexer, \
static inline bool lex_normal_map430(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 266, '"', 368, '#', 383, \
'$', 366, '&', 199, '\'', 200, '(', 251, '*', 344, '-', \
340, '0', 447, '<', 272, '>', 275, '?', 351, '@', 445, \
'\\', 42, '_', 450, '`', 403, '|', 256};
static uint32_t map[] = {'!', 261, '"', 360, '#', 375, \
'$', 358, '\'', 197, '*', 336, '-', 332, '0', 438, '<', \
267, '>', 270, '?', 343, '@', 436, '\\', 60, '_', 441, \
'`', 395};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));

42
parser/static/lex_funcs/lex_normal/inline/inline_impl15.h
View file

@ -19,58 +19,56 @@
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map438(t_lexer *lexer, \
static inline bool lex_normal_map431(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 266, '"', 368, '#', 383, \
'$', 366, '&', 199, '\'', 200, '*', 344, '-', 340, '0', \
447, '<', 272, '>', 275, '?', 351, '@', 445, '\\', 45, \
'_', 450, '`', 403, '|', 256};
static uint32_t map[] = {'!', 260, '#', 375, '$', 357, \
'&', 196, '*', 333, '-', 330, '0', 439, '<', 266, '>', \
270, '?', 342, '@', 435, '\\', 65, '_', 442, '|', 251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map439(t_lexer *lexer, \
static inline bool lex_normal_map432(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 266, '"', 368, '#', 383, \
'$', 366, '\'', 200, '*', 344, '-', 340, '0', 447, '<', \
270, '>', 275, '?', 351, '@', 445, '\\', 60, '_', 450, \
'`', 403};
static uint32_t map[] = {'!', 260, '#', 375, '$', 357, \
')', 252, '*', 333, '-', 330, '0', 439, '?', 342, '@', \
435, '\\', 81, '_', 442, '|', 249};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map440(t_lexer *lexer, \
static inline bool lex_normal_map433(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 265, '#', 383, '$', 365, \
'&', 199, '*', 341, '-', 338, '0', 448, '<', 272, '>', \
275, '?', 350, '@', 444, '\\', 65, '_', 451, '|', 256};
static uint32_t map[] = {'!', 260, '#', 375, '$', 357, \
'*', 333, '-', 330, '0', 439, '?', 342, '@', 435, '\\', \
86, '_', 442};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map441(t_lexer *lexer, \
static inline bool lex_normal_map444(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 265, '#', 383, '$', 365, \
')', 257, '*', 341, '-', 338, '0', 448, '?', 350, '@', \
444, '\\', 80, '_', 451, '|', 252};
static uint32_t map[] = {'\n', 282, '!', 261, '#', 376, \
'*', 336, '-', 332, '0', 438, '?', 343, '@', 436, '\\', \
12, '_', 441, 'e', 404};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map442(t_lexer *lexer, \
static inline bool lex_normal_map445(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 265, '#', 383, '$', 365, \
'*', 341, '-', 338, '0', 448, '?', 350, '@', 444, '\\', \
86, '_', 451};
static uint32_t map[] = {'\n', 285, '!', 261, '#', 376, \
'*', 336, '-', 332, '0', 438, '?', 343, '@', 436, '\\', \
18, '_', 441};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));

78
parser/static/lex_funcs/lex_normal/inline/inline_impl16.h
View file

@ -19,12 +19,45 @@
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map448(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 288, '!', 261, '#', 376, \
'*', 336, '-', 332, '0', 438, '?', 343, '@', 436, '\\', \
24, '_', 441, 'e', 404};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map449(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 290, '!', 261, '#', 376, \
'*', 336, '-', 332, '0', 438, '?', 343, '@', 436, '\\', \
21, '_', 441};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map452(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 294, '!', 261, '#', 376, \
'*', 336, '-', 332, '0', 438, '?', 343, '@', 436, '\\', \
27, '_', 441};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map453(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 288, '!', 266, '#', 384, \
'*', 344, '-', 340, '0', 447, '?', 351, '@', 445, '\\', \
12, '_', 450};
static uint32_t map[] = {'\n', 296, '!', 261, '#', 376, \
'*', 336, '-', 332, '0', 438, '?', 343, '@', 436, '\\', \
30, '_', 441};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -33,42 +66,9 @@ static inline bool lex_normal_map453(t_lexer *lexer, \
static inline bool lex_normal_map454(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 291, '!', 266, '#', 384, \
'*', 344, '-', 340, '0', 447, '?', 351, '@', 445, '\\', \
21, '_', 450, 'e', 412};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map457(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 294, '!', 266, '#', 384, \
'*', 344, '-', 340, '0', 447, '?', 351, '@', 445, '\\', \
18, '_', 450};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map458(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 296, '!', 266, '#', 384, \
'*', 344, '-', 340, '0', 447, '?', 351, '@', 445, '\\', \
27, '_', 450, 'e', 412};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map461(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 299, '!', 266, '#', 384, \
'*', 344, '-', 340, '0', 447, '?', 351, '@', 445, '\\', \
24, '_', 450};
static uint32_t map[] = {'\n', 298, '!', 261, '#', 376, \
'*', 336, '-', 332, '0', 438, '?', 343, '@', 436, '\\', \
35, '_', 441};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));

42
parser/static/lex_funcs/lex_normal/inline/inline_impl17.h
View file

@ -19,56 +19,58 @@
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map462(t_lexer *lexer, \
static inline bool lex_normal_map455(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 301, '!', 266, '#', 384, \
'*', 344, '-', 340, '0', 447, '?', 351, '@', 445, '\\', \
30, '_', 450};
static uint32_t map[] = {'\n', 300, '!', 261, '#', 376, \
'*', 336, '-', 332, '0', 438, '?', 343, '@', 436, '\\', \
38, '_', 441};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map463(t_lexer *lexer, \
static inline bool lex_normal_map456(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 303, '!', 266, '#', 384, \
'*', 344, '-', 340, '0', 447, '?', 351, '@', 445, '\\', \
35, '_', 450};
static uint32_t map[] = {'\n', 301, '!', 261, '#', 376, \
'*', 336, '-', 332, '0', 438, '?', 343, '@', 436, '\\', \
93, '_', 441};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map464(t_lexer *lexer, \
static inline bool lex_normal_map457(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 305, '!', 266, '#', 384, \
'*', 344, '-', 340, '0', 447, '?', 351, '@', 445, '\\', \
38, '_', 450};
static uint32_t map[] = {'\n', 302, '!', 261, '#', 376, \
'*', 336, '-', 332, '0', 438, '?', 343, '@', 436, '\\', \
67, '_', 441};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map465(t_lexer *lexer, \
static inline bool lex_normal_map458(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 307, '!', 266, '#', 384, \
'*', 344, '-', 340, '0', 447, '?', 351, '@', 445, '\\', \
93, '_', 450};
static uint32_t map[] = {'\n', 303, '!', 261, '#', 376, \
'*', 336, '-', 332, '0', 438, '?', 343, '@', 436, '\\', \
71, '_', 441};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map466(t_lexer *lexer, \
static inline bool lex_normal_map459(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 309, '!', 266, '#', 384, \
'*', 344, '-', 340, '0', 447, '?', 351, '@', 445, '\\', \
67, '_', 450};
static uint32_t map[] = {'!', 261, '#', 376, '%', 339, \
'*', 334, '+', 351, '-', 349, '/', 337, '0', 437, ':', \
346, '=', 264, '?', 343, '@', 436, '\\', 115, '^', 320, \
'_', 440, 'd', 486, 'e', 483, 'f', 481, 'i', 485, '{', \
255, '}', 257, '~', 353};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));

48
parser/static/lex_funcs/lex_normal/inline/inline_impl18.h
View file

@ -19,58 +19,34 @@
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map467(t_lexer *lexer, \
static inline bool lex_normal_map460(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 310, '!', 266, '#', 384, \
'*', 344, '-', 340, '0', 447, '?', 351, '@', 445, '\\', \
71, '_', 450};
static uint32_t map[] = {'!', 261, '#', 376, '*', 336, \
'-', 332, '0', 438, '?', 343, '@', 436, '\\', 41, '_', \
441};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map468(t_lexer *lexer, \
static inline bool lex_normal_map461(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 266, '#', 384, '%', 347, \
'*', 342, '+', 359, '-', 357, '/', 345, '0', 446, ':', \
354, '=', 269, '?', 351, '@', 445, '\\', 118, '^', 328, \
'_', 449, 'd', 495, 'e', 492, 'f', 490, 'i', 494, '{', \
260, '}', 262, '~', 361};
static uint32_t map[] = {'!', 261, '#', 376, '*', 336, \
'-', 332, '0', 438, '?', 343, '@', 436, '\\', 44, '_', \
441};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map469(t_lexer *lexer, \
static inline bool lex_normal_map462(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 266, '#', 384, '*', 344, \
'-', 340, '0', 447, '?', 351, '@', 445, '\\', 41, '_', \
450};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map470(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 266, '#', 384, '*', 344, \
'-', 340, '0', 447, '?', 351, '@', 445, '\\', 44, '_', \
450};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map471(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 266, '#', 384, '*', 344, \
'-', 340, '0', 447, '?', 351, '@', 445, '\\', 59, '_', \
450};
static uint32_t map[] = {'!', 261, '#', 376, '*', 336, \
'-', 332, '0', 438, '?', 343, '@', 436, '\\', 59, '_', \
441};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));

69
parser/static/lex_funcs/lex_normal/inline/inline_impl2.h
View file

@ -19,12 +19,35 @@
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map102(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 291, '"', 360, '#', 400, \
'$', 358, '&', 323, '\'', 197, '(', 248, ')', 252, ';', \
490, '<', 266, '>', 270, '\\', 139, '`', 396, '|', 251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map103(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 292, '"', 360, '#', 400, \
'$', 358, '&', 323, '\'', 197, '(', 248, ';', 490, '<', \
266, '>', 270, '\\', 141, '`', 396, 'e', 487, '|', 251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map104(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 297, '"', 368, '#', 408, \
'$', 366, '&', 331, '\'', 200, '(', 251, ')', 257, ';', \
499, '<', 272, '>', 275, '\\', 142, '`', 404, '|', 256};
static uint32_t map[] = {'\n', 293, '!', 260, '#', 375, \
'$', 357, '&', 323, '*', 333, '-', 330, '0', 439, ';', \
490, '<', 266, '>', 270, '?', 342, '@', 435, '\\', 54, \
'_', 442, '`', 395, '|', 251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -33,9 +56,10 @@ static inline bool lex_normal_map104(t_lexer *lexer, \
static inline bool lex_normal_map105(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 298, '"', 368, '#', 408, \
'$', 366, '&', 331, '\'', 200, '(', 251, ';', 499, '<', \
272, '>', 275, '\\', 146, '`', 404, 'e', 496, '|', 256};
static uint32_t map[] = {'\n', 294, '!', 261, '"', 360, \
'#', 375, '$', 358, '&', 323, '\'', 197, '*', 336, '-', \
332, '0', 438, ';', 490, '<', 266, '>', 270, '?', 343, \
'@', 436, '\\', 28, '_', 441, '`', 395, '|', 251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -44,35 +68,10 @@ static inline bool lex_normal_map105(t_lexer *lexer, \
static inline bool lex_normal_map106(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 299, '!', 266, '"', 368, \
'#', 383, '$', 366, '&', 331, '\'', 200, '*', 344, '-', \
340, '0', 447, ';', 499, '<', 272, '>', 275, '?', 351, \
'@', 445, '\\', 25, '_', 450, '`', 403, '|', 256};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map107(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 300, '!', 265, '#', 383, \
'$', 365, '&', 331, '*', 341, '-', 338, '0', 448, ';', \
499, '<', 272, '>', 275, '?', 350, '@', 444, '\\', 54, \
'_', 451, '`', 403, '|', 256};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map108(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 301, '!', 266, '"', 368, \
'#', 383, '$', 366, '&', 331, '\'', 200, ')', 257, '*', \
344, '-', 340, '0', 447, ';', 499, '<', 272, '>', 275, \
'?', 351, '@', 445, '\\', 31, '_', 450, '`', 403, '|', \
256};
static uint32_t map[] = {'\n', 295, '!', 260, '#', 375, \
'$', 357, '&', 323, '*', 333, '-', 330, '0', 439, ';', \
490, '<', 266, '>', 270, '?', 342, '@', 435, '\\', 56, \
'_', 442, '|', 251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));

72
parser/static/lex_funcs/lex_normal/inline/inline_impl3.h
View file

@ -19,13 +19,38 @@
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map107(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 296, '!', 261, '"', 360, \
'#', 375, '$', 358, '&', 323, '\'', 197, ')', 252, '*', \
336, '-', 332, '0', 438, ';', 490, '<', 266, '>', 270, \
'?', 343, '@', 436, '\\', 31, '_', 441, '`', 395, '|', \
251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map108(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 297, '!', 260, '#', 375, \
'$', 357, '&', 196, '*', 333, '-', 330, '0', 439, '<', \
266, '>', 270, '?', 342, '@', 435, '\\', 63, '_', 442, \
'|', 251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map109(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 302, '!', 265, '#', 383, \
'$', 365, '&', 331, '*', 341, '-', 338, '0', 448, ';', \
499, '<', 272, '>', 275, '?', 350, '@', 444, '\\', 56, \
'_', 451, '|', 256};
static uint32_t map[] = {'\n', 298, '!', 261, '"', 360, \
'#', 375, '$', 358, '&', 196, '\'', 197, '(', 248, '*', \
336, '-', 332, '0', 438, '<', 266, '>', 270, '?', 343, \
'@', 436, '\\', 36, '_', 441, '`', 395, '|', 251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -34,10 +59,9 @@ static inline bool lex_normal_map109(t_lexer *lexer, \
static inline bool lex_normal_map110(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 303, '!', 266, '"', 368, \
'#', 383, '$', 366, '&', 199, '\'', 200, '(', 251, '*', \
344, '-', 340, '0', 447, '<', 272, '>', 275, '?', 351, \
'@', 445, '\\', 36, '_', 450, '`', 403, '|', 256};
static uint32_t map[] = {'\n', 299, '!', 260, '#', 375, \
'$', 357, '&', 322, '*', 333, '-', 330, '0', 439, ';', \
490, '?', 342, '@', 435, '\\', 76, '_', 442, 'i', 408};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -46,34 +70,10 @@ static inline bool lex_normal_map110(t_lexer *lexer, \
static inline bool lex_normal_map111(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 304, '!', 265, '#', 383, \
'$', 365, '&', 199, '*', 341, '-', 338, '0', 448, '<', \
272, '>', 275, '?', 350, '@', 444, '\\', 63, '_', 451, \
'|', 256};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map112(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 305, '!', 266, '"', 368, \
'#', 383, '$', 366, '&', 199, '\'', 200, '*', 344, '-', \
340, '0', 447, '<', 272, '>', 275, '?', 351, '@', 445, \
'\\', 39, '_', 450, '`', 403, '|', 256};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map113(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 306, '!', 265, '#', 383, \
'$', 365, '&', 199, '*', 341, '-', 338, '0', 448, '<', \
270, '>', 275, '?', 350, '@', 444, '\\', 97, '_', 451, \
'|', 217};
static uint32_t map[] = {'\n', 300, '!', 261, '"', 360, \
'#', 375, '$', 358, '&', 196, '\'', 197, '*', 336, '-', \
332, '0', 438, '<', 266, '>', 270, '?', 343, '@', 436, \
'\\', 39, '_', 441, '`', 395, '|', 251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));

79
parser/static/lex_funcs/lex_normal/inline/inline_impl4.h
View file

@ -19,62 +19,63 @@
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map112(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 301, '!', 261, '"', 360, \
'#', 375, '$', 358, '&', 196, '\'', 197, '*', 336, '-', \
332, '0', 438, '<', 267, '>', 270, '?', 343, '@', 436, \
'\\', 94, '_', 441, '`', 395, '|', 214};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map113(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 302, '!', 261, '"', 360, \
'#', 375, '$', 358, '&', 322, '\'', 197, '*', 336, '-', \
332, '0', 438, ';', 490, '?', 343, '@', 436, '\\', 68, \
'_', 441, '`', 395};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map114(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 307, '!', 266, '"', 368, \
'#', 383, '$', 366, '&', 199, '\'', 200, '*', 344, '-', \
340, '0', 447, '<', 270, '>', 275, '?', 351, '@', 445, \
'\\', 94, '_', 450, '`', 403, '|', 217};
static uint32_t map[] = {'\n', 303, '!', 261, '"', 360, \
'#', 375, '$', 358, '\'', 197, '*', 336, '-', 332, '0', \
438, '?', 343, '@', 436, '\\', 72, '_', 441, '`', 395};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map115(t_lexer *lexer, \
static inline bool lex_normal_map164(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 308, '!', 265, '#', 383, \
'$', 365, '&', 330, '*', 341, '-', 338, '0', 448, ';', \
499, '?', 350, '@', 444, '\\', 76, '_', 451, 'i', 416};
static uint32_t map[] = {'!', 261, '"', 360, '#', 375, \
'$', 358, '%', 339, '&', 324, '\'', 197, '(', 248, ')', \
252, '*', 334, '+', 351, '-', 349, '/', 337, '0', 437, \
':', 346, ';', 490, '<', 265, '=', 264, '>', 269, '?', \
343, '@', 436, '\\', 116, '^', 320, '_', 440, '`', 396, \
'd', 486, 'e', 483, 'f', 481, 'i', 485, '{', 255, '|', \
250, '}', 257, '~', 353};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map116(t_lexer *lexer, \
static inline bool lex_normal_map165(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 309, '!', 266, '"', 368, \
'#', 383, '$', 366, '&', 330, '\'', 200, '*', 344, '-', \
340, '0', 447, ';', 499, '?', 351, '@', 445, '\\', 68, \
'_', 450, '`', 403};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map117(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 310, '!', 266, '"', 368, \
'#', 383, '$', 366, '\'', 200, '*', 344, '-', 340, '0', \
447, '?', 351, '@', 445, '\\', 72, '_', 450, '`', 403};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map167(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 266, '"', 368, '#', 383, \
'$', 366, '%', 347, '&', 332, '\'', 200, '(', 251, ')', \
257, '*', 342, '+', 359, '-', 357, '/', 345, '0', 446, \
':', 354, ';', 499, '<', 271, '=', 269, '>', 274, '?', \
351, '@', 445, '\\', 119, '^', 328, '_', 449, '`', 404, \
'd', 495, 'e', 492, 'f', 490, 'i', 494, '{', 260, '|', \
253, '}', 262, '~', 361};
static uint32_t map[] = {'!', 261, '"', 360, '#', 375, \
'$', 358, '&', 196, '\'', 197, '(', 248, '*', 336, '-', \
332, '0', 438, '<', 266, '>', 270, '?', 343, '@', 436, \
'\\', 42, '_', 441, '`', 395, '|', 251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));

67
parser/static/lex_funcs/lex_normal/inline/inline_impl5.h
View file

@ -19,13 +19,36 @@
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map166(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 261, '"', 360, '#', 375, \
'$', 358, '&', 196, '\'', 197, '*', 336, '-', 332, '0', \
438, '<', 266, '>', 270, '?', 343, '@', 436, '\\', 45, \
'_', 441, '`', 395, '|', 251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map167(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 261, '"', 360, '#', 375, \
'$', 358, '\'', 197, '*', 336, '-', 332, '0', 438, '<', \
267, '>', 270, '?', 343, '@', 436, '\\', 60, '_', 441, \
'`', 395};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map168(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 266, '"', 368, '#', 383, \
'$', 366, '&', 199, '\'', 200, '(', 251, '*', 344, '-', \
340, '0', 447, '<', 272, '>', 275, '?', 351, '@', 445, \
'\\', 42, '_', 450, '`', 403, '|', 256};
static uint32_t map[] = {'!', 261, '"', 360, '#', 400, \
'$', 358, '\'', 197, '(', 248, ')', 252, ';', 201, '<', \
267, '>', 270, '\\', 119, '`', 395, '{', 255};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -34,10 +57,9 @@ static inline bool lex_normal_map168(t_lexer *lexer, \
static inline bool lex_normal_map169(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 266, '"', 368, '#', 383, \
'$', 366, '&', 199, '\'', 200, '*', 344, '-', 340, '0', \
447, '<', 272, '>', 275, '?', 351, '@', 445, '\\', 45, \
'_', 450, '`', 403, '|', 256};
static uint32_t map[] = {'!', 261, '"', 360, '#', 400, \
'$', 358, '\'', 197, '(', 248, ';', 201, '<', 267, '>', \
270, '\\', 145, '`', 395, 'e', 487, '{', 255};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -46,32 +68,9 @@ static inline bool lex_normal_map169(t_lexer *lexer, \
static inline bool lex_normal_map170(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 266, '"', 368, '#', 383, \
'$', 366, '\'', 200, '*', 344, '-', 340, '0', 447, '<', \
270, '>', 275, '?', 351, '@', 445, '\\', 60, '_', 450, \
'`', 403};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map171(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 266, '"', 368, '#', 408, \
'$', 366, '\'', 200, '(', 251, ')', 257, ';', 204, '<', \
270, '>', 275, '\\', 122, '`', 403, '{', 260};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map172(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 266, '"', 368, '#', 408, \
'$', 366, '\'', 200, '(', 251, ';', 204, '<', 270, '>', \
275, '\\', 148, '`', 403, 'e', 496, '{', 260};
static uint32_t map[] = {'!', 261, '"', 360, '#', 400, \
'$', 358, '\'', 197, '(', 248, '<', 267, '>', 270, '\\', \
121, '`', 395, 'e', 484, 'f', 481, '{', 255};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));

62
parser/static/lex_funcs/lex_normal/inline/inline_impl6.h
View file

@ -19,12 +19,34 @@
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map171(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 261, '"', 360, '#', 400, \
'$', 358, '\'', 197, '(', 248, '<', 267, '>', 270, '\\', \
126, '`', 395, 'd', 486, '{', 255};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map172(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 261, '"', 360, '#', 400, \
'$', 358, '\'', 197, '(', 248, '<', 267, '>', 270, '\\', \
128, '`', 395, 'f', 481, '{', 255};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map173(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 266, '"', 368, '#', 408, \
'$', 366, '\'', 200, '(', 251, '<', 270, '>', 275, '\\', \
124, '`', 403, 'e', 493, 'f', 490, '{', 260};
static uint32_t map[] = {'!', 261, '"', 360, '#', 400, \
'$', 358, '\'', 197, '(', 248, '<', 267, '>', 270, '\\', \
130, '`', 395, '{', 255, '}', 257};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -33,9 +55,9 @@ static inline bool lex_normal_map173(t_lexer *lexer, \
static inline bool lex_normal_map174(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 266, '"', 368, '#', 408, \
'$', 366, '\'', 200, '(', 251, '<', 270, '>', 275, '\\', \
129, '`', 403, 'd', 495, '{', 260};
static uint32_t map[] = {'!', 202, '#', 400, '%', 341, \
'&', 324, ')', 252, '*', 335, '+', 329, '-', 331, '/', \
338, '<', 268, '=', 263, '>', 271, '?', 342};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -44,31 +66,9 @@ static inline bool lex_normal_map174(t_lexer *lexer, \
static inline bool lex_normal_map175(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 266, '"', 368, '#', 408, \
'$', 366, '\'', 200, '(', 251, '<', 270, '>', 275, '\\', \
131, '`', 403, '{', 260, '}', 262};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map176(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 266, '"', 368, '#', 408, \
'$', 366, '\'', 200, '(', 251, '<', 270, '>', 275, '\\', \
133, '`', 403, 'f', 490, '{', 260};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map177(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 205, '#', 408, '%', 349, \
'&', 332, ')', 257, '*', 343, '+', 337, '-', 339, '/', \
346, '<', 273, '=', 268, '>', 276, '?', 350};
static uint32_t map[] = {'!', 260, '"', 360, '#', 375, \
'$', 357, '*', 333, '-', 330, '0', 439, '?', 342, '@', \
435, '\\', 79, '_', 442};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));

61
parser/static/lex_funcs/lex_normal/inline/inline_impl7.h
View file

@ -19,12 +19,34 @@
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map176(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 260, '"', 360, '#', 400, \
'$', 359, '&', 196, '(', 248, ')', 199, '+', 352, '-', \
350, '<', 266, '=', 262, '>', 270};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map177(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 260, '#', 375, '$', 357, \
'&', 196, '*', 333, '-', 330, '0', 439, '<', 266, '>', \
270, '?', 342, '@', 435, '\\', 65, '_', 442, '|', 251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map178(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 265, '"', 368, '#', 383, \
'$', 365, '*', 341, '-', 338, '0', 448, '?', 350, '@', \
444, '\\', 81, '_', 451};
static uint32_t map[] = {'!', 260, '#', 375, '$', 357, \
')', 252, '*', 333, '-', 330, '0', 439, '?', 342, '@', \
435, '\\', 81, '_', 442, '|', 249};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -33,9 +55,9 @@ static inline bool lex_normal_map178(t_lexer *lexer, \
static inline bool lex_normal_map179(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 265, '"', 368, '#', 408, \
'$', 367, '&', 199, '(', 251, ')', 202, '+', 360, '-', \
358, '<', 272, '=', 267, '>', 275};
static uint32_t map[] = {'!', 260, '#', 375, '$', 357, \
'*', 333, '-', 330, '0', 439, '?', 342, '@', 435, '\\', \
83, '_', 442};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -44,31 +66,8 @@ static inline bool lex_normal_map179(t_lexer *lexer, \
static inline bool lex_normal_map180(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 265, '#', 383, '$', 365, \
'&', 199, '*', 341, '-', 338, '0', 448, '<', 272, '>', \
275, '?', 350, '@', 444, '\\', 65, '_', 451, '|', 256};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map181(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 265, '#', 383, '$', 365, \
')', 257, '*', 341, '-', 338, '0', 448, '?', 350, '@', \
444, '\\', 80, '_', 451, '|', 252};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map182(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 265, '#', 383, '$', 365, \
'*', 341, '-', 338, '0', 448, '?', 350, '@', 444, '\\', \
83, '_', 451};
static uint32_t map[] = {'!', 260, '#', 375, '$', 357, \
'*', 333, '-', 330, '0', 439, '?', 342, '@', 435};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));

60
parser/static/lex_funcs/lex_normal/inline/inline_impl8.h
View file

@ -19,11 +19,34 @@
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map181(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 260, '#', 375, '$', 357, \
'*', 333, '-', 330, '0', 439, '?', 342, '@', 435, '\\', \
86, '_', 442};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map182(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'"', 360, '#', 400, '$', 358, \
'&', 196, '\'', 197, '(', 248, '<', 266, '>', 270, '\\', \
143, '`', 395, '|', 251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map183(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 265, '#', 383, '$', 365, \
'*', 341, '-', 338, '0', 448, '?', 350, '@', 444};
static uint32_t map[] = {'"', 360, '#', 400, '$', 358, \
'&', 196, '\'', 197, '(', 248, '<', 266, '>', 270, '\\', \
148, '`', 396, '|', 251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -32,9 +55,9 @@ static inline bool lex_normal_map183(t_lexer *lexer, \
static inline bool lex_normal_map184(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 265, '#', 383, '$', 365, \
'*', 341, '-', 338, '0', 448, '?', 350, '@', 444, '\\', \
86, '_', 451};
static uint32_t map[] = {'"', 360, '#', 400, '$', 358, \
'\'', 197, '(', 248, '<', 267, '>', 270, '\\', 132, '`', \
395, '{', 255};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -43,31 +66,8 @@ static inline bool lex_normal_map184(t_lexer *lexer, \
static inline bool lex_normal_map185(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'"', 368, '#', 408, '$', 366, \
'&', 199, '\'', 200, '(', 251, '<', 272, '>', 275, '\\', \
144, '`', 403, '|', 256};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map186(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'"', 368, '#', 408, '$', 366, \
'&', 199, '\'', 200, '(', 251, '<', 272, '>', 275, '\\', \
150, '`', 404, '|', 256};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map187(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'"', 368, '#', 408, '$', 366, \
'\'', 200, '(', 251, '<', 270, '>', 275, '\\', 135, '`', \
403, '{', 260};
static uint32_t map[] = {'"', 360, '#', 400, '$', 358, \
'\'', 197, '(', 248, '\\', 150, '`', 395, 'e', 487};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));

72
parser/static/lex_funcs/lex_normal/inline/inline_impl9.h
View file

@ -19,24 +19,48 @@
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map188(t_lexer *lexer, \
static inline bool lex_normal_map221(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'"', 368, '#', 408, '$', 366, \
'\'', 200, '(', 251, '\\', 153, '`', 403, 'e', 496};
static uint32_t map[] = {'\n', 285, '!', 261, '"', 360, \
'#', 375, '$', 358, '&', 323, '\'', 197, '(', 248, '*', \
336, '-', 332, '0', 438, ';', 490, '<', 266, '>', 270, \
'?', 343, '@', 436, '\\', 19, '_', 441, '`', 395, '|', \
251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map219(t_lexer *lexer, \
static inline bool lex_normal_map222(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 288, '!', 266, '"', 368, \
'#', 383, '$', 366, '&', 331, '\'', 200, '(', 251, '*', \
344, '-', 340, '0', 447, ';', 499, '<', 272, '>', 275, \
'?', 351, '@', 445, '\\', 13, '_', 450, '`', 403, '|', \
256};
static uint32_t map[] = {'\n', 286, '"', 360, '#', 400, \
'$', 358, '&', 323, '\'', 197, '(', 248, ')', 252, ';', \
490, '<', 266, '>', 270, '\\', 134, '`', 395, '|', 251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map223(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 291, '"', 360, '#', 400, \
'$', 358, '&', 323, '\'', 197, '(', 248, ')', 252, ';', \
490, '<', 266, '>', 270, '\\', 139, '`', 396, '|', 251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map224(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 294, '!', 261, '"', 360, \
'#', 375, '$', 358, '&', 323, '\'', 197, '*', 336, '-', \
332, '0', 438, ';', 490, '<', 266, '>', 270, '?', 343, \
'@', 436, '\\', 28, '_', 441, '`', 395, '|', 251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -45,32 +69,10 @@ static inline bool lex_normal_map219(t_lexer *lexer, \
static inline bool lex_normal_map225(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 292, '"', 368, '#', 408, \
'$', 366, '&', 331, '\'', 200, '(', 251, ')', 257, ';', \
499, '<', 272, '>', 275, '\\', 137, '`', 403, '|', 254};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map226(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 297, '"', 368, '#', 408, \
'$', 366, '&', 331, '\'', 200, '(', 251, ')', 257, ';', \
499, '<', 272, '>', 275, '\\', 142, '`', 404, '|', 256};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map227(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 299, '!', 266, '"', 368, \
'#', 383, '$', 366, '&', 331, '\'', 200, '*', 344, '-', \
340, '0', 447, ';', 499, '<', 272, '>', 275, '?', 351, \
'@', 445, '\\', 25, '_', 450, '`', 403, '|', 256};
static uint32_t map[] = {'\n', 295, '!', 260, '#', 375, \
'$', 357, '&', 323, '*', 333, '-', 330, '0', 439, ';', \
490, '<', 266, '>', 270, '?', 342, '@', 435, '\\', 56, \
'_', 442, '|', 251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));

9
parser/static/lex_funcs/lex_normal/lex_normal_funcs.h
View file

@ -513,15 +513,6 @@ bool lex_normal_s487(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s488(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s489(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s490(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s491(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s492(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s493(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s494(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s495(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s496(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s497(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s498(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s499(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_default(t_lexer *lexer, t_lexer_state *s);
#endif // LEX_NORMAL_FUNCS_H

2
parser/static/lex_funcs/lex_normal/main_func.c
View file

@ -19,7 +19,7 @@ bool lex_normal_call(t_lexer *lexer, t_lexer_state *s)
t_lex_normal_array *t;
t = create_lex_normal();
if (s->state < 500)
if (s->state < 491)
{
return (((bool (*)(t_lexer *, t_lexer_state \
*))(t->a[s->state]))(lexer, s));

16
parser/static/lex_funcs/lex_normal/state_0.c
View file

@ -15,39 +15,39 @@
bool lex_normal_s0(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(235, lexer, s));
return (lex_advance(232, lexer, s));
if (lex_normal_map0(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
return (lex_skip(232, lexer, s));
return (lex_skip(229, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(468, lexer, s));
return (lex_advance(459, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(380, lexer, s));
return (lex_advance(372, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s1(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(167, lexer, s));
return (lex_skip(164, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s2(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(171, lexer, s));
return (lex_skip(168, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s3(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(173, lexer, s));
return (lex_skip(170, lexer, s));
return (lex_end_state(lexer, s));
}

14
parser/static/lex_funcs/lex_normal/state_1.c
View file

@ -19,40 +19,40 @@ bool lex_normal_s5(t_lexer *lexer, t_lexer_state *s)
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(5, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(452, lexer, s));
return (lex_advance(443, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(380, lexer, s));
return (lex_advance(372, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '{' && s->lookahead != '|'))
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s6(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(174, lexer, s));
return (lex_skip(171, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s7(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(175, lexer, s));
return (lex_skip(172, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s8(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(176, lexer, s));
return (lex_skip(173, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s9(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(187, lexer, s));
return (lex_skip(184, lexer, s));
return (lex_end_state(lexer, s));
}

14
parser/static/lex_funcs/lex_normal/state_10.c
View file

@ -15,7 +15,7 @@
bool lex_normal_s50(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(420, lexer, s));
return (lex_advance(412, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(49, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
@ -27,37 +27,37 @@ bool lex_normal_s50(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s51(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(423, lexer, s));
return (lex_advance(415, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s52(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(423, lexer, s));
return (lex_advance(415, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(51, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(102, lexer, s));
return (lex_skip(100, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s53(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(426, lexer, s));
return (lex_advance(417, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s54(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(426, lexer, s));
return (lex_advance(417, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(53, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(107, lexer, s));
return (lex_skip(104, lexer, s));
return (lex_end_state(lexer, s));
}

21
parser/static/lex_funcs/lex_normal/state_100.c
View file

@ -1,21 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_100.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#include "./lex_normal_funcs.h"
bool lex_normal_default(t_lexer *lexer, t_lexer_state *s)
{
(void)(lexer);
(void)(s);
s->result = false;
return (false);
}

18
parser/static/lex_funcs/lex_normal/state_11.c
View file

@ -15,47 +15,47 @@
bool lex_normal_s55(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(428, lexer, s));
return (lex_advance(419, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s56(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(428, lexer, s));
return (lex_advance(419, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(55, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(109, lexer, s));
return (lex_skip(106, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s57(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(172, lexer, s));
return (lex_skip(169, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s58(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(439, lexer, s));
return (lex_advance(430, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s59(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(439, lexer, s));
return (lex_advance(430, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(58, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(471, lexer, s));
return (lex_advance(462, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(170, lexer, s));
return (lex_skip(167, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}

16
parser/static/lex_funcs/lex_normal/state_12.c
View file

@ -15,46 +15,46 @@
bool lex_normal_s60(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(439, lexer, s));
return (lex_advance(430, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(58, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(170, lexer, s));
return (lex_skip(167, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s61(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(179, lexer, s));
return (lex_skip(176, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s62(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(430, lexer, s));
return (lex_advance(421, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s63(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(430, lexer, s));
return (lex_advance(421, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(62, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(111, lexer, s));
return (lex_skip(108, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s64(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(440, lexer, s));
return (lex_advance(431, lexer, s));
return (lex_end_state(lexer, s));
}

22
parser/static/lex_funcs/lex_normal/state_13.c
View file

@ -15,54 +15,54 @@
bool lex_normal_s65(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(440, lexer, s));
return (lex_advance(431, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(64, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(180, lexer, s));
return (lex_skip(177, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s66(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(435, lexer, s));
return (lex_advance(426, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s67(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(435, lexer, s));
return (lex_advance(426, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(66, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(466, lexer, s));
return (lex_advance(457, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(116, lexer, s));
return (lex_skip(113, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s68(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(435, lexer, s));
return (lex_advance(426, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(66, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(116, lexer, s));
return (lex_skip(113, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s69(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(188, lexer, s));
return (lex_skip(185, lexer, s));
return (lex_end_state(lexer, s));
}

20
parser/static/lex_funcs/lex_normal/state_14.c
View file

@ -15,49 +15,49 @@
bool lex_normal_s70(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(436, lexer, s));
return (lex_advance(427, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s71(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(436, lexer, s));
return (lex_advance(427, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(70, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(467, lexer, s));
return (lex_advance(458, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(117, lexer, s));
return (lex_skip(114, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s72(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(436, lexer, s));
return (lex_advance(427, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(70, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(117, lexer, s));
return (lex_skip(114, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s73(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(198, lexer, s));
return (lex_skip(195, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s74(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(193, lexer, s));
return (lex_skip(190, lexer, s));
return (lex_end_state(lexer, s));
}

19
parser/static/lex_funcs/lex_normal/state_15.c
View file

@ -15,39 +15,46 @@
bool lex_normal_s75(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(434, lexer, s));
return (lex_advance(423, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s76(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(434, lexer, s));
return (lex_advance(423, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(75, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(115, lexer, s));
return (lex_skip(110, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s77(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(197, lexer, s));
return (lex_skip(194, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s78(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(190, lexer, s));
return (lex_skip(187, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s79(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(441, lexer, s));
return (lex_advance(365, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(361, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_advance(365, lexer, s));
if (s->lookahead != 0)
return (lex_advance(368, lexer, s));
return (lex_end_state(lexer, s));
}

27
parser/static/lex_funcs/lex_normal/state_16.c
View file

@ -15,53 +15,46 @@
bool lex_normal_s80(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(441, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(79, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(181, lexer, s));
return (lex_advance(432, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s81(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(373, lexer, s));
return (lex_advance(432, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(369, lexer, s));
return (lex_advance(80, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_advance(373, lexer, s));
if (s->lookahead != 0)
return (lex_advance(376, lexer, s));
return (lex_skip(178, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s82(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(183, lexer, s));
return (lex_skip(180, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s83(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(374, lexer, s));
return (lex_advance(366, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(371, lexer, s));
return (lex_advance(363, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_advance(374, lexer, s));
return (lex_advance(366, lexer, s));
if (s->lookahead != 0)
return (lex_advance(376, lexer, s));
return (lex_advance(368, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s84(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(191, lexer, s));
return (lex_skip(188, lexer, s));
return (lex_end_state(lexer, s));
}

18
parser/static/lex_funcs/lex_normal/state_17.c
View file

@ -15,33 +15,33 @@
bool lex_normal_s85(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(442, lexer, s));
return (lex_advance(433, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s86(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(442, lexer, s));
return (lex_advance(433, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(85, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(184, lexer, s));
return (lex_skip(181, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s87(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(189, lexer, s));
return (lex_skip(186, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s88(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(192, lexer, s));
return (lex_skip(189, lexer, s));
return (lex_end_state(lexer, s));
}
@ -52,14 +52,14 @@ bool lex_normal_s89(t_lexer *lexer, t_lexer_state *s)
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(89, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(454, lexer, s));
return (lex_advance(445, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(381, lexer, s));
return (lex_advance(373, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(413, lexer, s));
return (lex_advance(405, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*')))
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}

20
parser/static/lex_funcs/lex_normal/state_18.c
View file

@ -15,49 +15,49 @@
bool lex_normal_s90(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(104, lexer, s));
return (lex_skip(102, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s91(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(105, lexer, s));
return (lex_skip(103, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s92(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(433, lexer, s));
return (lex_advance(425, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s93(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(433, lexer, s));
return (lex_advance(425, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(92, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(465, lexer, s));
return (lex_advance(456, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(114, lexer, s));
return (lex_skip(112, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s94(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(433, lexer, s));
return (lex_advance(425, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(92, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(114, lexer, s));
return (lex_skip(112, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}

48
parser/static/lex_funcs/lex_normal/state_19.c
View file

@ -15,33 +15,45 @@
bool lex_normal_s95(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(186, lexer, s));
return (lex_skip(183, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s96(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(432, lexer, s));
return (lex_skip(191, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s97(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(432, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(96, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(113, lexer, s));
if (lex_normal_map97(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(97, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(446, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(372, lexer, s));
if (s->lookahead != 0)
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s98(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(194, lexer, s));
if (lex_normal_map98(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(98, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(447, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(372, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')')))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
@ -52,10 +64,14 @@ bool lex_normal_s99(t_lexer *lexer, t_lexer_state *s)
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(99, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(455, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(380, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(448, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(373, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(405, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*')))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}

22
parser/static/lex_funcs/lex_normal/state_2.c
View file

@ -19,57 +19,57 @@ bool lex_normal_s10(t_lexer *lexer, t_lexer_state *s)
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(10, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(453, lexer, s));
return (lex_advance(444, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(381, lexer, s));
return (lex_advance(373, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(413, lexer, s));
return (lex_advance(405, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*')))
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s11(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(419, lexer, s));
return (lex_advance(411, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s12(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(419, lexer, s));
return (lex_advance(411, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(11, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(453, lexer, s));
return (lex_advance(444, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(10, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s13(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(419, lexer, s));
return (lex_advance(411, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(11, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(10, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s14(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(443, lexer, s));
return (lex_advance(434, lexer, s));
return (lex_end_state(lexer, s));
}

61
parser/static/lex_funcs/lex_normal/state_20.c
View file

@ -16,15 +16,13 @@ bool lex_normal_s100(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map100(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(100, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(456, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(380, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')')))
return (lex_advance(497, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(410, lexer, s));
return (lex_end_state(lexer, s));
}
@ -35,14 +33,14 @@ bool lex_normal_s101(t_lexer *lexer, t_lexer_state *s)
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(101, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(457, lexer, s));
return (lex_advance(449, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(381, lexer, s));
return (lex_advance(373, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(413, lexer, s));
return (lex_advance(405, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
@ -50,13 +48,14 @@ bool lex_normal_s102(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map102(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(102, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(418, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(450, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(372, lexer, s));
if (s->lookahead != 0)
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
@ -67,15 +66,12 @@ bool lex_normal_s103(t_lexer *lexer, t_lexer_state *s)
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(103, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(458, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(381, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(413, lexer, s));
return (lex_advance(451, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(372, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*')))
return (lex_advance(497, lexer, s));
s->lookahead < ')')))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
@ -83,13 +79,12 @@ bool lex_normal_s104(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map104(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(104, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(459, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(380, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(410, lexer, s));
return (lex_end_state(lexer, s));
}

74
parser/static/lex_funcs/lex_normal/state_21.c
View file

@ -19,12 +19,15 @@ bool lex_normal_s105(t_lexer *lexer, t_lexer_state *s)
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(105, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(460, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(380, lexer, s));
return (lex_advance(452, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(373, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(405, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')')))
return (lex_advance(497, lexer, s));
s->lookahead < '*')))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
@ -32,18 +35,13 @@ bool lex_normal_s106(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map106(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(106, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(461, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(381, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(413, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*')))
return (lex_advance(497, lexer, s));
return (lex_advance(410, lexer, s));
return (lex_end_state(lexer, s));
}
@ -51,13 +49,18 @@ bool lex_normal_s107(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map107(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(107, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(453, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(373, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(418, lexer, s));
return (lex_advance(405, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*')))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
@ -65,18 +68,13 @@ bool lex_normal_s108(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map108(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(108, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(462, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(381, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(413, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*')))
return (lex_advance(497, lexer, s));
return (lex_advance(410, lexer, s));
return (lex_end_state(lexer, s));
}
@ -84,12 +82,18 @@ bool lex_normal_s109(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map109(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(109, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(454, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(373, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(418, lexer, s));
return (lex_advance(405, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*') && s->lookahead != ';' && s->lookahead \
!= '<'))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}

68
parser/static/lex_funcs/lex_normal/state_22.c
View file

@ -16,19 +16,13 @@ bool lex_normal_s110(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map110(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(110, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(463, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(381, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(413, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*') && s->lookahead != ';' && s->lookahead \
!= '<'))
return (lex_advance(497, lexer, s));
return (lex_advance(410, lexer, s));
return (lex_end_state(lexer, s));
}
@ -36,13 +30,19 @@ bool lex_normal_s111(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map111(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(111, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(455, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(373, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(418, lexer, s));
return (lex_advance(405, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*') && s->lookahead != ';' && s->lookahead \
!= '<'))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
@ -53,16 +53,16 @@ bool lex_normal_s112(t_lexer *lexer, t_lexer_state *s)
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(112, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(464, lexer, s));
return (lex_advance(456, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(381, lexer, s));
return (lex_advance(373, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(413, lexer, s));
return (lex_advance(405, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*') && s->lookahead != ';' && s->lookahead \
!= '<'))
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
@ -70,13 +70,20 @@ bool lex_normal_s113(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map113(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(113, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(457, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(373, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(418, lexer, s));
return (lex_advance(405, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*') && s->lookahead != ';' && s->lookahead \
!= '<' && (s->lookahead > '>' && s->lookahead < 'Z') && \
s->lookahead != '|'))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
@ -87,15 +94,16 @@ bool lex_normal_s114(t_lexer *lexer, t_lexer_state *s)
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(114, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(465, lexer, s));
return (lex_advance(458, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(381, lexer, s));
return (lex_advance(373, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(413, lexer, s));
return (lex_advance(405, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*') && s->lookahead != ';' && s->lookahead \
!= '<'))
return (lex_advance(497, lexer, s));
!= '<' && (s->lookahead > '>' && s->lookahead < 'Z') && \
s->lookahead != '|'))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}

74
parser/static/lex_funcs/lex_normal/state_23.c
View file

@ -14,81 +14,59 @@
bool lex_normal_s115(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map115(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(115, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(418, lexer, s));
if (s->lookahead == '\r')
return (lex_skip(1, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(459, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(164, lexer, s));
if (s->lookahead != 0)
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s116(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map116(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(116, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(466, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(381, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(413, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*') && s->lookahead != ';' && s->lookahead \
!= '<' && (s->lookahead > '>' && s->lookahead < 'Z') && \
s->lookahead != '|'))
return (lex_advance(497, lexer, s));
if (s->lookahead == '\r')
return (lex_skip(1, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(164, lexer, s));
if (s->lookahead != 0)
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s117(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map117(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(117, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(467, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(381, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(413, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*') && s->lookahead != ';' && s->lookahead \
!= '<' && (s->lookahead > '>' && s->lookahead < 'Z') && \
s->lookahead != '|'))
return (lex_advance(497, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(369, lexer, s));
if (s->lookahead != 0)
return (lex_advance(368, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s118(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(1, lexer, s));
return (lex_skip(2, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(468, lexer, s));
return (lex_advance(463, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(167, lexer, s));
return (lex_skip(168, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s119(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(1, lexer, s));
return (lex_skip(2, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(167, lexer, s));
return (lex_skip(168, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}

39
parser/static/lex_funcs/lex_normal/state_24.c
View file

@ -15,58 +15,61 @@
bool lex_normal_s120(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_advance(377, lexer, s));
return (lex_skip(3, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(464, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(170, lexer, s));
if (s->lookahead != 0)
return (lex_advance(376, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s121(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(2, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(472, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(171, lexer, s));
return (lex_skip(3, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(170, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s122(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(2, lexer, s));
return (lex_advance(364, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(171, lexer, s));
return (lex_advance(367, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(368, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s123(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(3, lexer, s));
return (lex_skip(4, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(473, lexer, s));
return (lex_advance(443, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(173, lexer, s));
return (lex_skip(5, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s124(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(3, lexer, s));
return (lex_skip(4, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(173, lexer, s));
return (lex_skip(5, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}

55
parser/static/lex_funcs/lex_normal/state_25.c
View file

@ -15,61 +15,62 @@
bool lex_normal_s125(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_advance(372, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_advance(375, lexer, s));
return (lex_skip(6, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(465, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(171, lexer, s));
if (s->lookahead != 0)
return (lex_advance(376, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s126(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(4, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(452, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(5, lexer, s));
return (lex_skip(6, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(171, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s127(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(4, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(5, lexer, s));
return (lex_skip(7, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(466, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(172, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s128(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(6, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(474, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(174, lexer, s));
return (lex_skip(7, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(172, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s129(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(6, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(174, lexer, s));
return (lex_skip(8, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(467, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(173, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}

55
parser/static/lex_funcs/lex_normal/state_26.c
View file

@ -15,62 +15,61 @@
bool lex_normal_s130(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(7, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(475, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(175, lexer, s));
return (lex_skip(8, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(173, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s131(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(7, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(175, lexer, s));
return (lex_skip(9, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(469, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(184, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s132(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(8, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(476, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(176, lexer, s));
return (lex_skip(9, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(184, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s133(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(8, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(176, lexer, s));
return (lex_skip(32, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(446, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(97, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s134(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(9, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(478, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(187, lexer, s));
return (lex_skip(32, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(97, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}

42
parser/static/lex_funcs/lex_normal/state_27.c
View file

@ -15,61 +15,59 @@
bool lex_normal_s135(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(9, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(187, lexer, s));
return (lex_skip(33, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(447, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(98, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s136(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(32, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(455, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(99, lexer, s));
return (lex_skip(33, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(98, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s137(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(32, lexer, s));
return (lex_skip(46, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(99, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_skip(174, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s138(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(33, lexer, s));
return (lex_skip(90, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(456, lexer, s));
return (lex_advance(450, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(100, lexer, s));
return (lex_skip(102, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s139(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(33, lexer, s));
return (lex_skip(90, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(100, lexer, s));
return (lex_skip(102, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}

53
parser/static/lex_funcs/lex_normal/state_28.c
View file

@ -15,35 +15,38 @@
bool lex_normal_s140(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(46, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(177, lexer, s));
return (lex_skip(91, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(451, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(103, lexer, s));
if (s->lookahead != 0)
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s141(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(90, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(459, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(104, lexer, s));
return (lex_skip(91, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(103, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s142(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(90, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(104, lexer, s));
return (lex_skip(47, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(470, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(182, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
@ -51,23 +54,23 @@ bool lex_normal_s143(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(47, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(479, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(185, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(182, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s144(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(47, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(185, lexer, s));
return (lex_skip(57, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(468, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(169, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}

39
parser/static/lex_funcs/lex_normal/state_29.c
View file

@ -15,62 +15,59 @@
bool lex_normal_s145(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(91, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(460, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(105, lexer, s));
return (lex_skip(57, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(169, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s146(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(91, lexer, s));
return (lex_skip(61, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(105, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_skip(176, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s147(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(57, lexer, s));
return (lex_skip(95, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(477, lexer, s));
return (lex_advance(471, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(172, lexer, s));
return (lex_skip(183, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s148(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(57, lexer, s));
return (lex_skip(95, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(172, lexer, s));
return (lex_skip(183, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s149(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(95, lexer, s));
return (lex_skip(69, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(480, lexer, s));
return (lex_advance(472, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(186, lexer, s));
return (lex_skip(185, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}

22
parser/static/lex_funcs/lex_normal/state_3.c
View file

@ -15,7 +15,7 @@
bool lex_normal_s15(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(443, lexer, s));
return (lex_advance(434, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(14, lexer, s));
return (lex_end_state(lexer, s));
@ -24,47 +24,47 @@ bool lex_normal_s15(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s16(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(443, lexer, s));
return (lex_advance(434, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(14, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '\t' && \
s->lookahead < '\r')))
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s17(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(422, lexer, s));
return (lex_advance(413, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s18(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(422, lexer, s));
return (lex_advance(413, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(17, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(457, lexer, s));
return (lex_advance(445, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(101, lexer, s));
return (lex_skip(89, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s19(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(422, lexer, s));
return (lex_advance(413, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(17, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(101, lexer, s));
return (lex_skip(89, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}

35
parser/static/lex_funcs/lex_normal/state_30.c
View file

@ -15,56 +15,59 @@
bool lex_normal_s150(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(95, lexer, s));
return (lex_skip(69, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(186, lexer, s));
return (lex_skip(185, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s151(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(61, lexer, s));
return (lex_skip(73, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(179, lexer, s));
return (lex_skip(195, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s152(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(69, lexer, s));
return (lex_skip(74, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(481, lexer, s));
return (lex_advance(473, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(188, lexer, s));
return (lex_skip(190, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s153(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(69, lexer, s));
return (lex_skip(74, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(188, lexer, s));
return (lex_skip(190, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s154(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(73, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(198, lexer, s));
return (lex_skip(96, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(474, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(191, lexer, s));
if (s->lookahead != 0)
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}

35
parser/static/lex_funcs/lex_normal/state_31.c
View file

@ -15,59 +15,56 @@
bool lex_normal_s155(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(74, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(482, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(193, lexer, s));
return (lex_skip(96, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(191, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s156(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(74, lexer, s));
return (lex_skip(77, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(193, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_skip(194, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s157(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(98, lexer, s));
return (lex_skip(78, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(483, lexer, s));
return (lex_advance(475, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(194, lexer, s));
return (lex_skip(187, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s158(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(98, lexer, s));
return (lex_skip(78, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(194, lexer, s));
return (lex_skip(187, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s159(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(77, lexer, s));
return (lex_skip(82, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(197, lexer, s));
return (lex_skip(180, lexer, s));
return (lex_end_state(lexer, s));
}

43
parser/static/lex_funcs/lex_normal/state_32.c
View file

@ -15,59 +15,60 @@
bool lex_normal_s160(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(78, lexer, s));
return (lex_skip(84, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(484, lexer, s));
return (lex_advance(476, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(190, lexer, s));
return (lex_skip(188, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s161(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(78, lexer, s));
return (lex_skip(84, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(190, lexer, s));
return (lex_skip(188, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s162(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(82, lexer, s));
return (lex_skip(87, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(183, lexer, s));
return (lex_skip(186, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s163(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(84, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(485, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(191, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_skip(88, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(189, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s164(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(84, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
if (lex_normal_map164(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
return (lex_skip(191, lexer, s));
return (lex_skip(164, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(459, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(372, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}

81
parser/static/lex_funcs/lex_normal/state_33.c
View file

@ -14,21 +14,43 @@
bool lex_normal_s165(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(87, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
if (lex_normal_map165(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
return (lex_skip(189, lexer, s));
return (lex_skip(165, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(460, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(373, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(405, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*') && s->lookahead != ';' && s->lookahead \
!= '<'))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s166(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(88, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
if (lex_normal_map166(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
return (lex_skip(192, lexer, s));
return (lex_skip(166, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(461, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(373, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(405, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*') && s->lookahead != ';' && s->lookahead \
!= '<'))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
@ -40,11 +62,16 @@ bool lex_normal_s167(t_lexer *lexer, t_lexer_state *s)
s->lookahead == ' '))
return (lex_skip(167, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(468, lexer, s));
return (lex_advance(462, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(380, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(373, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(405, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '|'))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
@ -56,16 +83,13 @@ bool lex_normal_s168(t_lexer *lexer, t_lexer_state *s)
s->lookahead == ' '))
return (lex_skip(168, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(469, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(381, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(413, lexer, s));
return (lex_advance(463, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(372, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*') && s->lookahead != ';' && s->lookahead \
!= '<'))
return (lex_advance(497, lexer, s));
s->lookahead < ')') && s->lookahead != '{' && s->lookahead \
!= '|'))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
@ -77,15 +101,12 @@ bool lex_normal_s169(t_lexer *lexer, t_lexer_state *s)
s->lookahead == ' '))
return (lex_skip(169, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(470, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(381, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(413, lexer, s));
return (lex_advance(468, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(372, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*') && s->lookahead != ';' && s->lookahead \
!= '<'))
return (lex_advance(497, lexer, s));
s->lookahead < ')') && s->lookahead != '{' && s->lookahead \
!= '|'))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}

67
parser/static/lex_funcs/lex_normal/state_34.c
View file

@ -20,16 +20,13 @@ bool lex_normal_s170(t_lexer *lexer, t_lexer_state *s)
s->lookahead == ' '))
return (lex_skip(170, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(471, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(381, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(413, lexer, s));
return (lex_advance(464, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(372, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '|'))
return (lex_advance(497, lexer, s));
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '{' && s->lookahead != '|'))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
@ -41,13 +38,13 @@ bool lex_normal_s171(t_lexer *lexer, t_lexer_state *s)
s->lookahead == ' '))
return (lex_skip(171, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(472, lexer, s));
return (lex_advance(465, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(380, lexer, s));
return (lex_advance(372, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != '{' && s->lookahead \
!= '|'))
return (lex_advance(497, lexer, s));
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '{' && s->lookahead != '|'))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
@ -59,13 +56,13 @@ bool lex_normal_s172(t_lexer *lexer, t_lexer_state *s)
s->lookahead == ' '))
return (lex_skip(172, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(477, lexer, s));
return (lex_advance(466, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(380, lexer, s));
return (lex_advance(372, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != '{' && s->lookahead \
!= '|'))
return (lex_advance(497, lexer, s));
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '{' && s->lookahead != '|'))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
@ -77,13 +74,13 @@ bool lex_normal_s173(t_lexer *lexer, t_lexer_state *s)
s->lookahead == ' '))
return (lex_skip(173, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(473, lexer, s));
return (lex_advance(467, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(380, lexer, s));
return (lex_advance(372, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '{' && s->lookahead != '|'))
return (lex_advance(497, lexer, s));
!= '<' && (s->lookahead > '{' && s->lookahead < '}')))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
@ -91,16 +88,22 @@ bool lex_normal_s174(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map174(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
if (s->lookahead == '\\')
return (lex_skip(137, lexer, s));
if (s->lookahead == '^')
return (lex_advance(321, lexer, s));
if (s->lookahead == '`')
return (lex_advance(203, lexer, s));
if (s->lookahead == '|')
return (lex_advance(250, lexer, s));
if (s->lookahead == '}')
return (lex_advance(256, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(174, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(474, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(380, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '{' && s->lookahead != '|'))
return (lex_advance(497, lexer, s));
if (((s->lookahead >= '0' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= '_' && s->lookahead <= 'z')))
return (lex_advance(410, lexer, s));
return (lex_end_state(lexer, s));
}

96
parser/static/lex_funcs/lex_normal/state_35.c
View file

@ -16,17 +16,18 @@ bool lex_normal_s175(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map175(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
if ((s->lookahead == '\n' || s->lookahead == '\r'))
return (lex_skip(175, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(475, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(380, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && (s->lookahead > '{' && s->lookahead < '}')))
return (lex_advance(497, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_advance(365, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(410, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '_' && \
s->lookahead < 'z')))
return (lex_advance(368, lexer, s));
return (lex_end_state(lexer, s));
}
@ -34,17 +35,22 @@ bool lex_normal_s176(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map176(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
if (s->lookahead == '\\')
return (lex_skip(146, lexer, s));
if (s->lookahead == '`')
return (lex_advance(395, lexer, s));
if (s->lookahead == '|')
return (lex_advance(251, lexer, s));
if (s->lookahead == '~')
return (lex_advance(353, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(176, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(476, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(380, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '{' && s->lookahead != '|'))
return (lex_advance(497, lexer, s));
return (lex_advance(374, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= '_' && s->lookahead <= 'z')))
return (lex_advance(410, lexer, s));
return (lex_end_state(lexer, s));
}
@ -52,23 +58,13 @@ bool lex_normal_s177(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map177(lexer, s))
return (true);
if (s->lookahead == '\\')
return (lex_skip(140, lexer, s));
if (s->lookahead == '^')
return (lex_advance(329, lexer, s));
if (s->lookahead == '`')
return (lex_advance(206, lexer, s));
if (s->lookahead == '|')
return (lex_advance(255, lexer, s));
if (s->lookahead == '}')
return (lex_advance(261, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(177, lexer, s));
if (((s->lookahead >= '0' && s->lookahead <= '9') || \
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= '_' && s->lookahead <= 'z')))
return (lex_advance(418, lexer, s));
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(410, lexer, s));
return (lex_end_state(lexer, s));
}
@ -76,18 +72,13 @@ bool lex_normal_s178(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map178(lexer, s))
return (true);
if ((s->lookahead == '\n' || s->lookahead == '\r'))
return (lex_skip(178, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_advance(373, lexer, s));
return (lex_skip(178, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(418, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '_' && \
s->lookahead < 'z')))
return (lex_advance(376, lexer, s));
return (lex_advance(410, lexer, s));
return (lex_end_state(lexer, s));
}
@ -95,21 +86,18 @@ bool lex_normal_s179(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map179(lexer, s))
return (true);
if (s->lookahead == '\\')
return (lex_skip(151, lexer, s));
if (s->lookahead == '`')
return (lex_advance(403, lexer, s));
if (s->lookahead == '|')
return (lex_advance(256, lexer, s));
if (s->lookahead == '~')
return (lex_advance(361, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
if ((s->lookahead == '\n' || s->lookahead == '\r'))
return (lex_skip(179, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(382, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= '_' && s->lookahead <= 'z')))
return (lex_advance(418, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_advance(366, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(410, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > ' ' && \
s->lookahead < '$') && (s->lookahead > '_' && s->lookahead \
< 'z')))
return (lex_advance(368, lexer, s));
return (lex_end_state(lexer, s));
}

66
parser/static/lex_funcs/lex_normal/state_36.c
View file

@ -16,13 +16,19 @@ bool lex_normal_s180(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map180(lexer, s))
return (true);
if (s->lookahead == '\\')
return (lex_skip(159, lexer, s));
if (s->lookahead == '_')
return (lex_advance(442, lexer, s));
if (s->lookahead == '}')
return (lex_advance(256, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(180, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(418, lexer, s));
return (lex_advance(410, lexer, s));
return (lex_end_state(lexer, s));
}
@ -36,7 +42,7 @@ bool lex_normal_s181(t_lexer *lexer, t_lexer_state *s)
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(418, lexer, s));
return (lex_advance(410, lexer, s));
return (lex_end_state(lexer, s));
}
@ -44,19 +50,17 @@ bool lex_normal_s182(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map182(lexer, s))
return (true);
if ((s->lookahead == '\n' || s->lookahead == '\r'))
return (lex_skip(182, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
return (lex_advance(374, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(418, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > ' ' && \
s->lookahead < '$') && (s->lookahead > '_' && s->lookahead \
< 'z')))
return (lex_advance(376, lexer, s));
return (lex_skip(182, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(470, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(372, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<'))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
@ -64,19 +68,17 @@ bool lex_normal_s183(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map183(lexer, s))
return (true);
if (s->lookahead == '\\')
return (lex_skip(162, lexer, s));
if (s->lookahead == '_')
return (lex_advance(451, lexer, s));
if (s->lookahead == '}')
return (lex_advance(261, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
return (lex_skip(183, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(418, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(471, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(372, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<'))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
@ -84,12 +86,16 @@ bool lex_normal_s184(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map184(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
return (lex_skip(184, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(418, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(469, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(372, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '{' && s->lookahead != '|'))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}

99
parser/static/lex_funcs/lex_normal/state_37.c
View file

@ -20,88 +20,109 @@ bool lex_normal_s185(t_lexer *lexer, t_lexer_state *s)
s->lookahead == ' '))
return (lex_skip(185, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(479, lexer, s));
return (lex_advance(472, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(380, lexer, s));
return (lex_advance(372, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<'))
return (lex_advance(497, lexer, s));
!= '<' && s->lookahead != '>' && s->lookahead != '|'))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s186(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map186(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
if (s->lookahead == '"')
return (lex_advance(360, lexer, s));
if (s->lookahead == '#')
return (lex_advance(400, lexer, s));
if (s->lookahead == '$')
return (lex_advance(198, lexer, s));
if (s->lookahead == ')')
return (lex_advance(252, lexer, s));
if (s->lookahead == '\\')
return (lex_skip(162, lexer, s));
if (s->lookahead == '`')
return (lex_advance(395, lexer, s));
if (s->lookahead == '|')
return (lex_advance(249, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(186, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(480, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(380, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<'))
return (lex_advance(497, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s187(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map187(lexer, s))
return (true);
if (s->lookahead == '"')
return (lex_advance(360, lexer, s));
if (s->lookahead == '#')
return (lex_advance(400, lexer, s));
if (s->lookahead == '$')
return (lex_advance(359, lexer, s));
if (s->lookahead == '\'')
return (lex_advance(197, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(158, lexer, s));
if (s->lookahead == '`')
return (lex_advance(395, lexer, s));
if (s->lookahead == '}')
return (lex_advance(257, lexer, s));
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
return (lex_skip(187, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(478, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(380, lexer, s));
return (lex_advance(475, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '{' && s->lookahead != '|'))
return (lex_advance(497, lexer, s));
!= '<' && s->lookahead != '>' && s->lookahead != '|' && \
s->lookahead != '}'))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s188(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map188(lexer, s))
return (true);
if (s->lookahead == '"')
return (lex_advance(360, lexer, s));
if (s->lookahead == '#')
return (lex_advance(400, lexer, s));
if (s->lookahead == '$')
return (lex_advance(359, lexer, s));
if (s->lookahead == '\'')
return (lex_advance(197, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(161, lexer, s));
if (s->lookahead == '`')
return (lex_advance(395, lexer, s));
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
return (lex_skip(188, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(481, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(380, lexer, s));
return (lex_advance(476, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '>' && s->lookahead != '|'))
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s189(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '"')
return (lex_advance(368, lexer, s));
return (lex_advance(360, lexer, s));
if (s->lookahead == '#')
return (lex_advance(408, lexer, s));
if (s->lookahead == '$')
return (lex_advance(201, lexer, s));
return (lex_advance(400, lexer, s));
if (s->lookahead == '\'')
return (lex_advance(197, lexer, s));
if (s->lookahead == ')')
return (lex_advance(257, lexer, s));
if (s->lookahead == '\\')
return (lex_skip(165, lexer, s));
if (s->lookahead == '`')
return (lex_advance(403, lexer, s));
if (s->lookahead == '|')
return (lex_advance(252, lexer, s));
if (s->lookahead == '\\')
return (lex_skip(163, lexer, s));
if (s->lookahead == '}')
return (lex_advance(256, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(189, lexer, s));
return (lex_advance(392, lexer, s));
return (lex_end_state(lexer, s));
}

127
parser/static/lex_funcs/lex_normal/state_38.c
View file

@ -15,130 +15,119 @@
bool lex_normal_s190(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '"')
return (lex_advance(368, lexer, s));
return (lex_advance(360, lexer, s));
if (s->lookahead == '#')
return (lex_advance(408, lexer, s));
return (lex_advance(401, lexer, s));
if (s->lookahead == '$')
return (lex_advance(367, lexer, s));
return (lex_advance(358, lexer, s));
if (s->lookahead == '\'')
return (lex_advance(200, lexer, s));
return (lex_advance(197, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(161, lexer, s));
return (lex_advance(153, lexer, s));
if (s->lookahead == '`')
return (lex_advance(403, lexer, s));
if (s->lookahead == '}')
return (lex_advance(262, lexer, s));
return (lex_advance(396, lexer, s));
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
return (lex_skip(190, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(484, lexer, s));
return (lex_advance(473, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(372, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '>' && s->lookahead != '|' && \
s->lookahead != '}'))
return (lex_advance(497, lexer, s));
!= '<' && s->lookahead != '>' && s->lookahead != '|'))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s191(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '"')
return (lex_advance(368, lexer, s));
return (lex_advance(360, lexer, s));
if (s->lookahead == '#')
return (lex_advance(408, lexer, s));
return (lex_advance(401, lexer, s));
if (s->lookahead == '$')
return (lex_advance(367, lexer, s));
return (lex_advance(358, lexer, s));
if (s->lookahead == '\'')
return (lex_advance(200, lexer, s));
return (lex_advance(197, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(164, lexer, s));
return (lex_advance(155, lexer, s));
if (s->lookahead == '`')
return (lex_advance(403, lexer, s));
return (lex_advance(395, lexer, s));
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
return (lex_skip(191, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(485, lexer, s));
return (lex_advance(474, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(372, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '>' && s->lookahead != '|'))
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s192(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '"')
return (lex_advance(368, lexer, s));
return (lex_advance(360, lexer, s));
if (s->lookahead == '#')
return (lex_advance(408, lexer, s));
if (s->lookahead == '\'')
return (lex_advance(200, lexer, s));
if (s->lookahead == ')')
return (lex_advance(257, lexer, s));
return (lex_advance(370, lexer, s));
if (s->lookahead == '$')
return (lex_advance(358, lexer, s));
if (s->lookahead == '\\')
return (lex_skip(166, lexer, s));
if (s->lookahead == '}')
return (lex_advance(261, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
return (lex_advance(122, lexer, s));
if (s->lookahead == '`')
return (lex_advance(395, lexer, s));
if ((s->lookahead == '\n' || s->lookahead == '\r'))
return (lex_skip(192, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_advance(400, lexer, s));
return (lex_advance(367, lexer, s));
if (s->lookahead != 0)
return (lex_advance(368, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s193(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '"')
return (lex_advance(368, lexer, s));
if (s->lookahead == '#')
return (lex_advance(409, lexer, s));
if (s->lookahead == '$')
return (lex_advance(366, lexer, s));
if (s->lookahead == '\'')
return (lex_advance(375, lexer, s));
if (s->lookahead == '%')
return (lex_advance(340, lexer, s));
if (s->lookahead == '+')
return (lex_advance(389, lexer, s));
if (s->lookahead == '-')
return (lex_advance(379, lexer, s));
if (s->lookahead == ':')
return (lex_advance(200, lexer, s));
if (s->lookahead == '=')
return (lex_advance(382, lexer, s));
if (s->lookahead == '?')
return (lex_advance(386, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(156, lexer, s));
if (s->lookahead == '`')
return (lex_advance(404, lexer, s));
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
return (lex_skip(156, lexer, s));
if (s->lookahead == '}')
return (lex_advance(256, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(193, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(482, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(380, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '>' && s->lookahead != '|'))
return (lex_advance(497, lexer, s));
return (lex_skip(194, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s194(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '"')
return (lex_advance(368, lexer, s));
if (s->lookahead == '#')
return (lex_advance(409, lexer, s));
if (s->lookahead == '$')
return (lex_advance(366, lexer, s));
if (s->lookahead == '\'')
return (lex_advance(200, lexer, s));
return (lex_advance(375, lexer, s));
if (s->lookahead == '%')
return (lex_advance(340, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(158, lexer, s));
if (s->lookahead == '`')
return (lex_advance(403, lexer, s));
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
return (lex_skip(156, lexer, s));
if (s->lookahead == '}')
return (lex_advance(256, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(194, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(483, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(380, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '>' && s->lookahead != '|'))
return (lex_advance(497, lexer, s));
return (lex_end_state(lexer, s));
}

97
parser/static/lex_funcs/lex_normal/state_39.c
View file

@ -14,97 +14,58 @@
bool lex_normal_s195(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '"')
return (lex_advance(368, lexer, s));
if (s->lookahead == '#')
return (lex_advance(378, lexer, s));
if (s->lookahead == '$')
return (lex_advance(366, lexer, s));
return (lex_advance(400, lexer, s));
if (s->lookahead == '&')
return (lex_advance(196, lexer, s));
if (s->lookahead == ')')
return (lex_advance(252, lexer, s));
if (s->lookahead == '<')
return (lex_advance(266, lexer, s));
if (s->lookahead == '>')
return (lex_advance(270, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(125, lexer, s));
return (lex_skip(151, lexer, s));
if (s->lookahead == '`')
return (lex_advance(403, lexer, s));
if ((s->lookahead == '\n' || s->lookahead == '\r'))
return (lex_skip(195, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
return (lex_advance(203, lexer, s));
if (s->lookahead == '|')
return (lex_advance(251, lexer, s));
if (s->lookahead == '}')
return (lex_advance(256, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_advance(375, lexer, s));
if (s->lookahead != 0)
return (lex_advance(376, lexer, s));
return (lex_skip(195, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s196(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '#')
return (lex_advance(383, lexer, s));
if (s->lookahead == '%')
return (lex_advance(348, lexer, s));
if (s->lookahead == '+')
return (lex_advance(397, lexer, s));
if (s->lookahead == '-')
return (lex_advance(387, lexer, s));
if (s->lookahead == ':')
return (lex_advance(203, lexer, s));
if (s->lookahead == '=')
return (lex_advance(390, lexer, s));
if (s->lookahead == '?')
return (lex_advance(394, lexer, s));
if (s->lookahead == '\\')
return (lex_skip(159, lexer, s));
if (s->lookahead == '}')
return (lex_advance(261, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(197, lexer, s));
if (s->lookahead == '&')
return (lex_advance(258, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s197(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '#')
return (lex_advance(383, lexer, s));
if (s->lookahead == '%')
return (lex_advance(348, lexer, s));
if (s->lookahead == '\\')
return (lex_skip(159, lexer, s));
if (s->lookahead == '}')
return (lex_advance(261, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(197, lexer, s));
if (s->lookahead == '\'')
return (lex_advance(371, lexer, s));
if (s->lookahead != 0)
return (lex_advance(197, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s198(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '#')
return (lex_advance(408, lexer, s));
if (s->lookahead == '&')
return (lex_advance(199, lexer, s));
if (s->lookahead == ')')
return (lex_advance(257, lexer, s));
if (s->lookahead == '<')
return (lex_advance(272, lexer, s));
if (s->lookahead == '>')
return (lex_advance(275, lexer, s));
if (s->lookahead == '\\')
return (lex_skip(154, lexer, s));
if (s->lookahead == '`')
return (lex_advance(206, lexer, s));
if (s->lookahead == '|')
return (lex_advance(256, lexer, s));
if (s->lookahead == '}')
return (lex_advance(261, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(198, lexer, s));
if (s->lookahead == '(')
return (lex_advance(393, lexer, s));
if (s->lookahead == '{')
return (lex_advance(377, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s199(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '&')
return (lex_advance(263, lexer, s));
if (s->lookahead == ')')
return (lex_advance(305, lexer, s));
return (lex_end_state(lexer, s));
}

26
parser/static/lex_funcs/lex_normal/state_4.c
View file

@ -15,57 +15,57 @@
bool lex_normal_s20(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(421, lexer, s));
return (lex_advance(416, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s21(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(421, lexer, s));
return (lex_advance(416, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(20, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(454, lexer, s));
return (lex_advance(449, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(89, lexer, s));
return (lex_skip(101, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s22(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(421, lexer, s));
return (lex_advance(416, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(20, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(89, lexer, s));
return (lex_skip(101, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s23(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(425, lexer, s));
return (lex_advance(414, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s24(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(425, lexer, s));
return (lex_advance(414, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(23, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(461, lexer, s));
return (lex_advance(448, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(106, lexer, s));
return (lex_skip(99, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}

39
parser/static/lex_funcs/lex_normal/state_40.c
View file

@ -14,45 +14,44 @@
bool lex_normal_s200(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\'')
return (lex_advance(379, lexer, s));
if (s->lookahead != 0)
return (lex_advance(200, lexer, s));
if (s->lookahead == '+')
return (lex_advance(388, lexer, s));
if (s->lookahead == '-')
return (lex_advance(378, lexer, s));
if (s->lookahead == '=')
return (lex_advance(380, lexer, s));
if (s->lookahead == '?')
return (lex_advance(384, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s201(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '(')
return (lex_advance(401, lexer, s));
if (s->lookahead == '{')
return (lex_advance(385, lexer, s));
if (s->lookahead == ';')
return (lex_advance(254, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s202(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == ')')
return (lex_advance(313, lexer, s));
if (s->lookahead == '=')
return (lex_advance(326, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s203(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '+')
return (lex_advance(396, lexer, s));
if (s->lookahead == '-')
return (lex_advance(386, lexer, s));
if (s->lookahead == '=')
return (lex_advance(388, lexer, s));
if (s->lookahead == '?')
return (lex_advance(392, lexer, s));
if (s->lookahead == '`')
return (lex_advance(356, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_advance(203, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s204(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == ';')
return (lex_advance(259, lexer, s));
if (s->lookahead == 'a')
return (lex_advance(205, lexer, s));
return (lex_end_state(lexer, s));
}

25
parser/static/lex_funcs/lex_normal/state_41.c
View file

@ -14,38 +14,37 @@
bool lex_normal_s205(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '=')
return (lex_advance(334, lexer, s));
if (s->lookahead == 'c')
return (lex_advance(244, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s206(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '`')
return (lex_advance(364, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_advance(206, lexer, s));
if (s->lookahead == 'e')
return (lex_advance(242, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s207(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'a')
return (lex_advance(208, lexer, s));
if (s->lookahead == 'f')
return (lex_advance(240, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s208(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'c')
return (lex_advance(247, lexer, s));
if (s->lookahead == 'i')
return (lex_advance(238, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s209(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'e')
return (lex_advance(245, lexer, s));
if (s->lookahead == 'i')
return (lex_advance(207, lexer, s));
if (s->lookahead == 's')
return (lex_advance(206, lexer, s));
return (lex_end_state(lexer, s));
}

24
parser/static/lex_funcs/lex_normal/state_42.c
View file

@ -14,39 +14,37 @@
bool lex_normal_s210(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'f')
return (lex_advance(243, lexer, s));
if (s->lookahead == 'l')
return (lex_advance(209, lexer, s));
if (s->lookahead == 's')
return (lex_advance(204, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s211(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'i')
return (lex_advance(241, lexer, s));
if (s->lookahead == 'n')
return (lex_advance(233, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s212(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'i')
return (lex_advance(210, lexer, s));
if (s->lookahead == 's')
return (lex_advance(209, lexer, s));
if (s->lookahead == 'o')
return (lex_advance(236, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s213(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'l')
return (lex_advance(212, lexer, s));
if (s->lookahead == 's')
return (lex_advance(207, lexer, s));
return (lex_advance(204, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s214(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'n')
return (lex_advance(236, lexer, s));
if (s->lookahead == '|')
return (lex_advance(259, lexer, s));
return (lex_end_state(lexer, s));
}

86
parser/static/lex_funcs/lex_normal/state_43.c
View file

@ -14,50 +14,90 @@
bool lex_normal_s215(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'o')
return (lex_advance(239, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '\t' && \
s->lookahead < '\r')))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s216(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 's')
return (lex_advance(207, lexer, s));
if (s->eof)
return (lex_advance(232, lexer, s));
if (s->lookahead == '\n')
return (lex_skip(231, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s217(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '|')
return (lex_advance(264, lexer, s));
if (s->eof)
return (lex_advance(232, lexer, s));
if (s->lookahead == '\n')
return (lex_skip(218, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s218(t_lexer *lexer, t_lexer_state *s)
{
if ((s->lookahead != 0 && (s->lookahead > '\t' && \
s->lookahead < '\r')))
return (lex_advance(497, lexer, s));
if (s->eof)
return (lex_advance(232, lexer, s));
if (s->lookahead == '\n')
return (lex_advance(284, lexer, s));
if (s->lookahead == '#')
return (lex_advance(400, lexer, s));
if (s->lookahead == '&')
return (lex_advance(323, lexer, s));
if (s->lookahead == ')')
return (lex_advance(252, lexer, s));
if (s->lookahead == ';')
return (lex_advance(490, lexer, s));
if (s->lookahead == '<')
return (lex_advance(266, lexer, s));
if (s->lookahead == '>')
return (lex_advance(270, lexer, s));
if (s->lookahead == '\\')
return (lex_skip(227, lexer, s));
if (s->lookahead == '`')
return (lex_advance(396, lexer, s));
if (s->lookahead == 'e')
return (lex_advance(213, lexer, s));
if (s->lookahead == 'i')
return (lex_advance(211, lexer, s));
if (s->lookahead == '|')
return (lex_advance(251, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(218, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s219(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(235, lexer, s));
if (lex_normal_map219(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_advance(232, lexer, s));
if (s->lookahead == '\n')
return (lex_advance(284, lexer, s));
if (s->lookahead == '#')
return (lex_advance(400, lexer, s));
if (s->lookahead == '&')
return (lex_advance(323, lexer, s));
if (s->lookahead == ')')
return (lex_advance(252, lexer, s));
if (s->lookahead == ';')
return (lex_advance(490, lexer, s));
if (s->lookahead == '<')
return (lex_advance(266, lexer, s));
if (s->lookahead == '>')
return (lex_advance(270, lexer, s));
if (s->lookahead == '\\')
return (lex_skip(228, lexer, s));
if (s->lookahead == '`')
return (lex_advance(395, lexer, s));
if (s->lookahead == '|')
return (lex_advance(251, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(219, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(453, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(381, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(413, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*')))
return (lex_advance(497, lexer, s));
return (lex_end_state(lexer, s));
}

110
parser/static/lex_funcs/lex_normal/state_44.c
View file

@ -15,90 +15,84 @@
bool lex_normal_s220(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(235, lexer, s));
return (lex_advance(232, lexer, s));
if (s->lookahead == '\n')
return (lex_skip(234, lexer, s));
return (lex_skip(219, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s221(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(235, lexer, s));
if (s->lookahead == '\n')
return (lex_skip(222, lexer, s));
return (lex_advance(232, lexer, s));
if (lex_normal_map221(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(221, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(445, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(373, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(405, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*')))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s222(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(235, lexer, s));
if (s->lookahead == '\n')
return (lex_advance(290, lexer, s));
if (s->lookahead == '#')
return (lex_advance(408, lexer, s));
if (s->lookahead == '&')
return (lex_advance(331, lexer, s));
if (s->lookahead == ')')
return (lex_advance(257, lexer, s));
if (s->lookahead == ';')
return (lex_advance(499, lexer, s));
if (s->lookahead == '<')
return (lex_advance(272, lexer, s));
if (s->lookahead == '>')
return (lex_advance(275, lexer, s));
if (s->lookahead == '\\')
return (lex_skip(230, lexer, s));
if (s->lookahead == '`')
return (lex_advance(404, lexer, s));
if (s->lookahead == 'e')
return (lex_advance(216, lexer, s));
if (s->lookahead == 'i')
return (lex_advance(214, lexer, s));
if (s->lookahead == '|')
return (lex_advance(256, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_advance(232, lexer, s));
if (lex_normal_map222(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(222, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(446, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(372, lexer, s));
if (s->lookahead != 0)
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s223(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(235, lexer, s));
if (s->lookahead == '\n')
return (lex_advance(290, lexer, s));
if (s->lookahead == '#')
return (lex_advance(408, lexer, s));
if (s->lookahead == '&')
return (lex_advance(331, lexer, s));
if (s->lookahead == ')')
return (lex_advance(257, lexer, s));
if (s->lookahead == ';')
return (lex_advance(499, lexer, s));
if (s->lookahead == '<')
return (lex_advance(272, lexer, s));
if (s->lookahead == '>')
return (lex_advance(275, lexer, s));
if (s->lookahead == '\\')
return (lex_skip(231, lexer, s));
if (s->lookahead == '`')
return (lex_advance(403, lexer, s));
if (s->lookahead == '|')
return (lex_advance(256, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_advance(232, lexer, s));
if (lex_normal_map223(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(223, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(450, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(372, lexer, s));
if (s->lookahead != 0)
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s224(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(235, lexer, s));
if (s->lookahead == '\n')
return (lex_skip(223, lexer, s));
return (lex_advance(232, lexer, s));
if (lex_normal_map224(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(224, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(452, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(373, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(405, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*')))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}

83
parser/static/lex_funcs/lex_normal/state_45.c
View file

@ -15,82 +15,69 @@
bool lex_normal_s225(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(235, lexer, s));
return (lex_advance(232, lexer, s));
if (lex_normal_map225(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(225, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(455, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(380, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(410, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s226(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(235, lexer, s));
if (lex_normal_map226(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(226, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(459, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(380, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(232, lexer, s));
if (s->lookahead == '\r')
return (lex_skip(216, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(231, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s227(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(235, lexer, s));
if (lex_normal_map227(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(227, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(461, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(381, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(413, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*')))
return (lex_advance(497, lexer, s));
return (lex_advance(232, lexer, s));
if (s->lookahead == '\r')
return (lex_skip(217, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(218, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s228(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(235, lexer, s));
if (lex_normal_map228(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
return (lex_advance(232, lexer, s));
if (s->lookahead == '\r')
return (lex_skip(220, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(228, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(418, lexer, s));
return (lex_skip(219, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s229(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(235, lexer, s));
if (s->lookahead == '\r')
return (lex_skip(220, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
return (lex_advance(232, lexer, s));
if (lex_normal_map229(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
return (lex_skip(234, lexer, s));
return (lex_skip(229, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(459, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(372, lexer, s));
if (s->lookahead != 0)
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}

104
parser/static/lex_funcs/lex_normal/state_46.c
View file

@ -15,91 +15,73 @@
bool lex_normal_s230(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(235, lexer, s));
if (s->lookahead == '\r')
return (lex_skip(221, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
return (lex_advance(232, lexer, s));
if (lex_normal_map230(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
return (lex_skip(222, lexer, s));
return (lex_skip(230, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(463, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(372, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != '{' && s->lookahead \
!= '|'))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s231(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(235, lexer, s));
if (s->lookahead == '\r')
return (lex_skip(224, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
return (lex_advance(232, lexer, s));
if (lex_normal_map231(lexer, s))
return (true);
if (s->lookahead == '\\')
return (lex_skip(226, lexer, s));
if (s->lookahead == '^')
return (lex_advance(321, lexer, s));
if (s->lookahead == '`')
return (lex_advance(395, lexer, s));
if (s->lookahead == 'd')
return (lex_advance(212, lexer, s));
if (s->lookahead == 'e')
return (lex_advance(210, lexer, s));
if (s->lookahead == 'f')
return (lex_advance(208, lexer, s));
if (s->lookahead == 'i')
return (lex_advance(211, lexer, s));
if (s->lookahead == '|')
return (lex_advance(250, lexer, s));
if (s->lookahead == '}')
return (lex_advance(256, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(223, lexer, s));
return (lex_skip(231, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s232(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(235, lexer, s));
if (lex_normal_map232(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
return (lex_skip(232, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(468, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(380, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
lex_accept_token(ts_builtin_sym_end, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s233(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(235, lexer, s));
if (lex_normal_map233(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
return (lex_skip(233, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(472, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(380, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != '{' && s->lookahead \
!= '|'))
return (lex_advance(497, lexer, s));
lex_accept_token(anon_sym_in, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s234(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(235, lexer, s));
if (lex_normal_map234(lexer, s))
return (true);
lex_accept_token(anon_sym_in, lexer, s);
if (s->lookahead == '\\')
return (lex_skip(229, lexer, s));
if (s->lookahead == '^')
return (lex_advance(329, lexer, s));
if (s->lookahead == '`')
return (lex_advance(403, lexer, s));
if (s->lookahead == 'd')
return (lex_advance(215, lexer, s));
if (s->lookahead == 'e')
return (lex_advance(213, lexer, s));
if (s->lookahead == 'f')
return (lex_advance(211, lexer, s));
if (s->lookahead == 'i')
return (lex_advance(214, lexer, s));
if (s->lookahead == '|')
return (lex_advance(255, lexer, s));
if (s->lookahead == '}')
return (lex_advance(261, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(234, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}

58
parser/static/lex_funcs/lex_normal/state_47.c
View file

@ -13,42 +13,48 @@
#include "./lex_normal_funcs.h"
bool lex_normal_s235(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(ts_builtin_sym_end, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s236(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_in, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s237(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_in, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(218, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(497, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s238(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_in, lexer, s);
if (((s->lookahead >= '0' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
s->lookahead == '_' || (s->lookahead >= 'a' && \
s->lookahead <= 'z')))
return (lex_advance(418, lexer, s));
return (lex_advance(410, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s236(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_do, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s237(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_do, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(215, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s238(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_fi, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s239(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_do, lexer, s);
lex_accept_token(anon_sym_fi, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(215, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}

40
parser/static/lex_funcs/lex_normal/state_48.c
View file

@ -14,48 +14,42 @@
bool lex_normal_s240(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_do, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(218, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(497, lexer, s));
lex_accept_token(anon_sym_elif, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s241(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_fi, lexer, s);
lex_accept_token(anon_sym_elif, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(215, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s242(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_fi, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(218, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(497, lexer, s));
lex_accept_token(anon_sym_else, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s243(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_elif, lexer, s);
lex_accept_token(anon_sym_else, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(215, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s244(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_elif, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(218, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(497, lexer, s));
lex_accept_token(anon_sym_esac, lexer, s);
return (lex_end_state(lexer, s));
}

65
parser/static/lex_funcs/lex_normal/state_49.c
View file

@ -14,41 +14,17 @@
bool lex_normal_s245(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_else, lexer, s);
lex_accept_token(anon_sym_esac, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(215, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s246(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_else, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(218, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(497, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s247(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_esac, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s248(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_esac, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(218, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(497, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s249(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_esac, lexer, s);
if (s->lookahead == '\\')
@ -57,10 +33,33 @@ bool lex_normal_s249(t_lexer *lexer, t_lexer_state *s)
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
s->lookahead == '_' || (s->lookahead >= 'a' && \
s->lookahead <= 'z')))
return (lex_advance(413, lexer, s));
return (lex_advance(405, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s247(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_esac, lexer, s);
if (((s->lookahead >= '0' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
s->lookahead == '_' || (s->lookahead >= 'a' && \
s->lookahead <= 'z')))
return (lex_advance(410, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s248(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LPAREN, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s249(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PIPE, lexer, s);
return (lex_end_state(lexer, s));
}

24
parser/static/lex_funcs/lex_normal/state_5.c
View file

@ -15,56 +15,56 @@
bool lex_normal_s25(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(425, lexer, s));
return (lex_advance(414, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(23, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(106, lexer, s));
return (lex_skip(99, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s26(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(424, lexer, s));
return (lex_advance(418, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s27(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(424, lexer, s));
return (lex_advance(418, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(26, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(458, lexer, s));
return (lex_advance(452, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(103, lexer, s));
return (lex_skip(105, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s28(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(424, lexer, s));
return (lex_advance(418, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(26, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(103, lexer, s));
return (lex_skip(105, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s29(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(427, lexer, s));
return (lex_advance(420, lexer, s));
return (lex_end_state(lexer, s));
}

37
parser/static/lex_funcs/lex_normal/state_50.c
View file

@ -14,45 +14,42 @@
bool lex_normal_s250(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_esac, lexer, s);
if (((s->lookahead >= '0' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
s->lookahead == '_' || (s->lookahead >= 'a' && \
s->lookahead <= 'z')))
return (lex_advance(418, lexer, s));
lex_accept_token(anon_sym_PIPE, lexer, s);
if (s->lookahead == '=')
return (lex_advance(319, lexer, s));
if (s->lookahead == '|')
return (lex_advance(259, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s251(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LPAREN, lexer, s);
lex_accept_token(anon_sym_PIPE, lexer, s);
if (s->lookahead == '|')
return (lex_advance(259, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s252(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PIPE, lexer, s);
lex_accept_token(anon_sym_RPAREN, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s253(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PIPE, lexer, s);
if (s->lookahead == '&')
return (lex_advance(311, lexer, s));
if (s->lookahead == '=')
return (lex_advance(327, lexer, s));
if (s->lookahead == '|')
return (lex_advance(264, lexer, s));
lex_accept_token(anon_sym_LF, lexer, s);
if (s->lookahead == '\n')
return (lex_advance(253, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(124, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(443, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s254(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PIPE, lexer, s);
if (s->lookahead == '&')
return (lex_advance(311, lexer, s));
if (s->lookahead == '|')
return (lex_advance(264, lexer, s));
lex_accept_token(anon_sym_SEMI_SEMI, lexer, s);
return (lex_end_state(lexer, s));
}

34
parser/static/lex_funcs/lex_normal/state_51.c
View file

@ -14,42 +14,42 @@
bool lex_normal_s255(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PIPE, lexer, s);
if (s->lookahead == '=')
return (lex_advance(327, lexer, s));
if (s->lookahead == '|')
return (lex_advance(264, lexer, s));
lex_accept_token(anon_sym_LBRACE, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(215, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s256(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PIPE, lexer, s);
if (s->lookahead == '|')
return (lex_advance(264, lexer, s));
lex_accept_token(anon_sym_RBRACE, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s257(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_RPAREN, lexer, s);
lex_accept_token(anon_sym_RBRACE, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(215, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s258(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LF, lexer, s);
if (s->lookahead == '\n')
return (lex_advance(258, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(127, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(452, lexer, s));
lex_accept_token(anon_sym_AMP_AMP, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s259(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_SEMI_SEMI, lexer, s);
lex_accept_token(anon_sym_PIPE_PIPE, lexer, s);
return (lex_end_state(lexer, s));
}

36
parser/static/lex_funcs/lex_normal/state_52.c
View file

@ -14,42 +14,44 @@
bool lex_normal_s260(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LBRACE, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(218, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(497, lexer, s));
lex_accept_token(anon_sym_BANG, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s261(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_RBRACE, lexer, s);
lex_accept_token(anon_sym_BANG, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(215, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s262(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_RBRACE, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(218, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(497, lexer, s));
lex_accept_token(anon_sym_EQ, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s263(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_AMP_AMP, lexer, s);
lex_accept_token(anon_sym_EQ, lexer, s);
if (s->lookahead == '=')
return (lex_advance(325, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s264(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PIPE_PIPE, lexer, s);
lex_accept_token(anon_sym_EQ, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(215, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}

52
parser/static/lex_funcs/lex_normal/state_53.c
View file

@ -14,44 +14,60 @@
bool lex_normal_s265(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_BANG, lexer, s);
lex_accept_token(anon_sym_LT, lexer, s);
if (s->lookahead == '&')
return (lex_advance(274, lexer, s));
if (s->lookahead == '<')
return (lex_advance(279, lexer, s));
if (s->lookahead == '=')
return (lex_advance(327, lexer, s));
if (s->lookahead == '>')
return (lex_advance(277, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s266(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_BANG, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(218, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(497, lexer, s));
lex_accept_token(anon_sym_LT, lexer, s);
if (s->lookahead == '&')
return (lex_advance(274, lexer, s));
if (s->lookahead == '<')
return (lex_advance(278, lexer, s));
if (s->lookahead == '>')
return (lex_advance(277, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s267(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_EQ, lexer, s);
lex_accept_token(anon_sym_LT, lexer, s);
if (s->lookahead == '&')
return (lex_advance(274, lexer, s));
if (s->lookahead == '>')
return (lex_advance(277, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s268(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_EQ, lexer, s);
lex_accept_token(anon_sym_LT, lexer, s);
if (s->lookahead == '<')
return (lex_advance(280, lexer, s));
if (s->lookahead == '=')
return (lex_advance(333, lexer, s));
return (lex_advance(327, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s269(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_EQ, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(218, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(497, lexer, s));
lex_accept_token(anon_sym_GT, lexer, s);
if (s->lookahead == '&')
return (lex_advance(275, lexer, s));
if (s->lookahead == '=')
return (lex_advance(328, lexer, s));
if (s->lookahead == '>')
return (lex_advance(273, lexer, s));
if (s->lookahead == '|')
return (lex_advance(276, lexer, s));
return (lex_end_state(lexer, s));
}

40
parser/static/lex_funcs/lex_normal/state_54.c
View file

@ -14,54 +14,42 @@
bool lex_normal_s270(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LT, lexer, s);
lex_accept_token(anon_sym_GT, lexer, s);
if (s->lookahead == '&')
return (lex_advance(279, lexer, s));
return (lex_advance(275, lexer, s));
if (s->lookahead == '>')
return (lex_advance(272, lexer, s));
if (s->lookahead == '|')
return (lex_advance(276, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s271(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LT, lexer, s);
if (s->lookahead == '&')
return (lex_advance(279, lexer, s));
if (s->lookahead == '<')
return (lex_advance(285, lexer, s));
lex_accept_token(anon_sym_GT, lexer, s);
if (s->lookahead == '=')
return (lex_advance(335, lexer, s));
return (lex_advance(328, lexer, s));
if (s->lookahead == '>')
return (lex_advance(273, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s272(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LT, lexer, s);
if (s->lookahead == '&')
return (lex_advance(279, lexer, s));
if (s->lookahead == '<')
return (lex_advance(284, lexer, s));
lex_accept_token(anon_sym_GT_GT, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s273(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LT, lexer, s);
if (s->lookahead == '<')
return (lex_advance(286, lexer, s));
lex_accept_token(anon_sym_GT_GT, lexer, s);
if (s->lookahead == '=')
return (lex_advance(335, lexer, s));
return (lex_advance(315, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s274(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_GT, lexer, s);
if (s->lookahead == '&')
return (lex_advance(280, lexer, s));
if (s->lookahead == '=')
return (lex_advance(336, lexer, s));
if (s->lookahead == '>')
return (lex_advance(278, lexer, s));
if (s->lookahead == '|')
return (lex_advance(281, lexer, s));
lex_accept_token(anon_sym_LT_AMP, lexer, s);
return (lex_end_state(lexer, s));
}

28
parser/static/lex_funcs/lex_normal/state_55.c
View file

@ -14,44 +14,36 @@
bool lex_normal_s275(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_GT, lexer, s);
if (s->lookahead == '&')
return (lex_advance(280, lexer, s));
if (s->lookahead == '>')
return (lex_advance(277, lexer, s));
if (s->lookahead == '|')
return (lex_advance(281, lexer, s));
lex_accept_token(anon_sym_GT_AMP, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s276(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_GT, lexer, s);
if (s->lookahead == '=')
return (lex_advance(336, lexer, s));
if (s->lookahead == '>')
return (lex_advance(278, lexer, s));
lex_accept_token(anon_sym_GT_PIPE, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s277(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_GT_GT, lexer, s);
lex_accept_token(anon_sym_LT_GT, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s278(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_GT_GT, lexer, s);
if (s->lookahead == '=')
return (lex_advance(323, lexer, s));
lex_accept_token(anon_sym_LT_LT, lexer, s);
if (s->lookahead == '-')
return (lex_advance(281, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s279(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LT_AMP, lexer, s);
lex_accept_token(anon_sym_LT_LT, lexer, s);
if (s->lookahead == '-')
return (lex_advance(282, lexer, s));
return (lex_advance(281, lexer, s));
if (s->lookahead == '=')
return (lex_advance(314, lexer, s));
return (lex_end_state(lexer, s));
}

31
parser/static/lex_funcs/lex_normal/state_56.c
View file

@ -14,34 +14,47 @@
bool lex_normal_s280(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_GT_AMP, lexer, s);
if (s->lookahead == '-')
return (lex_advance(283, lexer, s));
lex_accept_token(anon_sym_LT_LT, lexer, s);
if (s->lookahead == '=')
return (lex_advance(314, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s281(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_GT_PIPE, lexer, s);
lex_accept_token(anon_sym_LT_LT_DASH, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s282(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LT_AMP_DASH, lexer, s);
lex_accept_token(aux_sym_heredoc_redirect_token1, lexer, \
s);
if (s->lookahead == '\n')
return (lex_advance(282, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(13, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(444, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s283(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_GT_AMP_DASH, lexer, s);
lex_accept_token(aux_sym_heredoc_redirect_token1, lexer, \
s);
if (s->lookahead == '\n')
return (lex_advance(283, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(50, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s284(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LT_LT, lexer, s);
if (s->lookahead == '-')
return (lex_advance(287, lexer, s));
lex_accept_token(aux_sym_heredoc_redirect_token1, lexer, \
s);
if (s->lookahead == '\n')
return (lex_advance(284, lexer, s));
return (lex_end_state(lexer, s));
}

39
parser/static/lex_funcs/lex_normal/state_57.c
View file

@ -14,25 +14,40 @@
bool lex_normal_s285(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LT_LT, lexer, s);
if (s->lookahead == '-')
return (lex_advance(287, lexer, s));
if (s->lookahead == '=')
return (lex_advance(322, lexer, s));
lex_accept_token(aux_sym_heredoc_redirect_token1, lexer, \
s);
if (s->lookahead == '\n')
return (lex_advance(285, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(19, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(445, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s286(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LT_LT, lexer, s);
if (s->lookahead == '=')
return (lex_advance(322, lexer, s));
lex_accept_token(aux_sym_heredoc_redirect_token1, lexer, \
s);
if (s->lookahead == '\n')
return (lex_advance(286, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(134, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(446, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s287(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LT_LT_DASH, lexer, s);
lex_accept_token(aux_sym_heredoc_redirect_token1, lexer, \
s);
if (s->lookahead == '\n')
return (lex_advance(287, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(136, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(447, lexer, s));
return (lex_end_state(lexer, s));
}
@ -43,9 +58,9 @@ bool lex_normal_s288(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(288, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(13, lexer, s));
return (lex_advance(25, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(453, lexer, s));
return (lex_advance(448, lexer, s));
return (lex_end_state(lexer, s));
}
@ -56,6 +71,6 @@ bool lex_normal_s289(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(289, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(50, lexer, s));
return (lex_advance(52, lexer, s));
return (lex_end_state(lexer, s));
}

20
parser/static/lex_funcs/lex_normal/state_58.c
View file

@ -18,6 +18,10 @@ bool lex_normal_s290(t_lexer *lexer, t_lexer_state *s)
s);
if (s->lookahead == '\n')
return (lex_advance(290, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(22, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(449, lexer, s));
return (lex_end_state(lexer, s));
}
@ -28,9 +32,9 @@ bool lex_normal_s291(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(291, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(22, lexer, s));
return (lex_advance(139, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(454, lexer, s));
return (lex_advance(450, lexer, s));
return (lex_end_state(lexer, s));
}
@ -41,9 +45,9 @@ bool lex_normal_s292(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(292, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(137, lexer, s));
return (lex_advance(141, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(455, lexer, s));
return (lex_advance(451, lexer, s));
return (lex_end_state(lexer, s));
}
@ -54,9 +58,7 @@ bool lex_normal_s293(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(293, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(139, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(456, lexer, s));
return (lex_advance(54, lexer, s));
return (lex_end_state(lexer, s));
}
@ -67,8 +69,8 @@ bool lex_normal_s294(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(294, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(19, lexer, s));
return (lex_advance(28, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(457, lexer, s));
return (lex_advance(452, lexer, s));
return (lex_end_state(lexer, s));
}

18
parser/static/lex_funcs/lex_normal/state_59.c
View file

@ -19,7 +19,7 @@ bool lex_normal_s295(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(295, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(52, lexer, s));
return (lex_advance(56, lexer, s));
return (lex_end_state(lexer, s));
}
@ -30,9 +30,9 @@ bool lex_normal_s296(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(296, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(28, lexer, s));
return (lex_advance(31, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(458, lexer, s));
return (lex_advance(453, lexer, s));
return (lex_end_state(lexer, s));
}
@ -43,9 +43,7 @@ bool lex_normal_s297(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(297, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(142, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(459, lexer, s));
return (lex_advance(63, lexer, s));
return (lex_end_state(lexer, s));
}
@ -56,9 +54,9 @@ bool lex_normal_s298(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(298, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(146, lexer, s));
return (lex_advance(36, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(460, lexer, s));
return (lex_advance(454, lexer, s));
return (lex_end_state(lexer, s));
}
@ -69,8 +67,6 @@ bool lex_normal_s299(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(299, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(25, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(461, lexer, s));
return (lex_advance(76, lexer, s));
return (lex_end_state(lexer, s));
}

20
parser/static/lex_funcs/lex_normal/state_6.c
View file

@ -15,49 +15,49 @@
bool lex_normal_s30(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(427, lexer, s));
return (lex_advance(420, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(29, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(462, lexer, s));
return (lex_advance(453, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(108, lexer, s));
return (lex_skip(107, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s31(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(427, lexer, s));
return (lex_advance(420, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(29, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(108, lexer, s));
return (lex_skip(107, lexer, s));
if (s->lookahead != 0)
return (lex_advance(497, lexer, s));
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s32(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(99, lexer, s));
return (lex_skip(97, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s33(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(100, lexer, s));
return (lex_skip(98, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s34(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(429, lexer, s));
return (lex_advance(422, lexer, s));
return (lex_end_state(lexer, s));
}

23
parser/static/lex_funcs/lex_normal/state_60.c
View file

@ -19,7 +19,9 @@ bool lex_normal_s300(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(300, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(54, lexer, s));
return (lex_advance(39, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(455, lexer, s));
return (lex_end_state(lexer, s));
}
@ -30,9 +32,9 @@ bool lex_normal_s301(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(301, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(31, lexer, s));
return (lex_advance(94, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(462, lexer, s));
return (lex_advance(456, lexer, s));
return (lex_end_state(lexer, s));
}
@ -43,7 +45,9 @@ bool lex_normal_s302(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(302, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(56, lexer, s));
return (lex_advance(68, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(457, lexer, s));
return (lex_end_state(lexer, s));
}
@ -54,19 +58,14 @@ bool lex_normal_s303(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(303, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(36, lexer, s));
return (lex_advance(72, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(463, lexer, s));
return (lex_advance(458, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s304(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(aux_sym_heredoc_redirect_token1, lexer, \
s);
if (s->lookahead == '\n')
return (lex_advance(304, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(63, lexer, s));
lex_accept_token(anon_sym_DOLLAR_LPAREN_LPAREN, lexer, s);
return (lex_end_state(lexer, s));
}

45
parser/static/lex_funcs/lex_normal/state_61.c
View file

@ -14,61 +14,36 @@
bool lex_normal_s305(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(aux_sym_heredoc_redirect_token1, lexer, \
s);
if (s->lookahead == '\n')
return (lex_advance(305, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(39, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(464, lexer, s));
lex_accept_token(anon_sym_RPAREN_RPAREN, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s306(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(aux_sym_heredoc_redirect_token1, lexer, \
s);
if (s->lookahead == '\n')
return (lex_advance(306, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(97, lexer, s));
lex_accept_token(anon_sym_PLUS_EQ, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s307(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(aux_sym_heredoc_redirect_token1, lexer, \
s);
if (s->lookahead == '\n')
return (lex_advance(307, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(94, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(465, lexer, s));
lex_accept_token(anon_sym_DASH_EQ, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s308(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(aux_sym_heredoc_redirect_token1, lexer, \
s);
if (s->lookahead == '\n')
return (lex_advance(308, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(76, lexer, s));
lex_accept_token(anon_sym_STAR_EQ, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s309(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(aux_sym_heredoc_redirect_token1, lexer, \
s);
if (s->lookahead == '\n')
return (lex_advance(309, lexer, s));
lex_accept_token(anon_sym_STAR_EQ, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(68, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(466, lexer, s));
return (lex_advance(215, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}

29
parser/static/lex_funcs/lex_normal/state_62.c
View file

@ -14,37 +14,42 @@
bool lex_normal_s310(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(aux_sym_heredoc_redirect_token1, lexer, \
s);
if (s->lookahead == '\n')
return (lex_advance(310, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(72, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(467, lexer, s));
lex_accept_token(anon_sym_SLASH_EQ, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s311(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PIPE_AMP, lexer, s);
lex_accept_token(anon_sym_SLASH_EQ, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(215, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s312(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_DOLLAR_LPAREN_LPAREN, lexer, s);
lex_accept_token(anon_sym_PERCENT_EQ, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s313(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_RPAREN_RPAREN, lexer, s);
lex_accept_token(anon_sym_PERCENT_EQ, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(215, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s314(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PLUS_EQ, lexer, s);
lex_accept_token(anon_sym_LT_LT_EQ, lexer, s);
return (lex_end_state(lexer, s));
}

28
parser/static/lex_funcs/lex_normal/state_63.c
View file

@ -14,42 +14,36 @@
bool lex_normal_s315(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_DASH_EQ, lexer, s);
lex_accept_token(anon_sym_GT_GT_EQ, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s316(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_STAR_EQ, lexer, s);
lex_accept_token(anon_sym_AMP_EQ, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s317(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_STAR_EQ, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(218, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(497, lexer, s));
lex_accept_token(anon_sym_CARET_EQ, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s318(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_SLASH_EQ, lexer, s);
lex_accept_token(anon_sym_CARET_EQ, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(215, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s319(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_SLASH_EQ, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(218, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(497, lexer, s));
lex_accept_token(anon_sym_PIPE_EQ, lexer, s);
return (lex_end_state(lexer, s));
}

32
parser/static/lex_funcs/lex_normal/state_64.c
View file

@ -14,36 +14,46 @@
bool lex_normal_s320(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PERCENT_EQ, lexer, s);
lex_accept_token(anon_sym_CARET, lexer, s);
if (s->lookahead == '=')
return (lex_advance(318, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(215, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s321(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PERCENT_EQ, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(218, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(497, lexer, s));
lex_accept_token(anon_sym_CARET, lexer, s);
if (s->lookahead == '=')
return (lex_advance(317, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s322(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LT_LT_EQ, lexer, s);
lex_accept_token(anon_sym_AMP, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s323(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_GT_GT_EQ, lexer, s);
lex_accept_token(anon_sym_AMP, lexer, s);
if (s->lookahead == '&')
return (lex_advance(258, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s324(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_AMP_EQ, lexer, s);
lex_accept_token(anon_sym_AMP, lexer, s);
if (s->lookahead == '&')
return (lex_advance(258, lexer, s));
if (s->lookahead == '=')
return (lex_advance(316, lexer, s));
return (lex_end_state(lexer, s));
}

28
parser/static/lex_funcs/lex_normal/state_65.c
View file

@ -14,46 +14,34 @@
bool lex_normal_s325(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_CARET_EQ, lexer, s);
lex_accept_token(anon_sym_EQ_EQ, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s326(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_CARET_EQ, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(218, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(497, lexer, s));
lex_accept_token(anon_sym_BANG_EQ, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s327(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PIPE_EQ, lexer, s);
lex_accept_token(anon_sym_LT_EQ, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s328(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_CARET, lexer, s);
if (s->lookahead == '=')
return (lex_advance(326, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(218, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(497, lexer, s));
lex_accept_token(anon_sym_GT_EQ, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s329(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_CARET, lexer, s);
lex_accept_token(anon_sym_PLUS, lexer, s);
if (s->lookahead == '+')
return (lex_advance(354, lexer, s));
if (s->lookahead == '=')
return (lex_advance(325, lexer, s));
return (lex_advance(306, lexer, s));
return (lex_end_state(lexer, s));
}

Some files were not shown because too many files have changed in this diff Show more