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

Updated grammar

Browse source
This commit is contained in:
Maix0 2024-07-02 21:01:18 +02:00
parent dcdefc2ac3
commit 63e1d5d05f
1136 changed files with 81301 additions and 91678 deletions
Download patch file Download diff file Expand all files Collapse all files

120
parser/Filelist.mk
View file

@ -6,9 +6,7 @@ create/create_external_scanner_symbol_map \
create/create_field_map_entries \ create/create_field_map_entries \
create/create_field_map_slices \ create/create_field_map_slices \
create/create_field_names \ create/create_field_names \
create/create_lex_keywords \
create/create_lex_modes \ create/create_lex_modes \
create/create_lex_normal \
create/create_non_terminal_alias_map \ create/create_non_terminal_alias_map \
create/create_parse_actions_entries \ create/create_parse_actions_entries \
create/create_parse_table \ create/create_parse_table \
@ -27,120 +25,6 @@ field_map_entries/field_map_entries_1 \
field_map_entries/field_map_entries_2 \ field_map_entries/field_map_entries_2 \
field_map_slices/field_map_slices_0 \ field_map_slices/field_map_slices_0 \
field_names/field_names_0 \ field_names/field_names_0 \
lex_funcs/lex_keywords/create_table/lex_keywords_array_0 \
lex_funcs/lex_keywords/main_func \
lex_funcs/lex_keywords/state_0 \
lex_funcs/lex_keywords/state_1 \
lex_funcs/lex_keywords/state_2 \
lex_funcs/lex_keywords/state_3 \
lex_funcs/lex_keywords/state_4 \
lex_funcs/lex_keywords/state_5 \
lex_funcs/lex_keywords/state_6 \
lex_funcs/lex_normal/create_table/lex_normal_array_0 \
lex_funcs/lex_normal/create_table/lex_normal_array_1 \
lex_funcs/lex_normal/create_table/lex_normal_array_2 \
lex_funcs/lex_normal/create_table/lex_normal_array_3 \
lex_funcs/lex_normal/create_table/lex_normal_array_4 \
lex_funcs/lex_normal/main_func \
lex_funcs/lex_normal/state_0 \
lex_funcs/lex_normal/state_1 \
lex_funcs/lex_normal/state_2 \
lex_funcs/lex_normal/state_3 \
lex_funcs/lex_normal/state_4 \
lex_funcs/lex_normal/state_5 \
lex_funcs/lex_normal/state_6 \
lex_funcs/lex_normal/state_7 \
lex_funcs/lex_normal/state_8 \
lex_funcs/lex_normal/state_9 \
lex_funcs/lex_normal/state_10 \
lex_funcs/lex_normal/state_11 \
lex_funcs/lex_normal/state_12 \
lex_funcs/lex_normal/state_13 \
lex_funcs/lex_normal/state_14 \
lex_funcs/lex_normal/state_15 \
lex_funcs/lex_normal/state_16 \
lex_funcs/lex_normal/state_17 \
lex_funcs/lex_normal/state_18 \
lex_funcs/lex_normal/state_19 \
lex_funcs/lex_normal/state_20 \
lex_funcs/lex_normal/state_21 \
lex_funcs/lex_normal/state_22 \
lex_funcs/lex_normal/state_23 \
lex_funcs/lex_normal/state_24 \
lex_funcs/lex_normal/state_25 \
lex_funcs/lex_normal/state_26 \
lex_funcs/lex_normal/state_27 \
lex_funcs/lex_normal/state_28 \
lex_funcs/lex_normal/state_29 \
lex_funcs/lex_normal/state_30 \
lex_funcs/lex_normal/state_31 \
lex_funcs/lex_normal/state_32 \
lex_funcs/lex_normal/state_33 \
lex_funcs/lex_normal/state_34 \
lex_funcs/lex_normal/state_35 \
lex_funcs/lex_normal/state_36 \
lex_funcs/lex_normal/state_37 \
lex_funcs/lex_normal/state_38 \
lex_funcs/lex_normal/state_39 \
lex_funcs/lex_normal/state_40 \
lex_funcs/lex_normal/state_41 \
lex_funcs/lex_normal/state_42 \
lex_funcs/lex_normal/state_43 \
lex_funcs/lex_normal/state_44 \
lex_funcs/lex_normal/state_45 \
lex_funcs/lex_normal/state_46 \
lex_funcs/lex_normal/state_47 \
lex_funcs/lex_normal/state_48 \
lex_funcs/lex_normal/state_49 \
lex_funcs/lex_normal/state_50 \
lex_funcs/lex_normal/state_51 \
lex_funcs/lex_normal/state_52 \
lex_funcs/lex_normal/state_53 \
lex_funcs/lex_normal/state_54 \
lex_funcs/lex_normal/state_55 \
lex_funcs/lex_normal/state_56 \
lex_funcs/lex_normal/state_57 \
lex_funcs/lex_normal/state_58 \
lex_funcs/lex_normal/state_59 \
lex_funcs/lex_normal/state_60 \
lex_funcs/lex_normal/state_61 \
lex_funcs/lex_normal/state_62 \
lex_funcs/lex_normal/state_63 \
lex_funcs/lex_normal/state_64 \
lex_funcs/lex_normal/state_65 \
lex_funcs/lex_normal/state_66 \
lex_funcs/lex_normal/state_67 \
lex_funcs/lex_normal/state_68 \
lex_funcs/lex_normal/state_69 \
lex_funcs/lex_normal/state_70 \
lex_funcs/lex_normal/state_71 \
lex_funcs/lex_normal/state_72 \
lex_funcs/lex_normal/state_73 \
lex_funcs/lex_normal/state_74 \
lex_funcs/lex_normal/state_75 \
lex_funcs/lex_normal/state_76 \
lex_funcs/lex_normal/state_77 \
lex_funcs/lex_normal/state_78 \
lex_funcs/lex_normal/state_79 \
lex_funcs/lex_normal/state_80 \
lex_funcs/lex_normal/state_81 \
lex_funcs/lex_normal/state_82 \
lex_funcs/lex_normal/state_83 \
lex_funcs/lex_normal/state_84 \
lex_funcs/lex_normal/state_85 \
lex_funcs/lex_normal/state_86 \
lex_funcs/lex_normal/state_87 \
lex_funcs/lex_normal/state_88 \
lex_funcs/lex_normal/state_89 \
lex_funcs/lex_normal/state_90 \
lex_funcs/lex_normal/state_91 \
lex_funcs/lex_normal/state_92 \
lex_funcs/lex_normal/state_93 \
lex_funcs/lex_normal/state_94 \
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_modes/lex_modes_0 \ lex_modes/lex_modes_0 \
lex_modes/lex_modes_1 \ lex_modes/lex_modes_1 \
lex_modes/lex_modes_2 \ lex_modes/lex_modes_2 \
@ -1067,6 +951,10 @@ small_parse_table/small_parse_table_833 \
small_parse_table/small_parse_table_834 \ small_parse_table/small_parse_table_834 \
small_parse_table/small_parse_table_835 \ small_parse_table/small_parse_table_835 \
small_parse_table/small_parse_table_836 \ 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_map/small_parse_table_map_0 \ 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_1 \
small_parse_table_map/small_parse_table_map_2 \ small_parse_table_map/small_parse_table_map_2 \

3401
parser/src/lex.c
View file

File diff suppressed because it is too large Load diff

21
parser/src/scanner.c
View file

@ -401,7 +401,7 @@ static bool scan(Scanner *scanner, TSLexer *lexer, const bool *valid_symbols)
{ {
if (!(lexer->lookahead == 0 || iswspace(lexer->lookahead) || lexer->lookahead == '>' || lexer->lookahead == '<' || if (!(lexer->lookahead == 0 || iswspace(lexer->lookahead) || lexer->lookahead == '>' || lexer->lookahead == '<' ||
lexer->lookahead == ')' || lexer->lookahead == '(' || lexer->lookahead == ';' || lexer->lookahead == '&' || lexer->lookahead == ')' || lexer->lookahead == '(' || lexer->lookahead == ';' || lexer->lookahead == '&' ||
lexer->lookahead == '|')) lexer->lookahead == '|' || lexer->lookahead == '{' || lexer->lookahead == '}'))
{ {
lexer->result_symbol = CONCAT; lexer->result_symbol = CONCAT;
// So for a`b`, we want to return a concat. We check if the // So for a`b`, we want to return a concat. We check if the
@ -584,10 +584,10 @@ static bool scan(Scanner *scanner, TSLexer *lexer, const bool *valid_symbols)
array_push(&scanner->heredocs, heredoc); array_push(&scanner->heredocs, heredoc);
lexer->result_symbol = HEREDOC_ARROW_DASH; lexer->result_symbol = HEREDOC_ARROW_DASH;
} }
else if (lexer->lookahead == '<' || lexer->lookahead == '=') // else if (lexer->lookahead == '<' || lexer->lookahead == '=')
{ // {
return false; // return false;
} // }
else else
{ {
Heredoc heredoc = heredoc_new(); Heredoc heredoc = heredoc_new();
@ -1085,9 +1085,7 @@ expansion_word:
for (;;) for (;;)
{ {
if (lexer->lookahead == '\"') if (lexer->lookahead == '\"')
{
return false; return false;
}
if (lexer->lookahead == '$') if (lexer->lookahead == '$')
{ {
lexer->mark_end(lexer); lexer->mark_end(lexer);
@ -1142,25 +1140,16 @@ expansion_word:
advance(lexer); advance(lexer);
lexer->mark_end(lexer); lexer->mark_end(lexer);
if (lexer->lookahead == '}') if (lexer->lookahead == '}')
{
return false; return false;
} }
}
else else
{
return false; return false;
} }
}
if (lexer->lookahead == '\'') if (lexer->lookahead == '\'')
{
return false; return false;
}
if (lexer->eof(lexer)) if (lexer->eof(lexer))
{
return false; return false;
}
advanced_once = advanced_once || !iswspace(lexer->lookahead); advanced_once = advanced_once || !iswspace(lexer->lookahead);
advance_once_space = advance_once_space || iswspace(lexer->lookahead); advance_once_space = advance_once_space || iswspace(lexer->lookahead);
advance(lexer); advance(lexer);

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

@ -14,42 +14,46 @@
void alias_sequences_0(t_alias_sequences_array *v) void alias_sequences_0(t_alias_sequences_array *v)
{ {
v->a[6][1] = anon_sym_POUND; v->a[6][1] = anon_sym_AT;
v->a[7][0] = anon_sym_POUND; v->a[7][0] = anon_sym_AT;
v->a[10][0] = anon_sym_DOLLAR; v->a[10][0] = anon_sym_DOLLAR;
v->a[21][0] = sym__immediate_double_hash; v->a[21][0] = sym__immediate_double_hash;
v->a[23][1] = sym_string_content; v->a[23][1] = sym_string_content;
v->a[26][0] = anon_sym_POUND; v->a[26][0] = anon_sym_AT;
v->a[34][1] = alias_sym_statements; v->a[28][1] = anon_sym_AT;
v->a[37][1] = sym__immediate_double_hash; v->a[36][1] = alias_sym_statements;
v->a[38][2] = sym_string_content; v->a[39][1] = sym__immediate_double_hash;
v->a[39][3] = sym_word; v->a[40][2] = sym_string_content;
v->a[40][0] = sym_regex; v->a[41][3] = sym_word;
v->a[42][1] = alias_sym_statements; v->a[42][0] = sym_regex;
v->a[43][1] = alias_sym_statements; v->a[45][1] = anon_sym_AT;
v->a[43][3] = alias_sym_statements; v->a[47][1] = alias_sym_statements;
v->a[44][1] = alias_sym_statements; v->a[48][1] = alias_sym_statements;
v->a[45][1] = alias_sym_statements; v->a[48][3] = alias_sym_statements;
v->a[49][1] = alias_sym_statements;
v->a[50][1] = alias_sym_statements; v->a[50][1] = alias_sym_statements;
v->a[50][3] = alias_sym_statements; v->a[53][0] = sym_word;
v->a[51][1] = alias_sym_statements; v->a[56][1] = alias_sym_statements;
v->a[51][3] = alias_sym_statements;
alias_sequences_1(v); alias_sequences_1(v);
} }
void alias_sequences_1(t_alias_sequences_array *v) void alias_sequences_1(t_alias_sequences_array *v)
{ {
v->a[52][1] = alias_sym_statements; v->a[56][3] = alias_sym_statements;
v->a[53][2] = alias_sym_statements; v->a[57][1] = alias_sym_statements;
v->a[62][1] = alias_sym_statements; v->a[57][3] = alias_sym_statements;
v->a[62][3] = alias_sym_statements; v->a[58][1] = alias_sym_statements;
v->a[63][3] = alias_sym_statements; v->a[59][2] = alias_sym_statements;
v->a[64][3] = alias_sym_statements; v->a[64][1] = sym_word;
v->a[65][3] = alias_sym_statements; v->a[69][1] = alias_sym_statements;
v->a[72][4] = alias_sym_statements; v->a[69][3] = alias_sym_statements;
v->a[73][4] = alias_sym_statements; v->a[70][3] = alias_sym_statements;
v->a[74][4] = alias_sym_statements; v->a[71][3] = alias_sym_statements;
v->a[77][5] = alias_sym_statements; v->a[72][3] = alias_sym_statements;
v->a[79][4] = alias_sym_statements;
v->a[80][4] = alias_sym_statements;
v->a[81][4] = alias_sym_statements;
v->a[84][5] = alias_sym_statements;
} }
/* EOF alias_sequences_0.c */ /* EOF alias_sequences_0.c */

9
parser/static/char_set/charset_inline.h
View file

@ -33,4 +33,13 @@ static inline t_char_range *sym_word_character_set_1(void)
return (val); return (val);
} }
static inline t_char_range *aux_sym__word_no_brace_token1_character_set_2(void)
{
static t_char_range val[10] = {{0, 0x08}, {0x0b, 0x1f}, \
{'!', '!'}, {'#', '#'}, {'%', '%'}, {'*', ':'}, {'=', \
'='}, {'?', '_'}, {'a', 'z'}, {'~', 0x10ffff}};
return (val);
}
#endif // CHARSET_INLINE_H #endif // CHARSET_INLINE_H

29
parser/static/create/create_lex_normal.c
View file

@ -1,29 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* create_lex_normal.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 "../types/type_lex_normal.h"
#include "../lex_funcs/lex_normal/create_table/lex_normal_array.h"
t_lex_normal_array *create_lex_normal(void)
{
static t_lex_normal_array table = {};
static bool init = false;
if (!init)
{
lex_normal_array_0(&table);
init = true;
}
return (&table);
}
/* create_lex_normal.c */

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

@ -48,7 +48,6 @@ 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_LT_LT_DASH] = true;
v->a[3][ts_external_token_heredoc_redirect_token1] = 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_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_file_descriptor] = true;
v->a[4][ts_external_token_variable_name] = true; v->a[4][ts_external_token_variable_name] = true;
v->a[4][ts_external_token__bare_dollar] = true; v->a[4][ts_external_token__bare_dollar] = true;
@ -56,6 +55,7 @@ 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_LT_LT_DASH] = true;
v->a[4][ts_external_token_heredoc_redirect_token1] = 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_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_file_descriptor] = true;
v->a[5][ts_external_token_variable_name] = true; v->a[5][ts_external_token_variable_name] = true;
v->a[5][ts_external_token__bare_dollar] = true; v->a[5][ts_external_token__bare_dollar] = true;
@ -67,70 +67,70 @@ 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] = true;
v->a[5][ts_external_token_LT_LT_DASH] = 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_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_file_descriptor] = true;
v->a[6][ts_external_token_variable_name] = 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__bare_dollar] = true;
v->a[6][ts_external_token_LT_LT] = 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_LT_LT_DASH] = true;
v->a[6][ts_external_token_heredoc_redirect_token1] = 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_file_descriptor] = true;
v->a[7][ts_external_token_variable_name] = 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] = true;
v->a[7][ts_external_token_LT_LT_DASH] = 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_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_file_descriptor] = true;
v->a[8][ts_external_token_variable_name] = 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] = true;
v->a[8][ts_external_token_LT_LT_DASH] = 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); external_scanner_states_3(v);
} }
void external_scanner_states_3(t_external_scanner_states_array *v) void external_scanner_states_3(t_external_scanner_states_array *v)
{ {
v->a[8][ts_external_token_heredoc_redirect_token1] = true; v->a[8][ts_external_token_esac] = true;
v->a[9][ts_external_token_file_descriptor] = 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__bare_dollar] = true;
v->a[9][ts_external_token_LT_LT] = true; v->a[9][ts_external_token_LT_LT] = true;
v->a[9][ts_external_token_LT_LT_DASH] = true; v->a[9][ts_external_token_LT_LT_DASH] = true;
v->a[9][ts_external_token_heredoc_redirect_token1] = true; v->a[9][ts_external_token_heredoc_redirect_token1] = true;
v->a[9][ts_external_token_LPAREN] = true; v->a[9][ts_external_token_LPAREN] = true;
v->a[9][ts_external_token_esac] = true;
v->a[10][ts_external_token_file_descriptor] = true; v->a[10][ts_external_token_file_descriptor] = true;
v->a[10][ts_external_token__bare_dollar] = true; v->a[10][ts_external_token__bare_dollar] = true;
v->a[10][ts_external_token_LT_LT] = true; v->a[10][ts_external_token_LT_LT] = true;
v->a[10][ts_external_token_LT_LT_DASH] = true; v->a[10][ts_external_token_LT_LT_DASH] = true;
v->a[10][ts_external_token_heredoc_redirect_token1] = true; v->a[10][ts_external_token_heredoc_redirect_token1] = true;
v->a[10][ts_external_token_LPAREN] = true; v->a[10][ts_external_token_LPAREN] = true;
v->a[10][ts_external_token_esac] = true;
v->a[11][ts_external_token_file_descriptor] = true; v->a[11][ts_external_token_file_descriptor] = true;
v->a[11][ts_external_token_variable_name] = true;
v->a[11][ts_external_token__bare_dollar] = true; v->a[11][ts_external_token__bare_dollar] = true;
v->a[11][ts_external_token_LT_LT] = true; 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_LT_LT_DASH] = true;
v->a[11][ts_external_token_heredoc_redirect_token1] = true; v->a[11][ts_external_token_LPAREN] = true;
v->a[12][ts_external_token_file_descriptor] = true;
external_scanner_states_4(v); external_scanner_states_4(v);
} }
void external_scanner_states_4(t_external_scanner_states_array *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__bare_dollar] = true;
v->a[12][ts_external_token_LT_LT] = 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_LT_LT_DASH] = true;
v->a[12][ts_external_token_heredoc_redirect_token1] = 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_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__bare_dollar] = true;
v->a[13][ts_external_token_LT_LT] = 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_LT_LT_DASH] = true;
v->a[13][ts_external_token_LPAREN] = true; v->a[13][ts_external_token_heredoc_redirect_token1] = true;
v->a[13][ts_external_token_esac] = true;
v->a[14][ts_external_token_LT_LT] = true; v->a[14][ts_external_token_LT_LT] = true;
v->a[15][ts_external_token_file_descriptor] = true; v->a[15][ts_external_token_file_descriptor] = true;
v->a[15][ts_external_token_variable_name] = true;
v->a[15][ts_external_token__bare_dollar] = true;
v->a[15][ts_external_token_LT_LT] = 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_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_file_descriptor] = true;
v->a[16][ts_external_token_LT_LT] = 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_LT_LT_DASH] = true;

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

@ -16,10 +16,10 @@ void external_scanner_states_5(t_external_scanner_states_array *v)
{ {
v->a[16][ts_external_token_heredoc_redirect_token1] = 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_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] = true;
v->a[17][ts_external_token_LT_LT_DASH] = true; v->a[17][ts_external_token_LT_LT_DASH] = true;
v->a[17][ts_external_token_heredoc_redirect_token1] = true;
v->a[17][ts_external_token_esac] = true;
v->a[18][ts_external_token_file_descriptor] = 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_variable_name] = true;
v->a[18][ts_external_token_LT_LT] = true; v->a[18][ts_external_token_LT_LT] = true;
@ -57,14 +57,19 @@ void external_scanner_states_6(t_external_scanner_states_array *v)
v->a[23][ts_external_token_LT_LT] = 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_LT_LT_DASH] = true;
v->a[23][ts_external_token_heredoc_redirect_token1] = true; v->a[23][ts_external_token_heredoc_redirect_token1] = true;
v->a[23][ts_external_token_esac] = true;
v->a[24][ts_external_token_file_descriptor] = true; v->a[24][ts_external_token_file_descriptor] = true;
v->a[24][ts_external_token_variable_name] = true;
external_scanner_states_7(v); external_scanner_states_7(v);
} }
void external_scanner_states_7(t_external_scanner_states_array *v) void external_scanner_states_7(t_external_scanner_states_array *v)
{ {
v->a[24][ts_external_token__concat] = true;
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_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_file_descriptor] = true;
v->a[25][ts_external_token__concat] = true; v->a[25][ts_external_token__concat] = true;
v->a[25][ts_external_token_variable_name] = true; v->a[25][ts_external_token_variable_name] = true;
@ -73,27 +78,23 @@ void external_scanner_states_7(t_external_scanner_states_array *v)
v->a[25][ts_external_token_heredoc_redirect_token1] = true; v->a[25][ts_external_token_heredoc_redirect_token1] = true;
v->a[26][ts_external_token_file_descriptor] = true; v->a[26][ts_external_token_file_descriptor] = true;
v->a[26][ts_external_token__concat] = true; v->a[26][ts_external_token__concat] = true;
v->a[26][ts_external_token_variable_name] = true; v->a[26][ts_external_token__bare_dollar] = true;
v->a[26][ts_external_token_LT_LT] = 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_LT_LT_DASH] = true;
v->a[26][ts_external_token_heredoc_redirect_token1] = 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_file_descriptor] = true;
v->a[27][ts_external_token__concat] = true; v->a[27][ts_external_token_variable_name] = 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); external_scanner_states_8(v);
} }
void external_scanner_states_8(t_external_scanner_states_array *v) void external_scanner_states_8(t_external_scanner_states_array *v)
{ {
v->a[27][ts_external_token_esac] = true; v->a[27][ts_external_token_heredoc_redirect_token1] = true;
v->a[28][ts_external_token_file_descriptor] = true; v->a[28][ts_external_token_file_descriptor] = true;
v->a[28][ts_external_token__bare_dollar] = true; v->a[28][ts_external_token__concat] = true;
v->a[28][ts_external_token_LT_LT] = 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_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_file_descriptor] = true;
v->a[29][ts_external_token__concat] = 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] = true;
@ -101,10 +102,9 @@ void external_scanner_states_8(t_external_scanner_states_array *v)
v->a[29][ts_external_token_heredoc_redirect_token1] = true; v->a[29][ts_external_token_heredoc_redirect_token1] = true;
v->a[29][ts_external_token_esac] = true; v->a[29][ts_external_token_esac] = true;
v->a[30][ts_external_token_file_descriptor] = true; v->a[30][ts_external_token_file_descriptor] = true;
v->a[30][ts_external_token__concat] = true; v->a[30][ts_external_token__bare_dollar] = true;
v->a[30][ts_external_token_LT_LT] = 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_LT_LT_DASH] = true;
v->a[30][ts_external_token_heredoc_redirect_token1] = true;
v->a[31][ts_external_token_file_descriptor] = 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] = true;
v->a[31][ts_external_token_LT_LT_DASH] = true; v->a[31][ts_external_token_LT_LT_DASH] = 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[36][ts_external_token_esac] = true;
v->a[37][ts_external_token_file_descriptor] = true; v->a[37][ts_external_token_file_descriptor] = true;
v->a[37][ts_external_token__concat] = true; v->a[37][ts_external_token__concat] = true;
v->a[37][ts_external_token__bare_dollar] = true; v->a[37][ts_external_token_variable_name] = true;
external_scanner_states_10(v); external_scanner_states_10(v);
} }

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

@ -18,57 +18,61 @@ void external_scanner_states_10(t_external_scanner_states_array *v)
v->a[37][ts_external_token_LT_LT_DASH] = true; 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_file_descriptor] = true;
v->a[38][ts_external_token__concat] = true; v->a[38][ts_external_token__concat] = true;
v->a[38][ts_external_token_variable_name] = true; v->a[38][ts_external_token__bare_dollar] = true;
v->a[38][ts_external_token_LT_LT] = true; v->a[38][ts_external_token_LT_LT] = true;
v->a[38][ts_external_token_LT_LT_DASH] = 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_variable_name] = true;
v->a[39][ts_external_token__concat] = true; v->a[39][ts_external_token__immediate_double_hash] = true;
v->a[39][ts_external_token_LT_LT] = true; v->a[40][ts_external_token_file_descriptor] = true;
v->a[39][ts_external_token_LT_LT_DASH] = true; v->a[40][ts_external_token__concat] = true;
v->a[40][ts_external_token_variable_name] = true; v->a[40][ts_external_token_LT_LT] = true;
v->a[40][ts_external_token_heredoc_redirect_token1] = true; v->a[40][ts_external_token_LT_LT_DASH] = true;
v->a[41][ts_external_token_file_descriptor] = true; v->a[41][ts_external_token_variable_name] = true;
v->a[41][ts_external_token__concat] = true;
v->a[41][ts_external_token_heredoc_redirect_token1] = 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_file_descriptor] = true;
v->a[42][ts_external_token_LPAREN] = true; v->a[42][ts_external_token__concat] = true;
v->a[42][ts_external_token_esac] = true; v->a[42][ts_external_token_heredoc_redirect_token1] = true;
v->a[43][ts_external_token_heredoc_redirect_token1] = true; v->a[43][ts_external_token_extglob_pattern] = true;
v->a[43][ts_external_token_LPAREN] = true;
external_scanner_states_11(v); external_scanner_states_11(v);
} }
void external_scanner_states_11(t_external_scanner_states_array *v) void external_scanner_states_11(t_external_scanner_states_array *v)
{ {
v->a[44][ts_external_token_file_descriptor] = true; v->a[43][ts_external_token_esac] = true;
v->a[44][ts_external_token__concat] = true; v->a[44][ts_external_token_regex] = true;
v->a[44][ts_external_token_variable_name] = true; v->a[44][ts_external_token__immediate_double_hash] = true;
v->a[45][ts_external_token_extglob_pattern] = true; v->a[45][ts_external_token_file_descriptor] = true;
v->a[45][ts_external_token_LPAREN] = true; v->a[45][ts_external_token__concat] = true;
v->a[46][ts_external_token__bare_dollar] = true; v->a[45][ts_external_token_variable_name] = true;
v->a[47][ts_external_token__empty_value] = true; v->a[46][ts_external_token_extglob_pattern] = true;
v->a[48][ts_external_token_extglob_pattern] = true; v->a[46][ts_external_token_LPAREN] = true;
v->a[49][ts_external_token__concat] = true; v->a[47][ts_external_token_heredoc_redirect_token1] = true;
v->a[49][ts_external_token_heredoc_redirect_token1] = true; v->a[48][ts_external_token__bare_dollar] = true;
v->a[50][ts_external_token__immediate_double_hash] = true; v->a[49][ts_external_token__empty_value] = true;
v->a[50][ts_external_token_extglob_pattern] = true;
v->a[51][ts_external_token_variable_name] = true; v->a[51][ts_external_token_variable_name] = true;
v->a[51][ts_external_token__expansion_word] = true; v->a[51][ts_external_token__expansion_word] = true;
v->a[52][ts_external_token_variable_name] = true; v->a[52][ts_external_token__concat] = true;
v->a[53][ts_external_token_heredoc_content] = true; v->a[52][ts_external_token_heredoc_redirect_token1] = true;
v->a[53][ts_external_token_heredoc_end] = true; v->a[53][ts_external_token__immediate_double_hash] = true;
v->a[54][ts_external_token_LT_LT] = true; v->a[54][ts_external_token_variable_name] = true;
v->a[54][ts_external_token_LT_LT_DASH] = true; v->a[55][ts_external_token_heredoc_content] = true;
v->a[55][ts_external_token__concat] = true; v->a[55][ts_external_token_heredoc_end] = true;
v->a[56][ts_external_token_regex] = true;
external_scanner_states_12(v); external_scanner_states_12(v);
} }
void external_scanner_states_12(t_external_scanner_states_array *v) void external_scanner_states_12(t_external_scanner_states_array *v)
{ {
v->a[57][ts_external_token_simple_heredoc_body] = true; v->a[56][ts_external_token_LT_LT] = true;
v->a[57][ts_external_token__heredoc_body_beginning] = true; v->a[56][ts_external_token_LT_LT_DASH] = true;
v->a[58][ts_external_token_esac] = true; v->a[57][ts_external_token__concat] = true;
v->a[59][ts_external_token_heredoc_end] = true; v->a[58][ts_external_token_regex] = true;
v->a[60][ts_external_token_heredoc_start] = true; v->a[59][ts_external_token_simple_heredoc_body] = true;
v->a[59][ts_external_token__heredoc_body_beginning] = true;
v->a[60][ts_external_token_esac] = true;
v->a[61][ts_external_token_heredoc_start] = true;
v->a[62][ts_external_token_heredoc_end] = true;
} }
/* EOF external_scanner_states_2.c */ /* EOF external_scanner_states_2.c */

1
parser/static/field_map_entries/field_map_entries.h
View file

@ -31,5 +31,6 @@ void field_map_entries_7(t_field_map_entries_array *v);
void field_map_entries_8(t_field_map_entries_array *v); void field_map_entries_8(t_field_map_entries_array *v);
void field_map_entries_9(t_field_map_entries_array *v); void field_map_entries_9(t_field_map_entries_array *v);
void field_map_entries_10(t_field_map_entries_array *v); void field_map_entries_10(t_field_map_entries_array *v);
void field_map_entries_11(t_field_map_entries_array *v);
#endif // FIELD_MAP_ENTRIES_H #endif // FIELD_MAP_ENTRIES_H

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

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

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

@ -14,126 +14,126 @@
void field_map_entries_5(t_field_map_entries_array *v) void field_map_entries_5(t_field_map_entries_array *v)
{ {
v->a[100] = fmap_entry(field_terminator, 1, true); v->a[100] = fmap_entry(field_cases, 1, true);
v->a[101] = fmap_entry(field_terminator, 3, true); v->a[101] = fmap_entry(field_op, 0, false);
v->a[102] = fmap_entry(field_body, 3, false); v->a[102] = fmap_entry(field_rhs, 1, false);
v->a[103] = fmap_entry(field_condition, 1, false); v->a[103] = fmap_entry(field_body, 5, false);
v->a[104] = fmap_entry(field_elif, 4, false); v->a[104] = fmap_entry(field_value, 3, false);
v->a[105] = fmap_entry(field_stmt, 1, true); v->a[105] = fmap_entry(field_var, 1, false);
v->a[106] = fmap_entry(field_stmt, 3, true); v->a[106] = fmap_entry(field_body, 3, false);
v->a[107] = fmap_entry(field_terminator, 1, true); v->a[107] = fmap_entry(field_cond, 1, false);
v->a[108] = fmap_entry(field_terminator, 3, true); v->a[108] = fmap_entry(field_else, 4, false);
v->a[109] = fmap_entry(field_condition, 1, false); v->a[109] = fmap_entry(field_stmt, 1, true);
v->a[110] = fmap_entry(field_elif, 3, false); v->a[110] = fmap_entry(field_stmt, 3, true);
v->a[111] = fmap_entry(field_else, 4, false); v->a[111] = fmap_entry(field_term, 1, true);
v->a[112] = fmap_entry(field_stmt, 1, true); v->a[112] = fmap_entry(field_term, 3, true);
v->a[113] = fmap_entry(field_terminator, 1, true); v->a[113] = fmap_entry(field_body, 3, false);
v->a[114] = fmap_entry(field_body, 2, false); v->a[114] = fmap_entry(field_cond, 1, false);
v->a[115] = fmap_entry(field_stmt, 2, true); v->a[115] = fmap_entry(field_elif, 4, false);
v->a[116] = fmap_entry(field_terminator, 2, true); v->a[116] = fmap_entry(field_stmt, 1, true);
v->a[117] = fmap_entry(field_value, 0, false); v->a[117] = fmap_entry(field_stmt, 3, true);
v->a[118] = fmap_entry(field_value, 0, true); v->a[118] = fmap_entry(field_term, 1, true);
v->a[119] = fmap_entry(field_value, 1, true); v->a[119] = fmap_entry(field_term, 3, true);
field_map_entries_6(v); field_map_entries_6(v);
} }
void field_map_entries_6(t_field_map_entries_array *v) void field_map_entries_6(t_field_map_entries_array *v)
{ {
v->a[120] = fmap_entry(field_body, 4, true); v->a[120] = fmap_entry(field_cond, 1, false);
v->a[121] = fmap_entry(field_cases, 4, false); v->a[121] = fmap_entry(field_elif, 3, false);
v->a[122] = fmap_entry(field_value, 1, false); v->a[122] = fmap_entry(field_else, 4, false);
v->a[123] = fmap_entry(field_value, 4, true); v->a[123] = fmap_entry(field_stmt, 1, true);
v->a[124] = fmap_entry(field_body, 4, true); v->a[124] = fmap_entry(field_term, 1, true);
v->a[125] = fmap_entry(field_cases, 3, true); v->a[125] = fmap_entry(field_body, 2, false);
v->a[126] = fmap_entry(field_cases, 4, false); v->a[126] = fmap_entry(field_stmt, 2, true);
v->a[127] = fmap_entry(field_value, 1, false); v->a[127] = fmap_entry(field_term, 2, true);
v->a[128] = fmap_entry(field_value, 4, true); v->a[128] = fmap_entry(field_value, 0, false);
v->a[129] = fmap_entry(field_alternative, 4, false); v->a[129] = fmap_entry(field_value, 0, true);
v->a[130] = fmap_entry(field_condition, 0, false); v->a[130] = fmap_entry(field_value, 1, true);
v->a[131] = fmap_entry(field_consequence, 2, false); v->a[131] = fmap_entry(field_body, 4, true);
v->a[132] = fmap_entry(field_fd, 0, false); v->a[132] = fmap_entry(field_cases, 4, false);
v->a[133] = fmap_entry(field_op, 1, false); v->a[133] = fmap_entry(field_value, 1, false);
v->a[134] = fmap_entry(field_op, 0, false); v->a[134] = fmap_entry(field_value, 4, true);
v->a[135] = fmap_entry(field_op, 2, true); v->a[135] = fmap_entry(field_body, 4, true);
v->a[136] = fmap_entry(field_right, 2, true); v->a[136] = fmap_entry(field_cases, 3, true);
v->a[137] = fmap_entry(field_arg, 2, true); v->a[137] = fmap_entry(field_cases, 4, false);
v->a[138] = fmap_entry(field_op, 0, false); v->a[138] = fmap_entry(field_value, 1, false);
v->a[139] = fmap_entry(field_op, 0, false); v->a[139] = fmap_entry(field_value, 4, true);
field_map_entries_7(v); field_map_entries_7(v);
} }
void field_map_entries_7(t_field_map_entries_array *v) void field_map_entries_7(t_field_map_entries_array *v)
{ {
v->a[140] = fmap_entry(field_redirect, 2, false); v->a[140] = fmap_entry(field_cond, 0, false);
v->a[141] = fmap_entry(field_body, 3, false); v->a[141] = fmap_entry(field_else, 4, false);
v->a[142] = fmap_entry(field_condition, 1, false); v->a[142] = fmap_entry(field_then, 2, false);
v->a[143] = fmap_entry(field_elif, 4, false); v->a[143] = fmap_entry(field_fd, 0, false);
v->a[144] = fmap_entry(field_else, 5, false); v->a[144] = fmap_entry(field_op, 1, false);
v->a[145] = fmap_entry(field_stmt, 1, true); v->a[145] = fmap_entry(field_op, 0, false);
v->a[146] = fmap_entry(field_stmt, 3, true); v->a[146] = fmap_entry(field_op, 2, true);
v->a[147] = fmap_entry(field_terminator, 1, true); v->a[147] = fmap_entry(field_rhs, 2, true);
v->a[148] = fmap_entry(field_terminator, 3, true); v->a[148] = fmap_entry(field_arg, 2, true);
v->a[149] = fmap_entry(field_body, 3, false); v->a[149] = fmap_entry(field_op, 0, false);
v->a[150] = fmap_entry(field_stmt, 3, true); v->a[150] = fmap_entry(field_op, 0, false);
v->a[151] = fmap_entry(field_terminator, 3, true); v->a[151] = fmap_entry(field_redr, 2, false);
v->a[152] = fmap_entry(field_value, 1, false); v->a[152] = fmap_entry(field_body, 3, false);
v->a[153] = fmap_entry(field_body, 3, false); v->a[153] = fmap_entry(field_cond, 1, false);
v->a[154] = fmap_entry(field_stmt, 3, true); v->a[154] = fmap_entry(field_elif, 4, false);
v->a[155] = fmap_entry(field_terminator, 3, true); v->a[155] = fmap_entry(field_else, 5, false);
v->a[156] = fmap_entry(field_value, 0, false); v->a[156] = fmap_entry(field_stmt, 1, true);
v->a[157] = fmap_entry(field_body, 3, false); v->a[157] = fmap_entry(field_stmt, 3, true);
v->a[158] = fmap_entry(field_stmt, 3, true); v->a[158] = fmap_entry(field_term, 1, true);
v->a[159] = fmap_entry(field_terminator, 3, true); v->a[159] = fmap_entry(field_term, 3, true);
field_map_entries_8(v); field_map_entries_8(v);
} }
void field_map_entries_8(t_field_map_entries_array *v) void field_map_entries_8(t_field_map_entries_array *v)
{ {
v->a[160] = fmap_entry(field_value, 0, false); v->a[160] = fmap_entry(field_body, 3, false);
v->a[161] = fmap_entry(field_value, 1, true); v->a[161] = fmap_entry(field_stmt, 3, true);
v->a[162] = fmap_entry(field_body, 5, true); v->a[162] = fmap_entry(field_term, 3, true);
v->a[163] = fmap_entry(field_cases, 4, true); v->a[163] = fmap_entry(field_value, 1, false);
v->a[164] = fmap_entry(field_cases, 5, false); v->a[164] = fmap_entry(field_body, 3, false);
v->a[165] = fmap_entry(field_value, 1, false); v->a[165] = fmap_entry(field_stmt, 3, true);
v->a[166] = fmap_entry(field_value, 5, true); v->a[166] = fmap_entry(field_term, 3, true);
v->a[167] = fmap_entry(field_body, 5, true); v->a[167] = fmap_entry(field_value, 0, false);
v->a[168] = fmap_entry(field_cases, 5, false); v->a[168] = fmap_entry(field_body, 3, false);
v->a[169] = fmap_entry(field_value, 1, false); v->a[169] = fmap_entry(field_stmt, 3, true);
v->a[170] = fmap_entry(field_value, 5, true); v->a[170] = fmap_entry(field_term, 3, true);
v->a[171] = fmap_entry(field_fd, 0, false); v->a[171] = fmap_entry(field_value, 0, false);
v->a[172] = fmap_entry(field_op, 1, false); v->a[172] = fmap_entry(field_value, 1, true);
v->a[173] = fmap_entry(field_op, 3, true); v->a[173] = fmap_entry(field_body, 5, true);
v->a[174] = fmap_entry(field_right, 3, true); v->a[174] = fmap_entry(field_cases, 4, true);
v->a[175] = fmap_entry(field_arg, 3, true); v->a[175] = fmap_entry(field_cases, 5, false);
v->a[176] = fmap_entry(field_fd, 0, false); v->a[176] = fmap_entry(field_value, 1, false);
v->a[177] = fmap_entry(field_op, 1, false); v->a[177] = fmap_entry(field_value, 5, true);
v->a[178] = fmap_entry(field_fd, 0, false); v->a[178] = fmap_entry(field_body, 5, true);
v->a[179] = fmap_entry(field_op, 1, false); v->a[179] = fmap_entry(field_cases, 5, false);
field_map_entries_9(v); field_map_entries_9(v);
} }
void field_map_entries_9(t_field_map_entries_array *v) void field_map_entries_9(t_field_map_entries_array *v)
{ {
v->a[180] = fmap_entry(field_redirect, 3, false); v->a[180] = fmap_entry(field_value, 1, false);
v->a[181] = fmap_entry(field_op, 0, false); v->a[181] = fmap_entry(field_value, 5, true);
v->a[182] = fmap_entry(field_op, 3, true); v->a[182] = fmap_entry(field_fd, 0, false);
v->a[183] = fmap_entry(field_redirect, 2, false); v->a[183] = fmap_entry(field_op, 1, false);
v->a[184] = fmap_entry(field_right, 3, true); v->a[184] = fmap_entry(field_op, 3, true);
v->a[185] = fmap_entry(field_body, 4, false); v->a[185] = fmap_entry(field_rhs, 3, true);
v->a[186] = fmap_entry(field_stmt, 4, true); v->a[186] = fmap_entry(field_arg, 3, true);
v->a[187] = fmap_entry(field_terminator, 4, true); v->a[187] = fmap_entry(field_fd, 0, false);
v->a[188] = fmap_entry(field_value, 1, false); v->a[188] = fmap_entry(field_op, 1, false);
v->a[189] = fmap_entry(field_body, 4, false); v->a[189] = fmap_entry(field_fd, 0, false);
v->a[190] = fmap_entry(field_stmt, 4, true); v->a[190] = fmap_entry(field_op, 1, false);
v->a[191] = fmap_entry(field_terminator, 4, true); v->a[191] = fmap_entry(field_redr, 3, false);
v->a[192] = fmap_entry(field_value, 1, false); v->a[192] = fmap_entry(field_op, 0, false);
v->a[193] = fmap_entry(field_value, 2, true); v->a[193] = fmap_entry(field_op, 3, true);
v->a[194] = fmap_entry(field_body, 4, false); v->a[194] = fmap_entry(field_redr, 2, false);
v->a[195] = fmap_entry(field_stmt, 4, true); v->a[195] = fmap_entry(field_rhs, 3, true);
v->a[196] = fmap_entry(field_terminator, 4, true); v->a[196] = fmap_entry(field_body, 4, false);
v->a[197] = fmap_entry(field_value, 0, false); v->a[197] = fmap_entry(field_stmt, 4, true);
v->a[198] = fmap_entry(field_value, 1, true); v->a[198] = fmap_entry(field_term, 4, true);
v->a[199] = fmap_entry(field_body, 6, true); v->a[199] = fmap_entry(field_value, 1, false);
field_map_entries_10(v); field_map_entries_10(v);
} }

44
parser/static/field_map_entries/field_map_entries_2.c
View file

@ -14,20 +14,36 @@
void field_map_entries_10(t_field_map_entries_array *v) void field_map_entries_10(t_field_map_entries_array *v)
{ {
v->a[200] = fmap_entry(field_cases, 5, true); v->a[200] = fmap_entry(field_body, 4, false);
v->a[201] = fmap_entry(field_cases, 6, false); v->a[201] = fmap_entry(field_stmt, 4, true);
v->a[202] = fmap_entry(field_value, 1, false); v->a[202] = fmap_entry(field_term, 4, true);
v->a[203] = fmap_entry(field_value, 6, true); v->a[203] = fmap_entry(field_value, 1, false);
v->a[204] = fmap_entry(field_fd, 0, false); v->a[204] = fmap_entry(field_value, 2, true);
v->a[205] = fmap_entry(field_op, 1, false); v->a[205] = fmap_entry(field_body, 4, false);
v->a[206] = fmap_entry(field_op, 4, true); v->a[206] = fmap_entry(field_stmt, 4, true);
v->a[207] = fmap_entry(field_redirect, 3, false); v->a[207] = fmap_entry(field_term, 4, true);
v->a[208] = fmap_entry(field_right, 4, true); v->a[208] = fmap_entry(field_value, 0, false);
v->a[209] = fmap_entry(field_body, 5, false); v->a[209] = fmap_entry(field_value, 1, true);
v->a[210] = fmap_entry(field_stmt, 5, true); v->a[210] = fmap_entry(field_body, 6, true);
v->a[211] = fmap_entry(field_terminator, 5, true); v->a[211] = fmap_entry(field_cases, 5, true);
v->a[212] = fmap_entry(field_value, 1, false); v->a[212] = fmap_entry(field_cases, 6, false);
v->a[213] = fmap_entry(field_value, 2, true); v->a[213] = fmap_entry(field_value, 1, false);
v->a[214] = fmap_entry(field_value, 6, true);
v->a[215] = fmap_entry(field_fd, 0, false);
v->a[216] = fmap_entry(field_op, 1, false);
v->a[217] = fmap_entry(field_op, 4, true);
v->a[218] = fmap_entry(field_redr, 3, false);
v->a[219] = fmap_entry(field_rhs, 4, true);
field_map_entries_11(v);
}
void field_map_entries_11(t_field_map_entries_array *v)
{
v->a[220] = fmap_entry(field_body, 5, false);
v->a[221] = fmap_entry(field_stmt, 5, true);
v->a[222] = fmap_entry(field_term, 5, true);
v->a[223] = fmap_entry(field_value, 1, false);
v->a[224] = fmap_entry(field_value, 2, true);
} }
/* EOF field_map_entries_2.c */ /* EOF field_map_entries_2.c */

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

@ -41,66 +41,71 @@ void field_map_slices_1(t_field_map_slices_array *v)
{ {
v->a[22] = fmap_slice(37, 1); v->a[22] = fmap_slice(37, 1);
v->a[24] = fmap_slice(36, 1); v->a[24] = fmap_slice(36, 1);
v->a[25] = fmap_slice(38, 2); v->a[25] = fmap_slice(38, 3);
v->a[26] = fmap_slice(38, 2); v->a[26] = fmap_slice(38, 3);
v->a[27] = fmap_slice(40, 2); v->a[27] = fmap_slice(41, 2);
v->a[28] = fmap_slice(42, 1); v->a[28] = fmap_slice(41, 2);
v->a[29] = fmap_slice(43, 3); v->a[29] = fmap_slice(43, 4);
v->a[30] = fmap_slice(46, 2); v->a[30] = fmap_slice(47, 1);
v->a[31] = fmap_slice(48, 4); v->a[31] = fmap_slice(48, 3);
v->a[32] = fmap_slice(52, 3); v->a[32] = fmap_slice(51, 2);
v->a[33] = fmap_slice(55, 2); v->a[33] = fmap_slice(53, 4);
v->a[34] = fmap_slice(57, 3); v->a[34] = fmap_slice(57, 3);
v->a[35] = fmap_slice(60, 1); v->a[35] = fmap_slice(60, 2);
v->a[36] = fmap_slice(61, 1); v->a[36] = fmap_slice(62, 3);
v->a[37] = fmap_slice(62, 3); v->a[37] = fmap_slice(65, 1);
v->a[41] = fmap_slice(65, 2); v->a[38] = fmap_slice(66, 1);
v->a[42] = fmap_slice(67, 3); v->a[39] = fmap_slice(67, 3);
v->a[43] = fmap_slice(70, 6); v->a[43] = fmap_slice(70, 2);
v->a[44] = fmap_slice(76, 4); v->a[44] = fmap_slice(72, 4);
v->a[45] = fmap_slice(80, 4); v->a[45] = fmap_slice(72, 4);
field_map_slices_2(v); field_map_slices_2(v);
} }
void field_map_slices_2(t_field_map_slices_array *v) void field_map_slices_2(t_field_map_slices_array *v)
{ {
v->a[46] = fmap_slice(84, 4); v->a[46] = fmap_slice(76, 2);
v->a[47] = fmap_slice(88, 2); v->a[47] = fmap_slice(78, 3);
v->a[48] = fmap_slice(90, 2); v->a[48] = fmap_slice(81, 6);
v->a[49] = fmap_slice(92, 3); v->a[49] = fmap_slice(87, 4);
v->a[50] = fmap_slice(95, 7); v->a[50] = fmap_slice(91, 4);
v->a[51] = fmap_slice(102, 7); v->a[51] = fmap_slice(95, 4);
v->a[52] = fmap_slice(109, 5); v->a[52] = fmap_slice(99, 2);
v->a[53] = fmap_slice(114, 4); v->a[54] = fmap_slice(101, 2);
v->a[54] = fmap_slice(118, 2); v->a[55] = fmap_slice(103, 3);
v->a[55] = fmap_slice(120, 4); v->a[56] = fmap_slice(106, 7);
v->a[56] = fmap_slice(124, 5); v->a[57] = fmap_slice(113, 7);
v->a[57] = fmap_slice(129, 3); v->a[58] = fmap_slice(120, 5);
v->a[58] = fmap_slice(132, 2); v->a[59] = fmap_slice(125, 4);
v->a[59] = fmap_slice(134, 3); v->a[60] = fmap_slice(129, 2);
v->a[60] = fmap_slice(137, 2); v->a[61] = fmap_slice(131, 4);
v->a[61] = fmap_slice(139, 2); v->a[62] = fmap_slice(135, 5);
v->a[62] = fmap_slice(141, 8); v->a[63] = fmap_slice(140, 3);
v->a[63] = fmap_slice(149, 4); v->a[65] = fmap_slice(143, 2);
v->a[64] = fmap_slice(153, 4); v->a[66] = fmap_slice(145, 3);
v->a[65] = fmap_slice(157, 5); v->a[67] = fmap_slice(148, 2);
field_map_slices_3(v); field_map_slices_3(v);
} }
void field_map_slices_3(t_field_map_slices_array *v) void field_map_slices_3(t_field_map_slices_array *v)
{ {
v->a[66] = fmap_slice(162, 5); v->a[68] = fmap_slice(150, 2);
v->a[67] = fmap_slice(167, 4); v->a[69] = fmap_slice(152, 8);
v->a[68] = fmap_slice(171, 4); v->a[70] = fmap_slice(160, 4);
v->a[69] = fmap_slice(175, 3); v->a[71] = fmap_slice(164, 4);
v->a[70] = fmap_slice(178, 3); v->a[72] = fmap_slice(168, 5);
v->a[71] = fmap_slice(181, 4); v->a[73] = fmap_slice(173, 5);
v->a[72] = fmap_slice(185, 4); v->a[74] = fmap_slice(178, 4);
v->a[73] = fmap_slice(189, 5); v->a[75] = fmap_slice(182, 4);
v->a[74] = fmap_slice(194, 5); v->a[76] = fmap_slice(186, 3);
v->a[75] = fmap_slice(199, 5); v->a[77] = fmap_slice(189, 3);
v->a[76] = fmap_slice(204, 5); v->a[78] = fmap_slice(192, 4);
v->a[77] = fmap_slice(209, 5); v->a[79] = fmap_slice(196, 4);
v->a[80] = fmap_slice(200, 5);
v->a[81] = fmap_slice(205, 5);
v->a[82] = fmap_slice(210, 5);
v->a[83] = fmap_slice(215, 5);
v->a[84] = fmap_slice(220, 5);
} }
/* EOF field_map_slices_0.c */ /* EOF field_map_slices_0.c */

1
parser/static/field_names/field_names.h
View file

@ -21,5 +21,6 @@
# include "../headers/constants.h" # include "../headers/constants.h"
void field_names_0(t_field_names_array *v); void field_names_0(t_field_names_array *v);
void field_names_1(t_field_names_array *v);
#endif // FIELD_NAMES_H #endif // FIELD_NAMES_H

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

@ -14,26 +14,32 @@
void field_names_0(t_field_names_array *v) void field_names_0(t_field_names_array *v)
{ {
v->a[field_alternative] = "alt";
v->a[field_arg] = "arg"; v->a[field_arg] = "arg";
v->a[field_args] = "args";
v->a[field_body] = "body"; v->a[field_body] = "body";
v->a[field_cases] = "case"; v->a[field_cases] = "cases";
v->a[field_cmd] = "cmd"; v->a[field_cmd] = "cmd";
v->a[field_condition] = "cond"; v->a[field_cond] = "cond";
v->a[field_consequence] = "cnsq";
v->a[field_dest] = "dest"; v->a[field_dest] = "dest";
v->a[field_elif] = "elif"; v->a[field_elif] = "elif";
v->a[field_else] = "else"; v->a[field_else] = "else";
v->a[field_fd] = "fd"; v->a[field_fd] = "fd";
v->a[field_left] = "left"; v->a[field_len] = "len";
v->a[field_lhs] = "lhs";
v->a[field_name] = "name"; v->a[field_name] = "name";
v->a[field_op] = "op"; v->a[field_op] = "op";
v->a[field_redirect] = "redir"; v->a[field_redr] = "redr";
v->a[field_right] = "right"; v->a[field_rhs] = "rhs";
v->a[field_stmt] = "stmt"; v->a[field_stmt] = "stmt";
v->a[field_terminator] = "term"; v->a[field_term] = "term";
v->a[field_then] = "then";
v->a[field_value] = "value"; v->a[field_value] = "value";
v->a[field_variable] = "var"; field_names_1(v);
}
void field_names_1(t_field_names_array *v)
{
v->a[field_var] = "var";
} }
/* EOF field_names_0.c */ /* EOF field_names_0.c */

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

@ -14,14 +14,14 @@
# define CONSTANTS_H # define CONSTANTS_H
# define LANGUAGE_VERSION 14 # define LANGUAGE_VERSION 14
# define STATE_COUNT 2118 # define STATE_COUNT 2137
# define LARGE_STATE_COUNT 2 # define LARGE_STATE_COUNT 2
# define SYMBOL_COUNT 179 # define SYMBOL_COUNT 181
# define ALIAS_COUNT 1 # define ALIAS_COUNT 1
# define TOKEN_COUNT 111 # define TOKEN_COUNT 112
# define EXTERNAL_TOKEN_COUNT 20 # define EXTERNAL_TOKEN_COUNT 20
# define FIELD_COUNT 20 # define FIELD_COUNT 21
# define MAX_ALIAS_SEQUENCE_LENGTH 8 # define MAX_ALIAS_SEQUENCE_LENGTH 8
# define PRODUCTION_ID_COUNT 78 # define PRODUCTION_ID_COUNT 85
#endif // CONSTANTS_H #endif // CONSTANTS_H

29
parser/static/headers/field_identifiers.h
View file

@ -14,26 +14,27 @@
# define FIELD_IDENTIFIERS_H # define FIELD_IDENTIFIERS_H
enum e_field_identifiers { enum e_field_identifiers {
field_alternative = 1, field_arg = 1,
field_arg = 2, field_args = 2,
field_body = 3, field_body = 3,
field_cases = 4, field_cases = 4,
field_cmd = 5, field_cmd = 5,
field_condition = 6, field_cond = 6,
field_consequence = 7, field_dest = 7,
field_dest = 8, field_elif = 8,
field_elif = 9, field_else = 9,
field_else = 10, field_fd = 10,
field_fd = 11, field_len = 11,
field_left = 12, field_lhs = 12,
field_name = 13, field_name = 13,
field_op = 14, field_op = 14,
field_redirect = 15, field_redr = 15,
field_right = 16, field_rhs = 16,
field_stmt = 17, field_stmt = 17,
field_terminator = 18, field_term = 18,
field_value = 19, field_then = 19,
field_variable = 20, field_value = 20,
field_var = 21,
}; };
#endif // FIELD_IDENTIFIERS_H #endif // FIELD_IDENTIFIERS_H

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

@ -98,7 +98,7 @@ enum e_symbols {
anon_sym_COLON_PLUS = 82, anon_sym_COLON_PLUS = 82,
anon_sym_PLUS3 = 83, anon_sym_PLUS3 = 83,
anon_sym_PERCENT_PERCENT = 84, anon_sym_PERCENT_PERCENT = 84,
aux_sym_expansion_regex_token1 = 85, aux_sym__expansion_regex_token1 = 85,
anon_sym_DOLLAR_LPAREN = 86, anon_sym_DOLLAR_LPAREN = 86,
anon_sym_BQUOTE = 87, anon_sym_BQUOTE = 87,
sym_comment = 88, sym_comment = 88,
@ -108,91 +108,93 @@ enum e_symbols {
anon_sym_AT = 92, anon_sym_AT = 92,
anon_sym_0 = 93, anon_sym_0 = 93,
anon_sym__ = 94, anon_sym__ = 94,
anon_sym_SEMI = 95, aux_sym__word_no_brace_token1 = 95,
sym_heredoc_start = 96, anon_sym_SEMI = 96,
sym_simple_heredoc_body = 97, sym_heredoc_start = 97,
sym__heredoc_body_beginning = 98, sym_simple_heredoc_body = 98,
sym_heredoc_content = 99, sym__heredoc_body_beginning = 99,
sym_heredoc_end = 100, sym_heredoc_content = 100,
sym_file_descriptor = 101, sym_heredoc_end = 101,
sym__empty_value = 102, sym_file_descriptor = 102,
sym__concat = 103, sym__empty_value = 103,
sym_variable_name = 104, sym__concat = 104,
sym_regex = 105, sym_variable_name = 105,
sym__expansion_word = 106, sym_regex = 106,
sym_extglob_pattern = 107, sym__expansion_word = 107,
sym__bare_dollar = 108, sym_extglob_pattern = 108,
sym__immediate_double_hash = 109, sym__bare_dollar = 109,
sym___error_recovery = 110, sym__immediate_double_hash = 110,
sym_program = 111, sym___error_recovery = 111,
sym__statements = 112, sym_program = 112,
aux_sym__terminated_statement = 113, sym__statements = 113,
sym__statement_not_pipeline = 114, aux_sym__terminated_statement = 114,
sym_redirected_statement = 115, sym__statement_not_pipeline = 115,
sym_for_statement = 116, sym_redirected_statement = 116,
sym_while_statement = 117, sym_for_statement = 117,
sym_do_group = 118, sym_while_statement = 118,
sym_if_statement = 119, sym_do_group = 119,
sym_elif_clause = 120, sym_if_statement = 120,
sym_else_clause = 121, sym_elif_clause = 121,
sym_case_statement = 122, sym_else_clause = 122,
sym__case_item_last = 123, sym_case_statement = 123,
sym_case_item = 124, sym__case_item_last = 124,
sym_function_definition = 125, sym_case_item = 125,
sym_compound_statement = 126, sym_function_definition = 126,
sym_subshell = 127, sym_compound_statement = 127,
sym_pipeline = 128, sym_subshell = 128,
sym_list = 129, sym_pipeline = 129,
sym_negated_command = 130, sym_list = 130,
sym_command = 131, sym_negated_command = 131,
sym_command_name = 132, sym_command = 132,
sym_variable_assignment = 133, sym_command_name = 133,
sym__variable_assignments = 134, sym_variable_assignment = 134,
sym_file_redirect = 135, sym__variable_assignments = 135,
sym_heredoc_redirect = 136, sym_file_redirect = 136,
sym__heredoc_pipeline = 137, sym_heredoc_redirect = 137,
sym__heredoc_expression = 138, sym__heredoc_pipeline = 138,
aux_sym__heredoc_command = 139, sym__heredoc_expression = 139,
sym__heredoc_body = 140, aux_sym__heredoc_command = 140,
sym_heredoc_body = 141, sym__heredoc_body = 141,
sym__simple_heredoc_body = 142, sym_heredoc_body = 142,
sym_arithmetic_expansion = 143, sym__simple_heredoc_body = 143,
sym__arithmetic_expression = 144, sym_arithmetic_expansion = 144,
sym_arithmetic_literal = 145, sym__arithmetic_expression = 145,
sym_arithmetic_binary_expression = 146, sym_arithmetic_literal = 146,
sym_arithmetic_ternary_expression = 147, sym_arithmetic_binary_expression = 147,
sym_arithmetic_unary_expression = 148, sym_arithmetic_ternary_expression = 148,
sym_arithmetic_postfix_expression = 149, sym_arithmetic_unary_expression = 149,
sym_arithmetic_parenthesized_expression = 150, sym_arithmetic_postfix_expression = 150,
sym_concatenation = 151, sym_arithmetic_parenthesized_expression = 151,
sym_string = 152, sym_concatenation = 152,
sym_simple_expansion = 153, sym_string = 153,
sym_expansion = 154, sym_simple_expansion = 154,
sym__expansion_body = 155, sym_expansion = 155,
sym_expansion_expression = 156, sym__expansion_body = 156,
sym_expansion_regex = 157, sym__expansion_expression = 157,
sym__concatenation_in_expansion = 158, sym__expansion_regex = 158,
sym_command_substitution = 159, sym__concatenation_in_expansion = 159,
sym__extglob_blob = 160, sym_command_substitution = 160,
sym_terminator = 161, sym__extglob_blob = 161,
aux_sym__statements_repeat1 = 162, sym__word_no_brace = 162,
aux_sym_redirected_statement_repeat1 = 163, sym_terminator = 163,
aux_sym_redirected_statement_repeat2 = 164, aux_sym__statements_repeat1 = 164,
aux_sym_for_statement_repeat1 = 165, aux_sym_redirected_statement_repeat1 = 165,
aux_sym_if_statement_repeat1 = 166, aux_sym_redirected_statement_repeat2 = 166,
aux_sym_case_statement_repeat1 = 167, aux_sym_for_statement_repeat1 = 167,
aux_sym__case_item_last_repeat1 = 168, aux_sym_if_statement_repeat1 = 168,
aux_sym__case_item_last_repeat2 = 169, aux_sym_case_statement_repeat1 = 169,
aux_sym_pipeline_repeat1 = 170, aux_sym__case_item_last_repeat1 = 170,
aux_sym_command_repeat1 = 171, aux_sym__case_item_last_repeat2 = 171,
aux_sym_command_repeat2 = 172, aux_sym_pipeline_repeat1 = 172,
aux_sym__variable_assignments_repeat1 = 173, aux_sym_command_repeat1 = 173,
aux_sym_heredoc_body_repeat1 = 174, aux_sym_command_repeat2 = 174,
aux_sym_concatenation_repeat1 = 175, aux_sym__variable_assignments_repeat1 = 175,
aux_sym_string_repeat1 = 176, aux_sym_heredoc_body_repeat1 = 176,
aux_sym_expansion_regex_repeat1 = 177, aux_sym_concatenation_repeat1 = 177,
aux_sym__concatenation_in_expansion_repeat1 = 178, aux_sym_string_repeat1 = 178,
alias_sym_statements = 179, aux_sym__expansion_regex_repeat1 = 179,
aux_sym__concatenation_in_expansion_repeat1 = 180,
alias_sym_statements = 181,
}; };
#endif // SYMBOLS_H #endif // SYMBOLS_H

27
parser/static/lex_funcs/lex_keywords/create_table/lex_keywords_array.h
View file

@ -1,27 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lex_keywords_array.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* 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 */
/* */
/* ************************************************************************** */
#ifndef LEX_KEYWORDS_ARRAY_H
# define LEX_KEYWORDS_ARRAY_H
# include "../../../types/type_lex_keywords.h"
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../char_set/charset_inline.h"
# include "../lex_keywords_funcs.h"
void lex_keywords_array_0(t_lex_keywords_array *v);
void lex_keywords_array_1(t_lex_keywords_array *v);
#endif // LEX_KEYWORDS_ARRAY_H

58
parser/static/lex_funcs/lex_keywords/create_table/lex_keywords_array_0.c
View file

@ -1,58 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lex_keywords_array_0.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 "../../../headers/symbols.h"
#include "../../../headers/external_scanner_symbol_identifiers.h"
#include "../../../headers/field_identifiers.h"
#include "../../../headers/constants.h"
#include "../lex_keywords_funcs.h"
#include "./lex_keywords_array.h"
void lex_keywords_array_0(t_lex_keywords_array *v)
{
v->a[0] = lex_keywords_s0;
v->a[1] = lex_keywords_s1;
v->a[2] = lex_keywords_s2;
v->a[3] = lex_keywords_s3;
v->a[4] = lex_keywords_s4;
v->a[5] = lex_keywords_s5;
v->a[6] = lex_keywords_s6;
v->a[7] = lex_keywords_s7;
v->a[8] = lex_keywords_s8;
v->a[9] = lex_keywords_s9;
v->a[10] = lex_keywords_s10;
v->a[11] = lex_keywords_s11;
v->a[12] = lex_keywords_s12;
v->a[13] = lex_keywords_s13;
v->a[14] = lex_keywords_s14;
v->a[15] = lex_keywords_s15;
v->a[16] = lex_keywords_s16;
v->a[17] = lex_keywords_s17;
v->a[18] = lex_keywords_s18;
v->a[19] = lex_keywords_s19;
lex_keywords_array_1(v);
}
void lex_keywords_array_1(t_lex_keywords_array *v)
{
v->a[20] = lex_keywords_s20;
v->a[21] = lex_keywords_s21;
v->a[22] = lex_keywords_s22;
v->a[23] = lex_keywords_s23;
v->a[24] = lex_keywords_s24;
v->a[25] = lex_keywords_s25;
v->a[26] = lex_keywords_s26;
v->a[27] = lex_keywords_s27;
v->a[28] = lex_keywords_s28;
v->a[29] = lex_keywords_s29;
}
/* EOF lex_keywords_array_0.c */

22
parser/static/lex_funcs/lex_keywords/inline.h
View file

@ -1,22 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* 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 */
/* */
/* ************************************************************************** */
#ifndef INLINE_H
# define INLINE_H
# include "../../headers/symbols.h"
# include "../../headers/external_scanner_symbol_identifiers.h"
# include "../../headers/field_identifiers.h"
# include "../../headers/constants.h"
# include "../../../parse_types.h"
#endif // INLINE_H

57
parser/static/lex_funcs/lex_keywords/lex_keywords_funcs.h
View file

@ -1,57 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lex_keywords_funcs.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* 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 */
/* */
/* ************************************************************************** */
#ifndef LEX_KEYWORDS_FUNCS_H
# define LEX_KEYWORDS_FUNCS_H
# include "../../types/type_lex_keywords.h"
# include "../../headers/symbols.h"
# include "../../headers/external_scanner_symbol_identifiers.h"
# include "../../headers/field_identifiers.h"
# include "../../headers/constants.h"
# include "../../char_set/charset_inline.h"
# include "./inline.h"
# include "../../../parse_types.h"
bool lex_keywords_s0(t_lexer *lexer, t_lexer_state *s);
bool lex_keywords_s1(t_lexer *lexer, t_lexer_state *s);
bool lex_keywords_s2(t_lexer *lexer, t_lexer_state *s);
bool lex_keywords_s3(t_lexer *lexer, t_lexer_state *s);
bool lex_keywords_s4(t_lexer *lexer, t_lexer_state *s);
bool lex_keywords_s5(t_lexer *lexer, t_lexer_state *s);
bool lex_keywords_s6(t_lexer *lexer, t_lexer_state *s);
bool lex_keywords_s7(t_lexer *lexer, t_lexer_state *s);
bool lex_keywords_s8(t_lexer *lexer, t_lexer_state *s);
bool lex_keywords_s9(t_lexer *lexer, t_lexer_state *s);
bool lex_keywords_s10(t_lexer *lexer, t_lexer_state *s);
bool lex_keywords_s11(t_lexer *lexer, t_lexer_state *s);
bool lex_keywords_s12(t_lexer *lexer, t_lexer_state *s);
bool lex_keywords_s13(t_lexer *lexer, t_lexer_state *s);
bool lex_keywords_s14(t_lexer *lexer, t_lexer_state *s);
bool lex_keywords_s15(t_lexer *lexer, t_lexer_state *s);
bool lex_keywords_s16(t_lexer *lexer, t_lexer_state *s);
bool lex_keywords_s17(t_lexer *lexer, t_lexer_state *s);
bool lex_keywords_s18(t_lexer *lexer, t_lexer_state *s);
bool lex_keywords_s19(t_lexer *lexer, t_lexer_state *s);
bool lex_keywords_s20(t_lexer *lexer, t_lexer_state *s);
bool lex_keywords_s21(t_lexer *lexer, t_lexer_state *s);
bool lex_keywords_s22(t_lexer *lexer, t_lexer_state *s);
bool lex_keywords_s23(t_lexer *lexer, t_lexer_state *s);
bool lex_keywords_s24(t_lexer *lexer, t_lexer_state *s);
bool lex_keywords_s25(t_lexer *lexer, t_lexer_state *s);
bool lex_keywords_s26(t_lexer *lexer, t_lexer_state *s);
bool lex_keywords_s27(t_lexer *lexer, t_lexer_state *s);
bool lex_keywords_s28(t_lexer *lexer, t_lexer_state *s);
bool lex_keywords_s29(t_lexer *lexer, t_lexer_state *s);
bool lex_keywords_default(t_lexer *lexer, t_lexer_state *s);
#endif // LEX_KEYWORDS_FUNCS_H

49
parser/static/lex_funcs/lex_keywords/main_func.c
View file

@ -1,49 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* main_func.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_keywords_funcs.h"
t_lex_keywords_array *create_lex_keywords(void);
bool lex_keywords_call(t_lexer *lexer, t_lexer_state *s)
{
t_lex_keywords_array *t;
t = create_lex_keywords();
if (s->state < 30)
{
return (((bool (*)(t_lexer *, t_lexer_state \
*))(t->a[s->state]))(lexer, s));
}
return (lex_keywords_default(lexer, s));
}
bool lex_keywords_main(t_lexer *lexer, t_state_id state)
{
t_lexer_state s;
s = (t_lexer_state){.result = false, .skip = false, .eof = \
false};
s.state = state;
s.skip = false;
s.lookahead = lexer->lookahead;
s.eof = lexer->eof(lexer);
while (lex_keywords_call(lexer, &s))
{
lexer->advance(lexer, s.skip);
s.skip = false;
s.lookahead = lexer->lookahead;
s.eof = lexer->eof(lexer);
}
return (s.result);
}
/* main_func.c */

68
parser/static/lex_funcs/lex_keywords/state_0.c
View file

@ -1,68 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_0.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_keywords_funcs.h"
bool lex_keywords_s0(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\\')
return (lex_skip(1, lexer, s));
if (s->lookahead == 'c')
return (lex_advance(2, lexer, s));
if (s->lookahead == 'd')
return (lex_advance(3, lexer, s));
if (s->lookahead == 'f')
return (lex_advance(4, lexer, s));
if (s->lookahead == 'i')
return (lex_advance(5, lexer, s));
if (s->lookahead == 't')
return (lex_advance(6, lexer, s));
if (s->lookahead == 'u')
return (lex_advance(7, lexer, s));
if (s->lookahead == 'w')
return (lex_advance(8, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(0, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_keywords_s1(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(0, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_keywords_s2(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'a')
return (lex_advance(10, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_keywords_s3(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'o')
return (lex_advance(11, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_keywords_s4(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'o')
return (lex_advance(12, lexer, s));
return (lex_end_state(lexer, s));
}

48
parser/static/lex_funcs/lex_keywords/state_1.c
View file

@ -1,48 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_1.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_keywords_funcs.h"
bool lex_keywords_s5(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'f')
return (lex_advance(13, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_keywords_s6(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'h')
return (lex_advance(14, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_keywords_s7(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'n')
return (lex_advance(15, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_keywords_s8(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'h')
return (lex_advance(16, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_keywords_s9(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(0, lexer, s));
return (lex_end_state(lexer, s));
}

47
parser/static/lex_funcs/lex_keywords/state_2.c
View file

@ -1,47 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_2.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_keywords_funcs.h"
bool lex_keywords_s10(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 's')
return (lex_advance(17, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_keywords_s11(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'n')
return (lex_advance(18, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_keywords_s12(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'r')
return (lex_advance(19, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_keywords_s13(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_if, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_keywords_s14(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'e')
return (lex_advance(20, lexer, s));
return (lex_end_state(lexer, s));
}

47
parser/static/lex_funcs/lex_keywords/state_3.c
View file

@ -1,47 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_3.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_keywords_funcs.h"
bool lex_keywords_s15(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 't')
return (lex_advance(21, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_keywords_s16(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'i')
return (lex_advance(22, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_keywords_s17(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'e')
return (lex_advance(23, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_keywords_s18(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'e')
return (lex_advance(24, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_keywords_s19(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_for, lexer, s);
return (lex_end_state(lexer, s));
}

46
parser/static/lex_funcs/lex_keywords/state_4.c
View file

@ -1,46 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_4.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_keywords_funcs.h"
bool lex_keywords_s20(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'n')
return (lex_advance(25, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_keywords_s21(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'i')
return (lex_advance(26, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_keywords_s22(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'l')
return (lex_advance(27, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_keywords_s23(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_case, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_keywords_s24(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_done, lexer, s);
return (lex_end_state(lexer, s));
}

45
parser/static/lex_funcs/lex_keywords/state_5.c
View file

@ -1,45 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_5.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_keywords_funcs.h"
bool lex_keywords_s25(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_then, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_keywords_s26(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'l')
return (lex_advance(28, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_keywords_s27(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'e')
return (lex_advance(29, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_keywords_s28(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_until, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_keywords_s29(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_while, lexer, s);
return (lex_end_state(lexer, s));
}

21
parser/static/lex_funcs/lex_keywords/state_6.c
View file

@ -1,21 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_6.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_keywords_funcs.h"
bool lex_keywords_default(t_lexer *lexer, t_lexer_state *s)
{
(void)(lexer);
(void)(s);
s->result = false;
return (false);
}

50
parser/static/lex_funcs/lex_normal/create_table/lex_normal_array.h
View file

@ -1,50 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lex_normal_array.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* 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 */
/* */
/* ************************************************************************** */
#ifndef LEX_NORMAL_ARRAY_H
# define LEX_NORMAL_ARRAY_H
# include "../../../types/type_lex_normal.h"
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../char_set/charset_inline.h"
# include "../lex_normal_funcs.h"
void lex_normal_array_0(t_lex_normal_array *v);
void lex_normal_array_1(t_lex_normal_array *v);
void lex_normal_array_2(t_lex_normal_array *v);
void lex_normal_array_3(t_lex_normal_array *v);
void lex_normal_array_4(t_lex_normal_array *v);
void lex_normal_array_5(t_lex_normal_array *v);
void lex_normal_array_6(t_lex_normal_array *v);
void lex_normal_array_7(t_lex_normal_array *v);
void lex_normal_array_8(t_lex_normal_array *v);
void lex_normal_array_9(t_lex_normal_array *v);
void lex_normal_array_10(t_lex_normal_array *v);
void lex_normal_array_11(t_lex_normal_array *v);
void lex_normal_array_12(t_lex_normal_array *v);
void lex_normal_array_13(t_lex_normal_array *v);
void lex_normal_array_14(t_lex_normal_array *v);
void lex_normal_array_15(t_lex_normal_array *v);
void lex_normal_array_16(t_lex_normal_array *v);
void lex_normal_array_17(t_lex_normal_array *v);
void lex_normal_array_18(t_lex_normal_array *v);
void lex_normal_array_19(t_lex_normal_array *v);
void lex_normal_array_20(t_lex_normal_array *v);
void lex_normal_array_21(t_lex_normal_array *v);
void lex_normal_array_22(t_lex_normal_array *v);
void lex_normal_array_23(t_lex_normal_array *v);
void lex_normal_array_24(t_lex_normal_array *v);
#endif // LEX_NORMAL_ARRAY_H

145
parser/static/lex_funcs/lex_normal/create_table/lex_normal_array_0.c
View file

@ -1,145 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lex_normal_array_0.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 "../../../headers/symbols.h"
#include "../../../headers/external_scanner_symbol_identifiers.h"
#include "../../../headers/field_identifiers.h"
#include "../../../headers/constants.h"
#include "../lex_normal_funcs.h"
#include "./lex_normal_array.h"
void lex_normal_array_0(t_lex_normal_array *v)
{
v->a[0] = lex_normal_s0;
v->a[1] = lex_normal_s1;
v->a[2] = lex_normal_s2;
v->a[3] = lex_normal_s3;
v->a[4] = lex_normal_s4;
v->a[5] = lex_normal_s5;
v->a[6] = lex_normal_s6;
v->a[7] = lex_normal_s7;
v->a[8] = lex_normal_s8;
v->a[9] = lex_normal_s9;
v->a[10] = lex_normal_s10;
v->a[11] = lex_normal_s11;
v->a[12] = lex_normal_s12;
v->a[13] = lex_normal_s13;
v->a[14] = lex_normal_s14;
v->a[15] = lex_normal_s15;
v->a[16] = lex_normal_s16;
v->a[17] = lex_normal_s17;
v->a[18] = lex_normal_s18;
v->a[19] = lex_normal_s19;
lex_normal_array_1(v);
}
void lex_normal_array_1(t_lex_normal_array *v)
{
v->a[20] = lex_normal_s20;
v->a[21] = lex_normal_s21;
v->a[22] = lex_normal_s22;
v->a[23] = lex_normal_s23;
v->a[24] = lex_normal_s24;
v->a[25] = lex_normal_s25;
v->a[26] = lex_normal_s26;
v->a[27] = lex_normal_s27;
v->a[28] = lex_normal_s28;
v->a[29] = lex_normal_s29;
v->a[30] = lex_normal_s30;
v->a[31] = lex_normal_s31;
v->a[32] = lex_normal_s32;
v->a[33] = lex_normal_s33;
v->a[34] = lex_normal_s34;
v->a[35] = lex_normal_s35;
v->a[36] = lex_normal_s36;
v->a[37] = lex_normal_s37;
v->a[38] = lex_normal_s38;
v->a[39] = lex_normal_s39;
lex_normal_array_2(v);
}
void lex_normal_array_2(t_lex_normal_array *v)
{
v->a[40] = lex_normal_s40;
v->a[41] = lex_normal_s41;
v->a[42] = lex_normal_s42;
v->a[43] = lex_normal_s43;
v->a[44] = lex_normal_s44;
v->a[45] = lex_normal_s45;
v->a[46] = lex_normal_s46;
v->a[47] = lex_normal_s47;
v->a[48] = lex_normal_s48;
v->a[49] = lex_normal_s49;
v->a[50] = lex_normal_s50;
v->a[51] = lex_normal_s51;
v->a[52] = lex_normal_s52;
v->a[53] = lex_normal_s53;
v->a[54] = lex_normal_s54;
v->a[55] = lex_normal_s55;
v->a[56] = lex_normal_s56;
v->a[57] = lex_normal_s57;
v->a[58] = lex_normal_s58;
v->a[59] = lex_normal_s59;
lex_normal_array_3(v);
}
void lex_normal_array_3(t_lex_normal_array *v)
{
v->a[60] = lex_normal_s60;
v->a[61] = lex_normal_s61;
v->a[62] = lex_normal_s62;
v->a[63] = lex_normal_s63;
v->a[64] = lex_normal_s64;
v->a[65] = lex_normal_s65;
v->a[66] = lex_normal_s66;
v->a[67] = lex_normal_s67;
v->a[68] = lex_normal_s68;
v->a[69] = lex_normal_s69;
v->a[70] = lex_normal_s70;
v->a[71] = lex_normal_s71;
v->a[72] = lex_normal_s72;
v->a[73] = lex_normal_s73;
v->a[74] = lex_normal_s74;
v->a[75] = lex_normal_s75;
v->a[76] = lex_normal_s76;
v->a[77] = lex_normal_s77;
v->a[78] = lex_normal_s78;
v->a[79] = lex_normal_s79;
lex_normal_array_4(v);
}
void lex_normal_array_4(t_lex_normal_array *v)
{
v->a[80] = lex_normal_s80;
v->a[81] = lex_normal_s81;
v->a[82] = lex_normal_s82;
v->a[83] = lex_normal_s83;
v->a[84] = lex_normal_s84;
v->a[85] = lex_normal_s85;
v->a[86] = lex_normal_s86;
v->a[87] = lex_normal_s87;
v->a[88] = lex_normal_s88;
v->a[89] = lex_normal_s89;
v->a[90] = lex_normal_s90;
v->a[91] = lex_normal_s91;
v->a[92] = lex_normal_s92;
v->a[93] = lex_normal_s93;
v->a[94] = lex_normal_s94;
v->a[95] = lex_normal_s95;
v->a[96] = lex_normal_s96;
v->a[97] = lex_normal_s97;
v->a[98] = lex_normal_s98;
v->a[99] = lex_normal_s99;
lex_normal_array_5(v);
}
/* EOF lex_normal_array_0.c */

145
parser/static/lex_funcs/lex_normal/create_table/lex_normal_array_1.c
View file

@ -1,145 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lex_normal_array_1.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 "../../../headers/symbols.h"
#include "../../../headers/external_scanner_symbol_identifiers.h"
#include "../../../headers/field_identifiers.h"
#include "../../../headers/constants.h"
#include "../lex_normal_funcs.h"
#include "./lex_normal_array.h"
void lex_normal_array_5(t_lex_normal_array *v)
{
v->a[100] = lex_normal_s100;
v->a[101] = lex_normal_s101;
v->a[102] = lex_normal_s102;
v->a[103] = lex_normal_s103;
v->a[104] = lex_normal_s104;
v->a[105] = lex_normal_s105;
v->a[106] = lex_normal_s106;
v->a[107] = lex_normal_s107;
v->a[108] = lex_normal_s108;
v->a[109] = lex_normal_s109;
v->a[110] = lex_normal_s110;
v->a[111] = lex_normal_s111;
v->a[112] = lex_normal_s112;
v->a[113] = lex_normal_s113;
v->a[114] = lex_normal_s114;
v->a[115] = lex_normal_s115;
v->a[116] = lex_normal_s116;
v->a[117] = lex_normal_s117;
v->a[118] = lex_normal_s118;
v->a[119] = lex_normal_s119;
lex_normal_array_6(v);
}
void lex_normal_array_6(t_lex_normal_array *v)
{
v->a[120] = lex_normal_s120;
v->a[121] = lex_normal_s121;
v->a[122] = lex_normal_s122;
v->a[123] = lex_normal_s123;
v->a[124] = lex_normal_s124;
v->a[125] = lex_normal_s125;
v->a[126] = lex_normal_s126;
v->a[127] = lex_normal_s127;
v->a[128] = lex_normal_s128;
v->a[129] = lex_normal_s129;
v->a[130] = lex_normal_s130;
v->a[131] = lex_normal_s131;
v->a[132] = lex_normal_s132;
v->a[133] = lex_normal_s133;
v->a[134] = lex_normal_s134;
v->a[135] = lex_normal_s135;
v->a[136] = lex_normal_s136;
v->a[137] = lex_normal_s137;
v->a[138] = lex_normal_s138;
v->a[139] = lex_normal_s139;
lex_normal_array_7(v);
}
void lex_normal_array_7(t_lex_normal_array *v)
{
v->a[140] = lex_normal_s140;
v->a[141] = lex_normal_s141;
v->a[142] = lex_normal_s142;
v->a[143] = lex_normal_s143;
v->a[144] = lex_normal_s144;
v->a[145] = lex_normal_s145;
v->a[146] = lex_normal_s146;
v->a[147] = lex_normal_s147;
v->a[148] = lex_normal_s148;
v->a[149] = lex_normal_s149;
v->a[150] = lex_normal_s150;
v->a[151] = lex_normal_s151;
v->a[152] = lex_normal_s152;
v->a[153] = lex_normal_s153;
v->a[154] = lex_normal_s154;
v->a[155] = lex_normal_s155;
v->a[156] = lex_normal_s156;
v->a[157] = lex_normal_s157;
v->a[158] = lex_normal_s158;
v->a[159] = lex_normal_s159;
lex_normal_array_8(v);
}
void lex_normal_array_8(t_lex_normal_array *v)
{
v->a[160] = lex_normal_s160;
v->a[161] = lex_normal_s161;
v->a[162] = lex_normal_s162;
v->a[163] = lex_normal_s163;
v->a[164] = lex_normal_s164;
v->a[165] = lex_normal_s165;
v->a[166] = lex_normal_s166;
v->a[167] = lex_normal_s167;
v->a[168] = lex_normal_s168;
v->a[169] = lex_normal_s169;
v->a[170] = lex_normal_s170;
v->a[171] = lex_normal_s171;
v->a[172] = lex_normal_s172;
v->a[173] = lex_normal_s173;
v->a[174] = lex_normal_s174;
v->a[175] = lex_normal_s175;
v->a[176] = lex_normal_s176;
v->a[177] = lex_normal_s177;
v->a[178] = lex_normal_s178;
v->a[179] = lex_normal_s179;
lex_normal_array_9(v);
}
void lex_normal_array_9(t_lex_normal_array *v)
{
v->a[180] = lex_normal_s180;
v->a[181] = lex_normal_s181;
v->a[182] = lex_normal_s182;
v->a[183] = lex_normal_s183;
v->a[184] = lex_normal_s184;
v->a[185] = lex_normal_s185;
v->a[186] = lex_normal_s186;
v->a[187] = lex_normal_s187;
v->a[188] = lex_normal_s188;
v->a[189] = lex_normal_s189;
v->a[190] = lex_normal_s190;
v->a[191] = lex_normal_s191;
v->a[192] = lex_normal_s192;
v->a[193] = lex_normal_s193;
v->a[194] = lex_normal_s194;
v->a[195] = lex_normal_s195;
v->a[196] = lex_normal_s196;
v->a[197] = lex_normal_s197;
v->a[198] = lex_normal_s198;
v->a[199] = lex_normal_s199;
lex_normal_array_10(v);
}
/* EOF lex_normal_array_1.c */

145
parser/static/lex_funcs/lex_normal/create_table/lex_normal_array_2.c
View file

@ -1,145 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lex_normal_array_2.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 "../../../headers/symbols.h"
#include "../../../headers/external_scanner_symbol_identifiers.h"
#include "../../../headers/field_identifiers.h"
#include "../../../headers/constants.h"
#include "../lex_normal_funcs.h"
#include "./lex_normal_array.h"
void lex_normal_array_10(t_lex_normal_array *v)
{
v->a[200] = lex_normal_s200;
v->a[201] = lex_normal_s201;
v->a[202] = lex_normal_s202;
v->a[203] = lex_normal_s203;
v->a[204] = lex_normal_s204;
v->a[205] = lex_normal_s205;
v->a[206] = lex_normal_s206;
v->a[207] = lex_normal_s207;
v->a[208] = lex_normal_s208;
v->a[209] = lex_normal_s209;
v->a[210] = lex_normal_s210;
v->a[211] = lex_normal_s211;
v->a[212] = lex_normal_s212;
v->a[213] = lex_normal_s213;
v->a[214] = lex_normal_s214;
v->a[215] = lex_normal_s215;
v->a[216] = lex_normal_s216;
v->a[217] = lex_normal_s217;
v->a[218] = lex_normal_s218;
v->a[219] = lex_normal_s219;
lex_normal_array_11(v);
}
void lex_normal_array_11(t_lex_normal_array *v)
{
v->a[220] = lex_normal_s220;
v->a[221] = lex_normal_s221;
v->a[222] = lex_normal_s222;
v->a[223] = lex_normal_s223;
v->a[224] = lex_normal_s224;
v->a[225] = lex_normal_s225;
v->a[226] = lex_normal_s226;
v->a[227] = lex_normal_s227;
v->a[228] = lex_normal_s228;
v->a[229] = lex_normal_s229;
v->a[230] = lex_normal_s230;
v->a[231] = lex_normal_s231;
v->a[232] = lex_normal_s232;
v->a[233] = lex_normal_s233;
v->a[234] = lex_normal_s234;
v->a[235] = lex_normal_s235;
v->a[236] = lex_normal_s236;
v->a[237] = lex_normal_s237;
v->a[238] = lex_normal_s238;
v->a[239] = lex_normal_s239;
lex_normal_array_12(v);
}
void lex_normal_array_12(t_lex_normal_array *v)
{
v->a[240] = lex_normal_s240;
v->a[241] = lex_normal_s241;
v->a[242] = lex_normal_s242;
v->a[243] = lex_normal_s243;
v->a[244] = lex_normal_s244;
v->a[245] = lex_normal_s245;
v->a[246] = lex_normal_s246;
v->a[247] = lex_normal_s247;
v->a[248] = lex_normal_s248;
v->a[249] = lex_normal_s249;
v->a[250] = lex_normal_s250;
v->a[251] = lex_normal_s251;
v->a[252] = lex_normal_s252;
v->a[253] = lex_normal_s253;
v->a[254] = lex_normal_s254;
v->a[255] = lex_normal_s255;
v->a[256] = lex_normal_s256;
v->a[257] = lex_normal_s257;
v->a[258] = lex_normal_s258;
v->a[259] = lex_normal_s259;
lex_normal_array_13(v);
}
void lex_normal_array_13(t_lex_normal_array *v)
{
v->a[260] = lex_normal_s260;
v->a[261] = lex_normal_s261;
v->a[262] = lex_normal_s262;
v->a[263] = lex_normal_s263;
v->a[264] = lex_normal_s264;
v->a[265] = lex_normal_s265;
v->a[266] = lex_normal_s266;
v->a[267] = lex_normal_s267;
v->a[268] = lex_normal_s268;
v->a[269] = lex_normal_s269;
v->a[270] = lex_normal_s270;
v->a[271] = lex_normal_s271;
v->a[272] = lex_normal_s272;
v->a[273] = lex_normal_s273;
v->a[274] = lex_normal_s274;
v->a[275] = lex_normal_s275;
v->a[276] = lex_normal_s276;
v->a[277] = lex_normal_s277;
v->a[278] = lex_normal_s278;
v->a[279] = lex_normal_s279;
lex_normal_array_14(v);
}
void lex_normal_array_14(t_lex_normal_array *v)
{
v->a[280] = lex_normal_s280;
v->a[281] = lex_normal_s281;
v->a[282] = lex_normal_s282;
v->a[283] = lex_normal_s283;
v->a[284] = lex_normal_s284;
v->a[285] = lex_normal_s285;
v->a[286] = lex_normal_s286;
v->a[287] = lex_normal_s287;
v->a[288] = lex_normal_s288;
v->a[289] = lex_normal_s289;
v->a[290] = lex_normal_s290;
v->a[291] = lex_normal_s291;
v->a[292] = lex_normal_s292;
v->a[293] = lex_normal_s293;
v->a[294] = lex_normal_s294;
v->a[295] = lex_normal_s295;
v->a[296] = lex_normal_s296;
v->a[297] = lex_normal_s297;
v->a[298] = lex_normal_s298;
v->a[299] = lex_normal_s299;
lex_normal_array_15(v);
}
/* EOF lex_normal_array_2.c */

145
parser/static/lex_funcs/lex_normal/create_table/lex_normal_array_3.c
View file

@ -1,145 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lex_normal_array_3.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 "../../../headers/symbols.h"
#include "../../../headers/external_scanner_symbol_identifiers.h"
#include "../../../headers/field_identifiers.h"
#include "../../../headers/constants.h"
#include "../lex_normal_funcs.h"
#include "./lex_normal_array.h"
void lex_normal_array_15(t_lex_normal_array *v)
{
v->a[300] = lex_normal_s300;
v->a[301] = lex_normal_s301;
v->a[302] = lex_normal_s302;
v->a[303] = lex_normal_s303;
v->a[304] = lex_normal_s304;
v->a[305] = lex_normal_s305;
v->a[306] = lex_normal_s306;
v->a[307] = lex_normal_s307;
v->a[308] = lex_normal_s308;
v->a[309] = lex_normal_s309;
v->a[310] = lex_normal_s310;
v->a[311] = lex_normal_s311;
v->a[312] = lex_normal_s312;
v->a[313] = lex_normal_s313;
v->a[314] = lex_normal_s314;
v->a[315] = lex_normal_s315;
v->a[316] = lex_normal_s316;
v->a[317] = lex_normal_s317;
v->a[318] = lex_normal_s318;
v->a[319] = lex_normal_s319;
lex_normal_array_16(v);
}
void lex_normal_array_16(t_lex_normal_array *v)
{
v->a[320] = lex_normal_s320;
v->a[321] = lex_normal_s321;
v->a[322] = lex_normal_s322;
v->a[323] = lex_normal_s323;
v->a[324] = lex_normal_s324;
v->a[325] = lex_normal_s325;
v->a[326] = lex_normal_s326;
v->a[327] = lex_normal_s327;
v->a[328] = lex_normal_s328;
v->a[329] = lex_normal_s329;
v->a[330] = lex_normal_s330;
v->a[331] = lex_normal_s331;
v->a[332] = lex_normal_s332;
v->a[333] = lex_normal_s333;
v->a[334] = lex_normal_s334;
v->a[335] = lex_normal_s335;
v->a[336] = lex_normal_s336;
v->a[337] = lex_normal_s337;
v->a[338] = lex_normal_s338;
v->a[339] = lex_normal_s339;
lex_normal_array_17(v);
}
void lex_normal_array_17(t_lex_normal_array *v)
{
v->a[340] = lex_normal_s340;
v->a[341] = lex_normal_s341;
v->a[342] = lex_normal_s342;
v->a[343] = lex_normal_s343;
v->a[344] = lex_normal_s344;
v->a[345] = lex_normal_s345;
v->a[346] = lex_normal_s346;
v->a[347] = lex_normal_s347;
v->a[348] = lex_normal_s348;
v->a[349] = lex_normal_s349;
v->a[350] = lex_normal_s350;
v->a[351] = lex_normal_s351;
v->a[352] = lex_normal_s352;
v->a[353] = lex_normal_s353;
v->a[354] = lex_normal_s354;
v->a[355] = lex_normal_s355;
v->a[356] = lex_normal_s356;
v->a[357] = lex_normal_s357;
v->a[358] = lex_normal_s358;
v->a[359] = lex_normal_s359;
lex_normal_array_18(v);
}
void lex_normal_array_18(t_lex_normal_array *v)
{
v->a[360] = lex_normal_s360;
v->a[361] = lex_normal_s361;
v->a[362] = lex_normal_s362;
v->a[363] = lex_normal_s363;
v->a[364] = lex_normal_s364;
v->a[365] = lex_normal_s365;
v->a[366] = lex_normal_s366;
v->a[367] = lex_normal_s367;
v->a[368] = lex_normal_s368;
v->a[369] = lex_normal_s369;
v->a[370] = lex_normal_s370;
v->a[371] = lex_normal_s371;
v->a[372] = lex_normal_s372;
v->a[373] = lex_normal_s373;
v->a[374] = lex_normal_s374;
v->a[375] = lex_normal_s375;
v->a[376] = lex_normal_s376;
v->a[377] = lex_normal_s377;
v->a[378] = lex_normal_s378;
v->a[379] = lex_normal_s379;
lex_normal_array_19(v);
}
void lex_normal_array_19(t_lex_normal_array *v)
{
v->a[380] = lex_normal_s380;
v->a[381] = lex_normal_s381;
v->a[382] = lex_normal_s382;
v->a[383] = lex_normal_s383;
v->a[384] = lex_normal_s384;
v->a[385] = lex_normal_s385;
v->a[386] = lex_normal_s386;
v->a[387] = lex_normal_s387;
v->a[388] = lex_normal_s388;
v->a[389] = lex_normal_s389;
v->a[390] = lex_normal_s390;
v->a[391] = lex_normal_s391;
v->a[392] = lex_normal_s392;
v->a[393] = lex_normal_s393;
v->a[394] = lex_normal_s394;
v->a[395] = lex_normal_s395;
v->a[396] = lex_normal_s396;
v->a[397] = lex_normal_s397;
v->a[398] = lex_normal_s398;
v->a[399] = lex_normal_s399;
lex_normal_array_20(v);
}
/* EOF lex_normal_array_3.c */

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

@ -1,134 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lex_normal_array_4.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 "../../../headers/symbols.h"
#include "../../../headers/external_scanner_symbol_identifiers.h"
#include "../../../headers/field_identifiers.h"
#include "../../../headers/constants.h"
#include "../lex_normal_funcs.h"
#include "./lex_normal_array.h"
void lex_normal_array_20(t_lex_normal_array *v)
{
v->a[400] = lex_normal_s400;
v->a[401] = lex_normal_s401;
v->a[402] = lex_normal_s402;
v->a[403] = lex_normal_s403;
v->a[404] = lex_normal_s404;
v->a[405] = lex_normal_s405;
v->a[406] = lex_normal_s406;
v->a[407] = lex_normal_s407;
v->a[408] = lex_normal_s408;
v->a[409] = lex_normal_s409;
v->a[410] = lex_normal_s410;
v->a[411] = lex_normal_s411;
v->a[412] = lex_normal_s412;
v->a[413] = lex_normal_s413;
v->a[414] = lex_normal_s414;
v->a[415] = lex_normal_s415;
v->a[416] = lex_normal_s416;
v->a[417] = lex_normal_s417;
v->a[418] = lex_normal_s418;
v->a[419] = lex_normal_s419;
lex_normal_array_21(v);
}
void lex_normal_array_21(t_lex_normal_array *v)
{
v->a[420] = lex_normal_s420;
v->a[421] = lex_normal_s421;
v->a[422] = lex_normal_s422;
v->a[423] = lex_normal_s423;
v->a[424] = lex_normal_s424;
v->a[425] = lex_normal_s425;
v->a[426] = lex_normal_s426;
v->a[427] = lex_normal_s427;
v->a[428] = lex_normal_s428;
v->a[429] = lex_normal_s429;
v->a[430] = lex_normal_s430;
v->a[431] = lex_normal_s431;
v->a[432] = lex_normal_s432;
v->a[433] = lex_normal_s433;
v->a[434] = lex_normal_s434;
v->a[435] = lex_normal_s435;
v->a[436] = lex_normal_s436;
v->a[437] = lex_normal_s437;
v->a[438] = lex_normal_s438;
v->a[439] = lex_normal_s439;
lex_normal_array_22(v);
}
void lex_normal_array_22(t_lex_normal_array *v)
{
v->a[440] = lex_normal_s440;
v->a[441] = lex_normal_s441;
v->a[442] = lex_normal_s442;
v->a[443] = lex_normal_s443;
v->a[444] = lex_normal_s444;
v->a[445] = lex_normal_s445;
v->a[446] = lex_normal_s446;
v->a[447] = lex_normal_s447;
v->a[448] = lex_normal_s448;
v->a[449] = lex_normal_s449;
v->a[450] = lex_normal_s450;
v->a[451] = lex_normal_s451;
v->a[452] = lex_normal_s452;
v->a[453] = lex_normal_s453;
v->a[454] = lex_normal_s454;
v->a[455] = lex_normal_s455;
v->a[456] = lex_normal_s456;
v->a[457] = lex_normal_s457;
v->a[458] = lex_normal_s458;
v->a[459] = lex_normal_s459;
lex_normal_array_23(v);
}
void lex_normal_array_23(t_lex_normal_array *v)
{
v->a[460] = lex_normal_s460;
v->a[461] = lex_normal_s461;
v->a[462] = lex_normal_s462;
v->a[463] = lex_normal_s463;
v->a[464] = lex_normal_s464;
v->a[465] = lex_normal_s465;
v->a[466] = lex_normal_s466;
v->a[467] = lex_normal_s467;
v->a[468] = lex_normal_s468;
v->a[469] = lex_normal_s469;
v->a[470] = lex_normal_s470;
v->a[471] = lex_normal_s471;
v->a[472] = lex_normal_s472;
v->a[473] = lex_normal_s473;
v->a[474] = lex_normal_s474;
v->a[475] = lex_normal_s475;
v->a[476] = lex_normal_s476;
v->a[477] = lex_normal_s477;
v->a[478] = lex_normal_s478;
v->a[479] = lex_normal_s479;
lex_normal_array_24(v);
}
void lex_normal_array_24(t_lex_normal_array *v)
{
v->a[480] = lex_normal_s480;
v->a[481] = lex_normal_s481;
v->a[482] = lex_normal_s482;
v->a[483] = lex_normal_s483;
v->a[484] = lex_normal_s484;
v->a[485] = lex_normal_s485;
v->a[486] = lex_normal_s486;
v->a[487] = lex_normal_s487;
v->a[488] = lex_normal_s488;
v->a[489] = lex_normal_s489;
v->a[490] = lex_normal_s490;
}
/* EOF lex_normal_array_4.c */

41
parser/static/lex_funcs/lex_normal/inline.h
View file

@ -1,41 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* 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 */
/* */
/* ************************************************************************** */
#ifndef INLINE_H
# define INLINE_H
# include "../../headers/symbols.h"
# include "../../headers/external_scanner_symbol_identifiers.h"
# include "../../headers/field_identifiers.h"
# include "../../headers/constants.h"
# include "../../../parse_types.h"
# include "./inline/inline_impl0.h"
# include "./inline/inline_impl1.h"
# include "./inline/inline_impl2.h"
# include "./inline/inline_impl3.h"
# include "./inline/inline_impl4.h"
# include "./inline/inline_impl5.h"
# include "./inline/inline_impl6.h"
# include "./inline/inline_impl7.h"
# include "./inline/inline_impl8.h"
# include "./inline/inline_impl9.h"
# include "./inline/inline_impl10.h"
# include "./inline/inline_impl11.h"
# include "./inline/inline_impl12.h"
# include "./inline/inline_impl13.h"
# include "./inline/inline_impl14.h"
# include "./inline/inline_impl15.h"
# include "./inline/inline_impl16.h"
# include "./inline/inline_impl17.h"
# include "./inline/inline_impl18.h"
#endif // INLINE_H

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

@ -1,85 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl0.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* 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 */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL0_H
# define INLINE_IMPL0_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map0(t_lexer *lexer, \
t_lexer_state *s)
{
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));
}
static inline bool lex_normal_map5(t_lexer *lexer, \
t_lexer_state *s)
{
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));
}
static inline bool lex_normal_map10(t_lexer *lexer, \
t_lexer_state *s)
{
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_map48(t_lexer *lexer, \
t_lexer_state *s)
{
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_map89(t_lexer *lexer, \
t_lexer_state *s)
{
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));
}
#endif // INLINE_IMPL0_H

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

@ -1,81 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl1.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* 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 */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL1_H
# define INLINE_IMPL1_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# 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', 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_map100(t_lexer *lexer, \
t_lexer_state *s)
{
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));
}
static inline bool lex_normal_map101(t_lexer *lexer, \
t_lexer_state *s)
{
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));
}
#endif // INLINE_IMPL1_H

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

@ -1,81 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl10.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* 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 */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL10_H
# define INLINE_IMPL10_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map229(t_lexer *lexer, \
t_lexer_state *s)
{
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_map230(t_lexer *lexer, \
t_lexer_state *s)
{
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_map231(t_lexer *lexer, \
t_lexer_state *s)
{
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_map365(t_lexer *lexer, \
t_lexer_state *s)
{
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_map366(t_lexer *lexer, \
t_lexer_state *s)
{
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));
}
#endif // INLINE_IMPL10_H

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

@ -1,84 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl11.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* 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 */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL11_H
# define INLINE_IMPL11_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map411(t_lexer *lexer, \
t_lexer_state *s)
{
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_map412(t_lexer *lexer, \
t_lexer_state *s)
{
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_map413(t_lexer *lexer, \
t_lexer_state *s)
{
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_map414(t_lexer *lexer, \
t_lexer_state *s)
{
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_map415(t_lexer *lexer, \
t_lexer_state *s)
{
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));
}
#endif // INLINE_IMPL11_H

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

@ -1,83 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl12.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* 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 */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL12_H
# define INLINE_IMPL12_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map416(t_lexer *lexer, \
t_lexer_state *s)
{
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_map417(t_lexer *lexer, \
t_lexer_state *s)
{
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_map418(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));
}
static inline bool lex_normal_map419(t_lexer *lexer, \
t_lexer_state *s)
{
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_map420(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));
}
#endif // INLINE_IMPL12_H

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

@ -1,80 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl13.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* 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 */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL13_H
# define INLINE_IMPL13_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map421(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_map422(t_lexer *lexer, \
t_lexer_state *s)
{
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_map423(t_lexer *lexer, \
t_lexer_state *s)
{
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_map424(t_lexer *lexer, \
t_lexer_state *s)
{
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_map425(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));
}
#endif // INLINE_IMPL13_H

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

@ -1,80 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl14.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* 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 */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL14_H
# define INLINE_IMPL14_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map426(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_map427(t_lexer *lexer, \
t_lexer_state *s)
{
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_map428(t_lexer *lexer, \
t_lexer_state *s)
{
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_map429(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_map430(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));
}
#endif // INLINE_IMPL14_H

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

@ -1,76 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl15.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* 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 */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL15_H
# define INLINE_IMPL15_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map431(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_map432(t_lexer *lexer, \
t_lexer_state *s)
{
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_map433(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_map444(t_lexer *lexer, \
t_lexer_state *s)
{
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_map445(t_lexer *lexer, \
t_lexer_state *s)
{
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));
}
#endif // INLINE_IMPL15_H

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

@ -1,76 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl16.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* 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 */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL16_H
# define INLINE_IMPL16_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# 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', 296, '!', 261, '#', 376, \
'*', 336, '-', 332, '0', 438, '?', 343, '@', 436, '\\', \
30, '_', 441};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map454(t_lexer *lexer, \
t_lexer_state *s)
{
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));
}
#endif // INLINE_IMPL16_H

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

@ -1,78 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl17.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* 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 */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL17_H
# define INLINE_IMPL17_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map455(t_lexer *lexer, \
t_lexer_state *s)
{
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_map456(t_lexer *lexer, \
t_lexer_state *s)
{
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_map457(t_lexer *lexer, \
t_lexer_state *s)
{
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_map458(t_lexer *lexer, \
t_lexer_state *s)
{
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_map459(t_lexer *lexer, \
t_lexer_state *s)
{
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));
}
#endif // INLINE_IMPL17_H

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

@ -1,54 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl18.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* 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 */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL18_H
# define INLINE_IMPL18_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map460(t_lexer *lexer, \
t_lexer_state *s)
{
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_map461(t_lexer *lexer, \
t_lexer_state *s)
{
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_map462(t_lexer *lexer, \
t_lexer_state *s)
{
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));
}
#endif // INLINE_IMPL18_H

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

@ -1,79 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl2.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* 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 */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL2_H
# define INLINE_IMPL2_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# 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', 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_map105(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));
}
static inline bool lex_normal_map106(t_lexer *lexer, \
t_lexer_state *s)
{
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));
}
#endif // INLINE_IMPL2_H

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

@ -1,81 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl3.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* 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 */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL3_H
# define INLINE_IMPL3_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# 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', 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_map110(t_lexer *lexer, \
t_lexer_state *s)
{
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_map111(t_lexer *lexer, \
t_lexer_state *s)
{
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));
}
#endif // INLINE_IMPL3_H

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

@ -1,83 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl4.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* 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 */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL4_H
# define INLINE_IMPL4_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# 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', 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_map164(t_lexer *lexer, \
t_lexer_state *s)
{
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_map165(t_lexer *lexer, \
t_lexer_state *s)
{
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));
}
#endif // INLINE_IMPL4_H

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

@ -1,78 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl5.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* 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 */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL5_H
# define INLINE_IMPL5_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# 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[] = {'!', 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_map169(t_lexer *lexer, \
t_lexer_state *s)
{
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));
}
static inline bool lex_normal_map170(t_lexer *lexer, \
t_lexer_state *s)
{
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));
}
#endif // INLINE_IMPL5_H

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

@ -1,76 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl6.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* 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 */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL6_H
# define INLINE_IMPL6_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# 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[] = {'!', 261, '"', 360, '#', 400, \
'$', 358, '\'', 197, '(', 248, '<', 267, '>', 270, '\\', \
130, '`', 395, '{', 255, '}', 257};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map174(t_lexer *lexer, \
t_lexer_state *s)
{
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));
}
static inline bool lex_normal_map175(t_lexer *lexer, \
t_lexer_state *s)
{
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));
}
#endif // INLINE_IMPL6_H

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

@ -1,75 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl7.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* 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 */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL7_H
# define INLINE_IMPL7_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# 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[] = {'!', 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_map179(t_lexer *lexer, \
t_lexer_state *s)
{
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));
}
static inline bool lex_normal_map180(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 260, '#', 375, '$', 357, \
'*', 333, '-', 330, '0', 439, '?', 342, '@', 435};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif // INLINE_IMPL7_H

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

@ -1,75 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl8.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* 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 */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL8_H
# define INLINE_IMPL8_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# 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[] = {'"', 360, '#', 400, '$', 358, \
'&', 196, '\'', 197, '(', 248, '<', 266, '>', 270, '\\', \
148, '`', 396, '|', 251};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map184(t_lexer *lexer, \
t_lexer_state *s)
{
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));
}
static inline bool lex_normal_map185(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'"', 360, '#', 400, '$', 358, \
'\'', 197, '(', 248, '\\', 150, '`', 395, 'e', 487};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif // INLINE_IMPL8_H

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

@ -1,80 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl9.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* 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 */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL9_H
# define INLINE_IMPL9_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map221(t_lexer *lexer, \
t_lexer_state *s)
{
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_map222(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_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));
}
static inline bool lex_normal_map225(t_lexer *lexer, \
t_lexer_state *s)
{
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));
}
#endif // INLINE_IMPL9_H

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

@ -1,518 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lex_normal_funcs.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* 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 */
/* */
/* ************************************************************************** */
#ifndef LEX_NORMAL_FUNCS_H
# define LEX_NORMAL_FUNCS_H
# include "../../types/type_lex_normal.h"
# include "../../headers/symbols.h"
# include "../../headers/external_scanner_symbol_identifiers.h"
# include "../../headers/field_identifiers.h"
# include "../../headers/constants.h"
# include "../../char_set/charset_inline.h"
# include "./inline.h"
# include "../../../parse_types.h"
bool lex_normal_s0(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s1(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s2(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s3(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s4(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s5(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s6(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s7(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s8(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s9(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s10(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s11(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s12(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s13(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s14(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s15(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s16(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s17(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s18(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s19(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s20(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s21(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s22(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s23(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s24(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s25(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s26(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s27(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s28(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s29(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s30(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s31(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s32(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s33(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s34(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s35(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s36(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s37(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s38(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s39(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s40(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s41(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s42(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s43(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s44(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s45(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s46(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s47(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s48(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s49(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s50(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s51(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s52(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s53(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s54(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s55(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s56(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s57(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s58(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s59(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s60(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s61(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s62(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s63(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s64(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s65(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s66(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s67(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s68(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s69(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s70(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s71(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s72(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s73(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s74(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s75(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s76(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s77(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s78(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s79(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s80(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s81(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s82(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s83(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s84(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s85(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s86(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s87(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s88(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s89(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s90(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s91(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s92(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s93(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s94(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s95(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s96(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s97(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s98(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s99(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s100(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s101(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s102(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s103(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s104(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s105(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s106(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s107(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s108(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s109(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s110(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s111(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s112(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s113(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s114(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s115(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s116(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s117(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s118(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s119(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s120(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s121(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s122(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s123(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s124(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s125(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s126(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s127(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s128(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s129(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s130(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s131(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s132(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s133(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s134(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s135(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s136(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s137(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s138(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s139(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s140(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s141(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s142(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s143(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s144(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s145(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s146(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s147(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s148(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s149(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s150(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s151(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s152(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s153(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s154(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s155(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s156(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s157(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s158(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s159(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s160(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s161(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s162(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s163(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s164(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s165(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s166(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s167(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s168(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s169(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s170(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s171(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s172(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s173(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s174(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s175(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s176(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s177(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s178(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s179(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s180(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s181(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s182(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s183(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s184(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s185(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s186(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s187(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s188(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s189(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s190(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s191(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s192(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s193(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s194(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s195(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s196(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s197(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s198(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s199(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s200(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s201(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s202(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s203(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s204(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s205(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s206(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s207(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s208(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s209(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s210(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s211(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s212(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s213(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s214(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s215(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s216(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s217(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s218(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s219(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s220(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s221(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s222(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s223(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s224(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s225(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s226(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s227(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s228(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s229(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s230(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s231(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s232(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s233(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s234(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s235(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s236(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s237(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s238(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s239(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s240(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s241(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s242(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s243(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s244(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s245(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s246(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s247(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s248(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s249(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s250(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s251(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s252(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s253(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s254(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s255(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s256(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s257(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s258(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s259(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s260(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s261(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s262(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s263(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s264(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s265(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s266(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s267(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s268(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s269(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s270(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s271(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s272(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s273(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s274(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s275(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s276(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s277(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s278(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s279(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s280(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s281(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s282(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s283(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s284(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s285(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s286(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s287(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s288(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s289(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s290(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s291(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s292(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s293(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s294(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s295(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s296(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s297(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s298(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s299(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s300(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s301(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s302(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s303(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s304(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s305(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s306(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s307(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s308(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s309(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s310(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s311(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s312(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s313(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s314(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s315(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s316(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s317(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s318(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s319(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s320(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s321(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s322(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s323(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s324(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s325(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s326(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s327(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s328(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s329(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s330(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s331(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s332(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s333(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s334(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s335(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s336(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s337(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s338(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s339(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s340(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s341(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s342(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s343(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s344(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s345(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s346(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s347(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s348(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s349(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s350(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s351(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s352(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s353(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s354(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s355(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s356(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s357(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s358(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s359(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s360(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s361(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s362(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s363(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s364(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s365(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s366(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s367(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s368(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s369(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s370(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s371(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s372(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s373(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s374(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s375(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s376(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s377(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s378(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s379(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s380(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s381(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s382(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s383(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s384(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s385(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s386(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s387(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s388(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s389(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s390(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s391(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s392(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s393(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s394(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s395(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s396(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s397(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s398(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s399(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s400(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s401(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s402(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s403(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s404(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s405(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s406(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s407(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s408(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s409(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s410(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s411(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s412(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s413(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s414(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s415(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s416(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s417(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s418(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s419(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s420(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s421(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s422(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s423(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s424(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s425(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s426(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s427(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s428(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s429(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s430(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s431(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s432(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s433(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s434(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s435(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s436(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s437(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s438(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s439(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s440(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s441(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s442(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s443(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s444(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s445(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s446(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s447(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s448(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s449(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s450(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s451(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s452(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s453(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s454(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s455(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s456(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s457(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s458(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s459(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s460(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s461(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s462(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s463(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s464(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s465(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s466(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s467(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s468(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s469(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s470(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s471(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s472(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s473(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s474(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s475(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s476(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s477(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s478(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s479(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s480(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s481(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s482(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s483(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s484(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s485(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s486(t_lexer *lexer, t_lexer_state *s);
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_default(t_lexer *lexer, t_lexer_state *s);
#endif // LEX_NORMAL_FUNCS_H

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

@ -1,49 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* main_func.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"
t_lex_normal_array *create_lex_normal(void);
bool lex_normal_call(t_lexer *lexer, t_lexer_state *s)
{
t_lex_normal_array *t;
t = create_lex_normal();
if (s->state < 491)
{
return (((bool (*)(t_lexer *, t_lexer_state \
*))(t->a[s->state]))(lexer, s));
}
return (lex_normal_default(lexer, s));
}
bool lex_normal_main(t_lexer *lexer, t_state_id state)
{
t_lexer_state s;
s = (t_lexer_state){.result = false, .skip = false, .eof = \
false};
s.state = state;
s.skip = false;
s.lookahead = lexer->lookahead;
s.eof = lexer->eof(lexer);
while (lex_normal_call(lexer, &s))
{
lexer->advance(lexer, s.skip);
s.skip = false;
s.lookahead = lexer->lookahead;
s.eof = lexer->eof(lexer);
}
return (s.result);
}
/* main_func.c */

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

@ -1,59 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_0.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_s0(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
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(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));
}
bool lex_normal_s1(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
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(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(170, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s4(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(5, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -1,58 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_1.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_s5(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map5(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(5, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(443, 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));
}
bool lex_normal_s6(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
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(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(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(184, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -1,63 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_10.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_s50(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(412, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(49, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(48, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s51(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
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(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(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(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(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(104, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -1,61 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_11.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_s55(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
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(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(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(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(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(430, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(58, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(462, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(167, lexer, s));
if (s->lookahead != 0)
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -1,60 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_12.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_s60(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
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(167, lexer, s));
if (s->lookahead != 0)
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(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(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(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(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(431, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -1,68 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_13.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_s65(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
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(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(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(426, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(66, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(457, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(113, lexer, s));
if (s->lookahead != 0)
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(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(113, lexer, s));
if (s->lookahead != 0)
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(185, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -1,63 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_14.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_s70(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
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(427, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(70, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(458, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(114, lexer, s));
if (s->lookahead != 0)
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(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(114, lexer, s));
if (s->lookahead != 0)
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(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(190, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -1,60 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_15.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_s75(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
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(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(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(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(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(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));
}

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

@ -1,60 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_16.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_s80(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
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(432, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(80, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
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(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(366, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(363, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_advance(366, lexer, s));
if (s->lookahead != 0)
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(188, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -1,65 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_17.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_s85(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
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(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(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(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(189, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s89(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map89(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(89, 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));
}

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

@ -1,63 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_18.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_s90(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
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(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(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(425, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(92, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(456, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(112, lexer, s));
if (s->lookahead != 0)
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(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(112, lexer, s));
if (s->lookahead != 0)
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -1,77 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_19.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_s95(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
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_skip(191, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s97(t_lexer *lexer, t_lexer_state *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 (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));
}
bool lex_normal_s99(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map99(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(99, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
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));
}

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

@ -1,75 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_2.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_s10(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map10(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(10, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(444, 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_s11(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
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(411, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(11, lexer, s));
if (s->lookahead == ' ')
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(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(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(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(434, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -1,90 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_20.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_s100(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map100(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(100, 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_s101(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map101(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(101, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(449, 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)
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
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 == ' '))
return (lex_skip(102, 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_s103(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map103(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(103, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
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(488, lexer, s));
return (lex_end_state(lexer, s));
}
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 <= '\r') || \
s->lookahead == ' '))
return (lex_skip(104, 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));
}

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

@ -1,99 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_21.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_s105(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map105(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(105, 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));
}
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 <= '\r') || \
s->lookahead == ' '))
return (lex_skip(106, 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_s107(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map107(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(107, 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(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_s108(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map108(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(108, 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_s109(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map109(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(109, lexer, s));
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(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));
}

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

@ -1,109 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_22.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_s110(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map110(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(110, 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_s111(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map111(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(111, lexer, s));
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(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_s112(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map112(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(112, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(456, 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_s113(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map113(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(113, lexer, s));
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(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));
}
bool lex_normal_s114(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map114(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(114, 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(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 > '>' && s->lookahead < 'Z') && \
s->lookahead != '|'))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -1,72 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_23.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_s115(t_lexer *lexer, t_lexer_state *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 (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 (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(2, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(463, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(168, lexer, s));
if (s->lookahead != 0)
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(2, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(168, lexer, s));
if (s->lookahead != 0)
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -1,75 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_24.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_s120(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
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(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(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(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_advance(364, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
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_s123(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(4, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(443, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(5, lexer, s));
if (s->lookahead != 0)
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(4, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(5, lexer, s));
if (s->lookahead != 0)
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -1,76 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_25.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_s125(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
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(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(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(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(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(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(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(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(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(488, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -1,75 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_26.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_s130(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(173, lexer, s));
if (s->lookahead != 0)
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(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(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(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(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(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(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(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(488, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -1,73 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_27.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_s135(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
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(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(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(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(46, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
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(90, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(450, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(102, lexer, s));
if (s->lookahead != 0)
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(90, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(102, lexer, s));
if (s->lookahead != 0)
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -1,76 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_28.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_s140(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
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(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(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(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(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s143(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(182, lexer, s));
if (s->lookahead != 0)
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(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(488, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -1,73 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_29.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_s145(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
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(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(61, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
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(95, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(471, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(183, lexer, s));
if (s->lookahead != 0)
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(95, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(183, lexer, s));
if (s->lookahead != 0)
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(69, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(472, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(185, lexer, s));
if (s->lookahead != 0)
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -1,70 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_3.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_s15(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(434, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(14, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s16(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
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(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(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(413, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(17, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(445, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(89, lexer, s));
if (s->lookahead != 0)
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(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(89, lexer, s));
if (s->lookahead != 0)
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -1,73 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_30.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_s150(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(69, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(185, lexer, s));
if (s->lookahead != 0)
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(73, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
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(74, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(473, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(190, lexer, s));
if (s->lookahead != 0)
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(74, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(190, lexer, s));
if (s->lookahead != 0)
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(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));
}

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

@ -1,70 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_31.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_s155(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
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(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(77, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
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(78, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(475, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(187, lexer, s));
if (s->lookahead != 0)
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(78, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(187, lexer, s));
if (s->lookahead != 0)
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(82, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(180, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -1,74 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_32.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_s160(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(84, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(476, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(188, lexer, s));
if (s->lookahead != 0)
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(84, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(188, lexer, s));
if (s->lookahead != 0)
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(87, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
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(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 (lex_normal_map164(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
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(488, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -1,112 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_33.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_s165(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map165(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
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 (lex_normal_map166(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
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));
}
bool lex_normal_s167(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map167(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
return (lex_skip(167, 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(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));
}
bool lex_normal_s168(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map168(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
return (lex_skip(168, 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_s169(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map169(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
return (lex_skip(169, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
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(488, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -1,109 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_34.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_s170(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map170(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
return (lex_skip(170, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
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 != '{' && s->lookahead != '|'))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s171(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map171(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
return (lex_skip(171, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(465, 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));
}
bool lex_normal_s172(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map172(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
return (lex_skip(172, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(466, 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));
}
bool lex_normal_s173(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map173(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
return (lex_skip(173, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(467, 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));
}
bool lex_normal_s174(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map174(lexer, s))
return (true);
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 >= '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));
}

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

@ -1,103 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_35.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_s175(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map175(lexer, s))
return (true);
if ((s->lookahead == '\n' || s->lookahead == '\r'))
return (lex_skip(175, 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));
}
bool lex_normal_s176(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map176(lexer, s))
return (true);
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 >= '0' && s->lookahead <= '9'))
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));
}
bool lex_normal_s177(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map177(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(177, 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_s178(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map178(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
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(410, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s179(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map179(lexer, s))
return (true);
if ((s->lookahead == '\n' || s->lookahead == '\r'))
return (lex_skip(179, 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));
}

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

@ -1,101 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_36.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_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(410, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s181(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map181(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(181, 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_s182(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map182(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
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));
}
bool lex_normal_s183(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map183(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
return (lex_skip(183, 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));
}
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 == '\n' || \
s->lookahead == ' '))
return (lex_skip(184, 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));
}

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

@ -1,128 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_37.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_s185(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map185(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
return (lex_skip(185, 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(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));
}
bool lex_normal_s186(t_lexer *lexer, t_lexer_state *s)
{
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));
return (lex_end_state(lexer, s));
}
bool lex_normal_s187(t_lexer *lexer, t_lexer_state *s)
{
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(475, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && 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 (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(476, 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));
}
bool lex_normal_s189(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '"')
return (lex_advance(360, lexer, s));
if (s->lookahead == '#')
return (lex_advance(400, lexer, s));
if (s->lookahead == '\'')
return (lex_advance(197, 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_advance(392, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -1,133 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_38.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_s190(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '"')
return (lex_advance(360, lexer, s));
if (s->lookahead == '#')
return (lex_advance(401, lexer, s));
if (s->lookahead == '$')
return (lex_advance(358, lexer, s));
if (s->lookahead == '\'')
return (lex_advance(197, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(153, lexer, s));
if (s->lookahead == '`')
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(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 != '|'))
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(360, lexer, s));
if (s->lookahead == '#')
return (lex_advance(401, lexer, s));
if (s->lookahead == '$')
return (lex_advance(358, lexer, s));
if (s->lookahead == '\'')
return (lex_advance(197, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(155, lexer, s));
if (s->lookahead == '`')
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(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(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(360, lexer, s));
if (s->lookahead == '#')
return (lex_advance(370, lexer, s));
if (s->lookahead == '$')
return (lex_advance(358, lexer, s));
if (s->lookahead == '\\')
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(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(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_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));
return (lex_end_state(lexer, s));
}
bool lex_normal_s194(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '#')
return (lex_advance(375, lexer, s));
if (s->lookahead == '%')
return (lex_advance(340, lexer, s));
if (s->lookahead == '\\')
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));
return (lex_end_state(lexer, s));
}

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

@ -1,71 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_39.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_s195(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '#')
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_skip(151, lexer, s));
if (s->lookahead == '`')
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_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(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(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(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(305, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -1,71 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_4.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_s20(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
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(416, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(20, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(449, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(101, lexer, s));
if (s->lookahead != 0)
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(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(101, lexer, s));
if (s->lookahead != 0)
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(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(414, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(23, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(448, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(99, lexer, s));
if (s->lookahead != 0)
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -1,57 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_40.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_s200(t_lexer *lexer, t_lexer_state *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(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(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(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 == 'a')
return (lex_advance(205, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -1,50 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_41.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_s205(t_lexer *lexer, t_lexer_state *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 == '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 == '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 == '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 == 'i')
return (lex_advance(207, lexer, s));
if (s->lookahead == 's')
return (lex_advance(206, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -1,50 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_42.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_s210(t_lexer *lexer, t_lexer_state *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 == '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 == '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 == '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 == '|')
return (lex_advance(259, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -1,103 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_43.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_s215(t_lexer *lexer, t_lexer_state *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->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->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->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(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));
return (lex_end_state(lexer, s));
}

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

@ -1,98 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_44.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_s220(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(232, lexer, s));
if (s->lookahead == '\n')
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(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(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(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(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

@ -1,83 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_45.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_s225(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(232, lexer, s));
if (lex_normal_map225(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(225, 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(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(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(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(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(232, lexer, s));
if (lex_normal_map229(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
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));
}

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