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

Updated parser

Browse source
This commit is contained in:
Maix0 2024-06-30 00:32:57 +02:00
parent 66a0625382
commit bdc062b33a
1248 changed files with 93128 additions and 102788 deletions
Download patch file Download diff file Expand all files Collapse all files

245
ast/src/from_node.c
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/06/17 12:41:56 by maiboyer #+# #+# */
/* Updated: 2024/06/29 16:14:11 by maiboyer ### ########.fr */
/* Updated: 2024/06/29 23:18:43 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
@ -447,24 +447,18 @@ void _append_redirection(t_ast_node node, t_ast_node redirection)
ast_free(redirection);
}
t_ast_terminator_kind _select_term(t_const_str input, t_usize term_start_byte, t_usize term_end_byte)
t_ast_terminator_kind _select_term(t_parse_node node)
{
char term_start;
char term_end;
t_symbol symbol;
term_end = '\0';
if (term_end_byte != term_start_byte)
term_end = input[term_end_byte];
term_start = input[term_start_byte];
if (term_start == '&' && term_end == '\0')
symbol = ts_node_grammar_symbol(node);
printf("term_symbol = %hu\n", symbol);
if (symbol == anon_sym_AMP)
return (AST_TERM_FORK);
if (term_start == ';' && term_end == '\0')
if (symbol == anon_sym_SEMI)
return (AST_TERM_SEMI);
if (term_start == ';' && term_end == ';')
if (symbol == anon_sym_SEMI_SEMI)
return (AST_TERM_DOUBLE_SEMI);
if (term_start == '\n')
return (AST_TERM_NEWLINE);
return (AST_TERM_NONE);
}
@ -477,6 +471,7 @@ t_error build_sym_command(t_parse_node self, t_const_str input, t_ast_node *out)
t_error build_sym_command_name(t_parse_node self, t_const_str input, t_ast_node *out);
t_error build_sym_comment(t_parse_node self, t_const_str input, t_ast_node *out);
t_error build_sym_compound_statement(t_parse_node self, t_const_str input, t_ast_node *out);
t_error build_sym_for_statement(t_parse_node self, t_const_str input, t_ast_node *out);
t_error build_sym_list(t_parse_node self, t_const_str input, t_ast_node *out);
t_error build_sym_negated_command(t_parse_node self, t_const_str input, t_ast_node *out);
t_error build_sym_pipeline(t_parse_node self, t_const_str input, t_ast_node *out);
@ -489,6 +484,10 @@ t_error build_sym_variable_assignment(t_parse_node self, t_const_str input, t_as
t_error build_sym_while_statement(t_parse_node self, t_const_str input, t_ast_node *out);
t_error build_sym_word(t_parse_node self, t_const_str input, t_ast_node *out);
t_error build_sym_if_statement(t_parse_node self, t_const_str input, t_ast_node *out);
t_error build_sym_elif_clause(t_parse_node self, t_const_str input, t_ast_node *out);
t_error build_sym_else_clause(t_parse_node self, t_const_str input, t_ast_node *out);
/* FUNCTION THAT ARE NOT DONE */
t_error build_sym_arithmetic_binary_expression(t_parse_node self, t_const_str input, t_ast_node *out);
@ -501,11 +500,6 @@ t_error build_sym_arithmetic_unary_expression(t_parse_node self, t_const_str inp
t_error build_sym_case_statement(t_parse_node self, t_const_str input, t_ast_node *out);
t_error build_sym_case_item(t_parse_node self, t_const_str input, t_ast_node *out);
t_error build_sym_if_statement(t_parse_node self, t_const_str input, t_ast_node *out);
t_error build_sym_elif_clause(t_parse_node self, t_const_str input, t_ast_node *out);
t_error build_sym_else_clause(t_parse_node self, t_const_str input, t_ast_node *out);
t_error build_sym_for_statement(t_parse_node self, t_const_str input, t_ast_node *out);
t_error build_sym_function_definition(t_parse_node self, t_const_str input, t_ast_node *out);
t_error build_sym_arithmetic_expansion(t_parse_node self, t_const_str input, t_ast_node *out);
@ -530,6 +524,117 @@ t_error build_sym_heredoc_start(t_parse_node self, t_const_str input, t_ast_node
#include <stdio.h>
// t_error build_sym_if_statement(t_parse_node self, t_const_str input, t_ast_node *out)
// {
// t_ast_node ret;
// t_ast_node tmp;
// t_usize i;
// t_parse_node child;
//
// (void)(out);
// (void)(input);
// (void)(self);
// if (out == NULL)
// return (ERROR);
// if (ts_node_grammar_symbol(self) != sym_if_statement)
// return (ERROR);
// ret = ast_alloc(AST_IF);
// i = 0;
// while (i < ts_node_child_count(self))
// {
// i++;
// }
// return (*out = ret, NO_ERROR);
// }
// t_error build_sym_elif_clause(t_parse_node self, t_const_str input, t_ast_node *out)
// {
// t_ast_node ret;
// t_ast_node tmp;
// t_usize i;
// t_parse_node child;
//
// (void)(out);
// (void)(input);
// (void)(self);
// if (out == NULL)
// return (ERROR);
// if (ts_node_grammar_symbol(self) != sym_elif_clause)
// return (ERROR);
// ret = ast_alloc(AST_ELIF);
// i = 0;
// while (i < ts_node_child_count(self))
// {
// // if (a)
// i++;
// }
// return (*out = ret, NO_ERROR);
//
// }
// t_error build_sym_else_clause(t_parse_node self, t_const_str input, t_ast_node *out)
// {
// t_ast_node ret;
// t_ast_node tmp;
// t_usize i;
// t_parse_node child;
//
// (void)(out);
// (void)(input);
// (void)(self);
// if (out == NULL)
// return (ERROR);
// if (ts_node_grammar_symbol(self) != sym_else_clause)
// return (ERROR);
// ret = ast_alloc(AST_ELSE);
// i = 0;
// while (i < ts_node_child_count(self))
// {
// i++;
// }
// return (*out = ret, NO_ERROR);
// }
t_error build_sym_for_statement(t_parse_node self, t_const_str input, t_ast_node *out)
{
t_ast_node ret;
t_ast_node tmp;
t_usize i;
(void)(out);
(void)(input);
(void)(self);
if (out == NULL)
return (ERROR);
if (ts_node_grammar_symbol(self) != sym_for_statement)
return (ERROR);
ret = ast_alloc(AST_FOR);
i = 0;
while (i < ts_node_child_count(self))
{
if (!ts_node_is_named(ts_node_child(self, i)) && (i++, true))
continue;
if (ts_node_field_id_for_child(self, i) == field_variable)
{
if (ast_from_node(ts_node_child(self, i), input, &tmp))
return (ast_free(ret), ERROR);
vec_ast_push(&ret->data.for_.do_, tmp);
}
if (ts_node_field_id_for_child(self, i) == field_value)
{
if (ast_from_node(ts_node_child(self, i), input, &tmp))
return (ast_free(ret), ERROR);
vec_ast_push(&ret->data.for_.words, tmp);
}
if (ts_node_field_id_for_child(self, i) == field_body)
{
if (ast_from_node(ts_node_child(self, i), input, &tmp))
return (ast_free(ret), ERROR);
vec_ast_push(&ret->data.for_.do_, tmp);
}
i++;
}
return (*out = ret, NO_ERROR);
}
t_error build_sym_pipeline(t_parse_node self, t_const_str input, t_ast_node *out)
{
@ -546,9 +651,11 @@ t_error build_sym_pipeline(t_parse_node self, t_const_str input, t_ast_node *out
return (ERROR);
ret = ast_alloc(AST_PIPELINE);
i = 0;
while (i < ts_node_named_child_count(self))
while (i < ts_node_child_count(self))
{
if (ast_from_node(ts_node_named_child(self, i), input, &tmp))
if (!ts_node_is_named(ts_node_child(self, i)) && (i++, true))
continue;
if (ast_from_node(ts_node_child(self, i), input, &tmp))
return (ast_free(ret), ERROR);
vec_ast_push(&ret->data.pipeline.statements, tmp);
i++;
@ -572,17 +679,16 @@ t_error build_sym_do_group(t_parse_node self, t_const_str input, t_ast_node *out
return (ERROR);
ret = ast_alloc(AST_COMPOUND_STATEMENT);
i = 0;
while (i < ts_node_named_child_count(self))
while (i < ts_node_child_count(self))
{
if (ts_node_field_id_for_child(self, i) == field_terminator && ret->data.compound_statement.body.len != 0)
{
term = _select_term(input, ts_node_start_byte(ts_node_named_child(self, i)), ts_node_end_byte(ts_node_named_child(self, i)));
term = _select_term(ts_node_child(self, i));
ast_set_term(&ret->data.compound_statement.body.buffer[ret->data.compound_statement.body.len - 1], term);
}
else
{
if (ast_from_node(ts_node_named_child(self, i), input, &tmp))
if (ast_from_node(ts_node_child(self, i), input, &tmp))
return (ast_free(ret), ERROR);
vec_ast_push(&ret->data.compound_statement.body, tmp);
}
@ -606,19 +712,20 @@ t_error build_sym_subshell(t_parse_node self, t_const_str input, t_ast_node *out
if (ts_node_grammar_symbol(self) != sym_subshell)
return (ERROR);
ret = ast_alloc(AST_SUBSHELL);
// ret->data.subshell.body
i = 0;
while (i < ts_node_named_child_count(self))
while (i < ts_node_child_count(self))
{
if (ts_node_field_id_for_child(self, i) == field_terminator && ret->data.subshell.body.len != 0)
{
term = _select_term(input, ts_node_start_byte(ts_node_named_child(self, i)), ts_node_end_byte(ts_node_named_child(self, i)));
term = _select_term(ts_node_child(self, i));
ast_set_term(&ret->data.subshell.body.buffer[ret->data.subshell.body.len - 1], term);
}
else
{
if (ast_from_node(ts_node_named_child(self, i), input, &tmp))
if (!ts_node_is_named(ts_node_child(self, i)) && (i++, true))
continue;
if (ast_from_node(ts_node_child(self, i), input, &tmp))
return (ast_free(ret), ERROR);
vec_ast_push(&ret->data.subshell.body, tmp);
}
@ -642,8 +749,6 @@ t_error build_sym_while_statement(t_parse_node self, t_const_str input, t_ast_no
return (ERROR);
if (ts_node_grammar_symbol(self) != sym_while_statement)
return (ERROR);
if (ts_node_named_child_count(self) != 1)
return (ERROR);
i = 0;
if (ts_node_grammar_symbol(ts_node_child(self, 0)) == anon_sym_until)
ret = ast_alloc(AST_UNTIL);
@ -651,16 +756,18 @@ t_error build_sym_while_statement(t_parse_node self, t_const_str input, t_ast_no
ret = ast_alloc(AST_WHILE);
else
return (ERROR);
while (i < ts_node_named_child_count(self))
while (i < ts_node_child_count(self))
{
child = ts_node_named_child(self, i);
child = ts_node_child(self, i);
if (!ts_node_is_named(child) && (i++, true))
continue;
if (ast_from_node(child, input, &tmp))
return (ast_free(ret), ERROR);
if (ts_node_field_id_for_child(self, i) == field_stmt)
vec_ast_push(&ret->data.while_.condition, tmp);
if (ts_node_field_id_for_child(self, i) == field_terminator)
{
term = _select_term(input, ts_node_start_byte(ts_node_named_child(self, i)), ts_node_end_byte(ts_node_named_child(self, i)));
term = _select_term(ts_node_child(self, i));
ast_set_term(&ret->data.while_.condition.buffer[ret->data.while_.condition.len - 1], term);
}
if (ts_node_field_id_for_child(self, i) == field_body)
@ -683,14 +790,16 @@ t_error build_sym_redirected_statement(t_parse_node self, t_const_str input, t_a
return (ERROR);
if (ts_node_grammar_symbol(self) != sym_negated_command)
return (ERROR);
if (ts_node_named_child_count(self) != 1)
if (ts_node_child_count(self) != 1)
return (ERROR);
i = 0;
if (ast_from_node(ts_node_named_child(self, i++), input, &ret))
if (ast_from_node(ts_node_child(self, i++), input, &ret))
return (ERROR);
while (i < ts_node_named_child_count(self))
while (i < ts_node_child_count(self))
{
if (ast_from_node(ts_node_named_child(self, i++), input, &tmp))
if (!ts_node_is_named(ts_node_child(self, i)) && (i++, true))
continue;
if (ast_from_node(ts_node_child(self, i++), input, &tmp))
return (ast_free(ret), ERROR);
_append_redirection(ret, tmp);
}
@ -711,9 +820,9 @@ t_error build_sym_negated_command(t_parse_node self, t_const_str input, t_ast_no
return (ERROR);
if (ts_node_grammar_symbol(self) != sym_negated_command)
return (ERROR);
if (ts_node_named_child_count(self) != 1)
if (ts_node_child_count(self) != 1)
return (ERROR);
if (ast_from_node(ts_node_named_child(self, 0), input, &ret))
if (ast_from_node(ts_node_child(self, 1), input, &ret))
return (ERROR);
_add_negation(&ret);
return (*out = ret, NO_ERROR);
@ -735,17 +844,19 @@ t_error build_sym_compound_statement(t_parse_node self, t_const_str input, t_ast
return (ERROR);
ret = ast_alloc(AST_COMPOUND_STATEMENT);
i = 0;
while (i < ts_node_named_child_count(self))
while (i < ts_node_child_count(self))
{
if (ts_node_field_id_for_child(self, i) == field_terminator && ret->data.compound_statement.body.len != 0)
{
term = _select_term(input, ts_node_start_byte(ts_node_named_child(self, i)), ts_node_end_byte(ts_node_named_child(self, i)));
term = _select_term(ts_node_child(self, i));
ast_set_term(&ret->data.compound_statement.body.buffer[ret->data.compound_statement.body.len - 1], term);
}
else
{
if (ast_from_node(ts_node_named_child(self, i), input, &tmp))
if (!ts_node_is_named(ts_node_child(self, i)) && (i++, true))
continue;
if (ast_from_node(ts_node_child(self, i), input, &tmp))
return (ast_free(ret), ERROR);
vec_ast_push(&ret->data.compound_statement.body, tmp);
}
@ -771,17 +882,17 @@ t_error build_sym_compound_statement(t_parse_node self, t_const_str input, t_ast
// ret = ast_alloc(AST_SUBSHELL);
// // ret->data.subshell.body
// i = 0;
// while (i < ts_node_named_child_count(self))
// while (i < ts_node_child_count(self))
// {
// if (ts_node_field_id_for_child(self, i) == field_terminator && ret->data.subshell.body.len != 0)
// {
// term = _select_term(input, ts_node_start_byte(ts_node_named_child(self, i)), ts_node_end_byte(ts_node_named_child(self, i)));
// term = _select_term(input, ts_node_start_byte(ts_node_child(self, i)), ts_node_end_byte(ts_node_child(self, i)));
//
// ast_set_term(&ret->data.subshell.body.buffer[ret->data.subshell.body.len - 1], term);
// }
// else
// {
// if (ast_from_node(ts_node_named_child(self, i), input, &tmp))
// if (ast_from_node(ts_node_child(self, i), input, &tmp))
// return (ast_free(ret), ERROR);
// vec_ast_push(&ret->data.subshell.body, tmp);
// }
@ -816,17 +927,17 @@ t_error build_sym_variable_assignment(t_parse_node self, t_const_str input, t_as
return (ERROR);
ret = ast_alloc(AST_VARIABLE_ASSIGNMENT);
// temp_str = str_substring(input, ts_node_start_byte(self), ts_node_end_byte(self) - ts_node_start_byte(self));
if (ts_node_named_child_count(self) >= 1)
if (ts_node_child_count(self) >= 2)
{
temp_ast = ts_node_named_child(self, 0);
temp_ast = ts_node_child(self, 0);
if (ts_node_grammar_symbol(temp_ast) != sym_variable_name)
return (ast_free(ret), ERROR);
ret->data.variable_assignment.name =
str_substring(input, ts_node_start_byte(temp_ast), ts_node_end_byte(temp_ast) - ts_node_start_byte(temp_ast));
}
if (ts_node_named_child_count(self) > 1)
if (ts_node_child_count(self) > 2)
{
if (ast_from_node(ts_node_named_child(self, 1), input, &ret->data.variable_assignment.value))
if (ast_from_node(ts_node_child(self, 2), input, &ret->data.variable_assignment.value))
return (ast_free(ret), ERROR);
}
return (*out = ret, NO_ERROR);
@ -864,9 +975,11 @@ t_error build_sym_string(t_parse_node self, t_const_str input, t_ast_node *out)
ret = ast_alloc(AST_WORD);
ret->data.word.kind = AST_WORD_DOUBLE_QUOTE;
i = 0;
while (i < ts_node_named_child_count(self))
while (i < ts_node_child_count(self))
{
if (ast_from_node(ts_node_named_child(self, i), input, &temp))
if (!ts_node_is_named(ts_node_child(self, i)) && (i++, true))
continue;
if (ast_from_node(ts_node_child(self, i), input, &temp))
return (ast_free(ret), ERROR);
vec_ast_push(&ret->data.word.inner, temp);
i++;
@ -890,9 +1003,9 @@ t_error build_sym_concatenation(t_parse_node self, t_const_str input, t_ast_node
ret = ast_alloc(AST_WORD);
ret->data.word.kind = AST_WORD_NO_QUOTE;
i = 0;
while (i < ts_node_named_child_count(self))
while (i < ts_node_child_count(self))
{
if (ast_from_node(ts_node_named_child(self, i), input, &temp))
if (ast_from_node(ts_node_child(self, i), input, &temp))
return (ast_free(ret), ERROR);
vec_ast_push(&ret->data.word.inner, temp);
i++;
@ -949,18 +1062,18 @@ t_error build_sym_program(t_parse_node self, t_const_str input, t_ast_node *out)
return (ERROR);
ret = ast_alloc(AST_PROGRAM);
i = 0;
while (i < ts_node_named_child_count(self))
while (i < ts_node_child_count(self))
{
temp = NULL;
if (i < ts_node_named_child_count(self) && ts_node_field_id_for_child(self, i) == field_stmt)
if (i < ts_node_child_count(self) && ts_node_field_id_for_child(self, i) == field_stmt)
{
if (ast_from_node(ts_node_named_child(self, i), input, &temp))
if (ast_from_node(ts_node_child(self, i), input, &temp))
return (ast_free(ret), ERROR);
i++;
}
if (i < ts_node_named_child_count(self) && ts_node_field_id_for_child(self, i) == field_terminator)
if (i < ts_node_child_count(self) && ts_node_field_id_for_child(self, i) == field_terminator)
{
printf("%s\n", (ts_node_grammar_type(ts_node_named_child(self, i))));
printf("%s\n", (ts_node_grammar_type(ts_node_child(self, i))));
i++;
}
if (temp == NULL)
@ -976,7 +1089,7 @@ t_error build_sym_command_name(t_parse_node self, t_const_str input, t_ast_node
return (ERROR);
if (ts_node_grammar_symbol(self) != sym_command_name)
return (ERROR);
return (ast_from_node(ts_node_named_child(self, 0), input, out));
return (ast_from_node(ts_node_child(self, 0), input, out));
}
t_error build_sym_word(t_parse_node self, t_const_str input, t_ast_node *out)
@ -1013,12 +1126,12 @@ t_error build_sym_command(t_parse_node self, t_const_str input, t_ast_node *out)
ret = ast_alloc(AST_COMMAND);
i = 0;
vec_idx = 0;
while (i < ts_node_named_child_count(self))
while (i < ts_node_child_count(self))
{
temp = NULL;
if (ts_node_field_id_for_child(self, i) == field_name)
vec_idx++;
if (ast_from_node(ts_node_named_child(self, i), input, &temp))
if (ast_from_node(ts_node_child(self, i), input, &temp))
return (ast_free(ret), ERROR);
vec_ast_push(_vec_command(&ret->data.command, vec_idx), temp);
i++;
@ -1039,16 +1152,16 @@ t_error build_sym_list(t_parse_node self, t_const_str input, t_ast_node *out)
ret = ast_alloc(AST_LIST);
i = 0;
output = &ret->data.list.left;
while (i < ts_node_named_child_count(self))
while (i < ts_node_child_count(self))
{
if (ts_node_field_id_for_child(self, i) == field_cmd)
{
if (ast_from_node(ts_node_named_child(self, i), input, output))
if (ast_from_node(ts_node_child(self, i), input, output))
return (ast_free(ret), ERROR);
}
else if (ts_node_field_id_for_child(self, i) == field_op)
{
temp = ts_node_grammar_symbol(ts_node_named_child(self, i));
temp = ts_node_grammar_symbol(ts_node_child(self, i));
if (temp == anon_sym_PIPE_PIPE)
ret->data.list.op = AST_LIST_OR;
if (temp == anon_sym_AMP_AMP)

66
parser/Filelist.mk
View file

@ -174,7 +174,6 @@ lex_modes/lex_modes_20 \
lex_modes/lex_modes_21 \
lex_modes/lex_modes_22 \
lex_modes/lex_modes_23 \
lex_modes/lex_modes_24 \
non_terminal_alias_map/non_terminal_alias_map_0 \
parse_actions_entries/parse_actions_entries_0 \
parse_actions_entries/parse_actions_entries_1 \
@ -222,11 +221,6 @@ parse_actions_entries/parse_actions_entries_42 \
parse_actions_entries/parse_actions_entries_43 \
parse_actions_entries/parse_actions_entries_44 \
parse_actions_entries/parse_actions_entries_45 \
parse_actions_entries/parse_actions_entries_46 \
parse_actions_entries/parse_actions_entries_47 \
parse_actions_entries/parse_actions_entries_48 \
parse_actions_entries/parse_actions_entries_49 \
parse_actions_entries/parse_actions_entries_50 \
parse_table/parse_table_0 \
parse_table/parse_table_1 \
primary_state_ids/primary_state_ids_0 \
@ -253,7 +247,6 @@ primary_state_ids/primary_state_ids_20 \
primary_state_ids/primary_state_ids_21 \
primary_state_ids/primary_state_ids_22 \
primary_state_ids/primary_state_ids_23 \
primary_state_ids/primary_state_ids_24 \
small_parse_table/small_parse_table_0 \
small_parse_table/small_parse_table_1 \
small_parse_table/small_parse_table_2 \
@ -1221,64 +1214,6 @@ small_parse_table/small_parse_table_963 \
small_parse_table/small_parse_table_964 \
small_parse_table/small_parse_table_965 \
small_parse_table/small_parse_table_966 \
small_parse_table/small_parse_table_967 \
small_parse_table/small_parse_table_968 \
small_parse_table/small_parse_table_969 \
small_parse_table/small_parse_table_970 \
small_parse_table/small_parse_table_971 \
small_parse_table/small_parse_table_972 \
small_parse_table/small_parse_table_973 \
small_parse_table/small_parse_table_974 \
small_parse_table/small_parse_table_975 \
small_parse_table/small_parse_table_976 \
small_parse_table/small_parse_table_977 \
small_parse_table/small_parse_table_978 \
small_parse_table/small_parse_table_979 \
small_parse_table/small_parse_table_980 \
small_parse_table/small_parse_table_981 \
small_parse_table/small_parse_table_982 \
small_parse_table/small_parse_table_983 \
small_parse_table/small_parse_table_984 \
small_parse_table/small_parse_table_985 \
small_parse_table/small_parse_table_986 \
small_parse_table/small_parse_table_987 \
small_parse_table/small_parse_table_988 \
small_parse_table/small_parse_table_989 \
small_parse_table/small_parse_table_990 \
small_parse_table/small_parse_table_991 \
small_parse_table/small_parse_table_992 \
small_parse_table/small_parse_table_993 \
small_parse_table/small_parse_table_994 \
small_parse_table/small_parse_table_995 \
small_parse_table/small_parse_table_996 \
small_parse_table/small_parse_table_997 \
small_parse_table/small_parse_table_998 \
small_parse_table/small_parse_table_999 \
small_parse_table/small_parse_table_1000 \
small_parse_table/small_parse_table_1001 \
small_parse_table/small_parse_table_1002 \
small_parse_table/small_parse_table_1003 \
small_parse_table/small_parse_table_1004 \
small_parse_table/small_parse_table_1005 \
small_parse_table/small_parse_table_1006 \
small_parse_table/small_parse_table_1007 \
small_parse_table/small_parse_table_1008 \
small_parse_table/small_parse_table_1009 \
small_parse_table/small_parse_table_1010 \
small_parse_table/small_parse_table_1011 \
small_parse_table/small_parse_table_1012 \
small_parse_table/small_parse_table_1013 \
small_parse_table/small_parse_table_1014 \
small_parse_table/small_parse_table_1015 \
small_parse_table/small_parse_table_1016 \
small_parse_table/small_parse_table_1017 \
small_parse_table/small_parse_table_1018 \
small_parse_table/small_parse_table_1019 \
small_parse_table/small_parse_table_1020 \
small_parse_table/small_parse_table_1021 \
small_parse_table/small_parse_table_1022 \
small_parse_table/small_parse_table_1023 \
small_parse_table/small_parse_table_1024 \
small_parse_table_map/small_parse_table_map_0 \
small_parse_table_map/small_parse_table_map_1 \
small_parse_table_map/small_parse_table_map_2 \
@ -1303,7 +1238,6 @@ small_parse_table_map/small_parse_table_map_20 \
small_parse_table_map/small_parse_table_map_21 \
small_parse_table_map/small_parse_table_map_22 \
small_parse_table_map/small_parse_table_map_23 \
small_parse_table_map/small_parse_table_map_24 \
symbols_metadata/symbols_metadata_0 \
symbols_metadata/symbols_metadata_1 \
symbols_names/symbols_names_0 \

65
parser/nsrc/node.c
View file

@ -1,6 +1,7 @@
#include "./language.h"
#include "./subtree.h"
#include "./tree.h"
#include "me/str/str.h"
#include <stdbool.h>
typedef struct NodeChildIterator
@ -738,59 +739,6 @@ static inline const char *ts_node__field_name_from_language(TSNode self, uint32_
return NULL;
}
TSFieldId ts_node_field_id_for_child(TSNode self, uint32_t child_index)
{
TSNode result = self;
bool did_descend = true;
TSFieldId inherited_field_name = 0;
while (did_descend)
{
did_descend = false;
TSNode child;
uint32_t index = 0;
NodeChildIterator iterator = ts_node_iterate_children(&result);
while (ts_node_child_iterator_next(&iterator, &child))
{
if (ts_node__is_relevant(child, true))
{
if (index == child_index)
{
if (ts_node_is_extra(child))
{
return 0;
}
TSFieldId field_name = ts_node__field_id_from_language(result, iterator.structural_child_index - 1);
if (field_name)
return field_name;
return inherited_field_name;
}
index++;
}
else
{
uint32_t grandchild_index = child_index - index;
uint32_t grandchild_count = ts_node__relevant_child_count(child, true);
if (grandchild_index < grandchild_count)
{
TSFieldId field_name = ts_node__field_id_from_language(result, iterator.structural_child_index - 1);
if (field_name)
inherited_field_name = field_name;
did_descend = true;
result = child;
child_index = grandchild_index;
break;
}
index += grandchild_count;
}
}
}
return 0;
}
const char *ts_node_field_name_for_child(TSNode self, uint32_t child_index)
{
TSNode result = self;
@ -876,6 +824,17 @@ uint32_t ts_node_named_child_count(TSNode self)
}
}
TSFieldId ts_node_field_id_for_child(TSNode self, uint32_t child_index)
{
const char *field_name;
field_name = ts_node_field_name_for_child(self, child_index);
if (field_name != NULL)
return (ts_language_field_id_for_name(ts_node_language(self), field_name, str_len(field_name)));
return 0;
}
TSNode ts_node_next_sibling(TSNode self)
{
return ts_node__next_sibling(self, true);

116
parser/parse_types.h
View file

@ -6,41 +6,44 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/24 23:01:45 by maiboyer #+# #+# */
/* Updated: 2024/05/02 14:37:53 by maiboyer ### ########.fr */
/* Updated: 2024/06/29 21:11:19 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef PARSE_TYPES_H
# define PARSE_TYPES_H
#define PARSE_TYPES_H
# include <stdbool.h>
# include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
# include "me/types.h"
# include "parser/types/types_char_range.h"
# include "parser/types/types_field_id.h"
# include "parser/types/types_field_map_entry.h"
# include "parser/types/types_field_map_slice.h"
# include "parser/types/types_language.h"
# include "parser/types/types_lex_modes.h"
# include "parser/types/types_lexer.h"
# include "parser/types/types_lexer_state.h"
# include "parser/types/types_parse_action_entry.h"
# include "parser/types/types_parse_action_type.h"
# include "parser/types/types_parse_actions.h"
# include "parser/types/types_parser_range.h"
# include "parser/types/types_point.h"
# include "parser/types/types_scanner.h"
# include "parser/types/types_state_id.h"
# include "parser/types/types_symbol.h"
# include "parser/types/types_symbol_metadata.h"
#include "./nsrc/api.h"
#include "./nsrc/lexer.h"
#include "./nsrc/parser.h"
#include "me/types.h"
#include "parser/types/types_lexer_state.h"
typedef TSSymbolMetadata t_symbol_metadata;
typedef TSSymbol t_symbol;
typedef TSStateId t_state_id;
typedef TSFieldId t_field_id;
typedef TSLexer t_lexer;
typedef TSFieldMapSlice t_field_map_slice;
typedef TSFieldMapEntry t_field_map_entry;
typedef TSParseActionEntry t_parse_action_entry;
typedef TSLexMode t_lex_modes;
typedef TSCharacterRange t_char_range;
#define ActionTypeShift TSParseActionTypeShift
#define ActionTypeReduce TSParseActionTypeReduce
#define ActionTypeRecover TSParseActionTypeRecover
#define ActionTypeAccept TSParseActionTypeAccept
#ifndef inline
#define inline __inline__
# define inline __inline__
#endif
static inline bool lex_skip(t_state_id state_value, t_lexer *lexer,
t_lexer_state *s)
static inline bool lex_skip(t_state_id state_value, t_lexer *lexer, t_lexer_state *s)
{
(void)(lexer);
s->skip = true;
@ -48,16 +51,14 @@ static inline bool lex_skip(t_state_id state_value, t_lexer *lexer,
return (true);
};
static inline bool lex_advance(t_state_id state_value, t_lexer *lexer,
t_lexer_state *s)
static inline bool lex_advance(t_state_id state_value, t_lexer *lexer, t_lexer_state *s)
{
(void)(lexer);
s->state = state_value;
return (true);
};
static inline bool lex_accept_token(t_symbol symbol_value, t_lexer *lexer,
t_lexer_state *s)
static inline bool lex_accept_token(t_symbol symbol_value, t_lexer *lexer, t_lexer_state *s)
{
s->result = true;
lexer->result_symbol = symbol_value;
@ -65,15 +66,14 @@ static inline bool lex_accept_token(t_symbol symbol_value, t_lexer *lexer,
return (true);
};
static inline bool lex_end_state(t_lexer *lexer, t_lexer_state *s)
static inline bool lex_end_state(t_lexer *lexer, t_lexer_state *s)
{
(void)(lexer);
(void)(s);
return (false);
};
static inline t_field_map_entry fmap_entry(t_field_id field_id,
uint8_t child_index, bool inherited)
static inline t_field_map_entry fmap_entry(t_field_id field_id, uint8_t child_index, bool inherited)
{
return ((t_field_map_entry){
.field_id = field_id,
@ -82,7 +82,7 @@ static inline t_field_map_entry fmap_entry(t_field_id field_id,
});
};
static inline t_field_map_slice fmap_slice(t_u16 index, t_u16 length)
static inline t_field_map_slice fmap_slice(t_u16 index, t_u16 length)
{
return ((t_field_map_slice){
.index = index,
@ -90,8 +90,7 @@ static inline t_field_map_slice fmap_slice(t_u16 index, t_u16 length)
});
};
static inline t_symbol_metadata sym_metadata(bool visible, bool named,
bool supertype)
static inline t_symbol_metadata sym_metadata(bool visible, bool named, bool supertype)
{
return ((t_symbol_metadata){
.visible = visible,
@ -100,13 +99,12 @@ static inline t_symbol_metadata sym_metadata(bool visible, bool named,
});
};
static inline t_parse_action_entry entry(uint8_t count, bool reusable)
static inline t_parse_action_entry entry(uint8_t count, bool reusable)
{
return ((t_parse_action_entry){.entry = {.count = count,
.reusable = reusable}});
return ((t_parse_action_entry){.entry = {.count = count, .reusable = reusable}});
};
static inline t_parse_action_entry shift(t_state_id state_value)
static inline t_parse_action_entry shift(t_state_id state_value)
{
return ((t_parse_action_entry){{.shift = {
.type = ActionTypeShift,
@ -114,22 +112,19 @@ static inline t_parse_action_entry shift(t_state_id state_value)
}}});
};
static inline t_parse_action_entry shift_repeat(t_state_id state_value)
static inline t_parse_action_entry shift_repeat(t_state_id state_value)
{
return ((t_parse_action_entry){{.shift = {.type = ActionTypeShift,
.state = (state_value), .repetition = true}}});
return ((t_parse_action_entry){{.shift = {.type = ActionTypeShift, .state = (state_value), .repetition = true}}});
};
static inline t_parse_action_entry shift_extra(void)
static inline t_parse_action_entry shift_extra(void)
{
return ((t_parse_action_entry){{.shift = {.type = ActionTypeShift,
.extra = true}}});
return ((t_parse_action_entry){{.shift = {.type = ActionTypeShift, .extra = true}}});
};
static inline t_parse_action_entry reduce(
static inline t_parse_action_entry reduce(
t_symbol symbol, uint8_t child_count, int16_t dynamic_precedence,
t_u16 production_id)
t_symbol symbol, uint8_t child_count, int16_t dynamic_precedence, t_u16 production_id)
{
return ((t_parse_action_entry){{.reduce = {
.type = ActionTypeReduce,
@ -140,25 +135,25 @@ static inline t_parse_action_entry reduce(
}}});
};
static inline t_parse_action_entry recover(void)
static inline t_parse_action_entry recover(void)
{
return ((t_parse_action_entry){{.type = ActionTypeRecover}});
};
static inline t_parse_action_entry accept(void)
static inline t_parse_action_entry accept(void)
{
return ((t_parse_action_entry){{.type = ActionTypeAccept}});
};
static inline bool set_contains(t_char_range *ranges, t_u32 len,
int32_t lookahead)
/*
static inline bool set_contains(t_char_range *ranges, t_u32 len, int32_t lookahead)
{
t_u32 index = 0;
t_u32 size = len - index;
while (size > 1)
{
t_u32 half_size = size / 2;
t_u32 mid_index = index + half_size;
t_u32 half_size = size / 2;
t_u32 mid_index = index + half_size;
t_char_range *range = &ranges[mid_index];
if (lookahead >= range->start && lookahead <= range->end)
{
@ -173,9 +168,9 @@ static inline bool set_contains(t_char_range *ranges, t_u32 len,
t_char_range *range = &ranges[index];
return (lookahead >= range->start && lookahead <= range->end);
};
*/
static inline bool advance_map_inner(t_u32 *map, t_u32 elems, t_lexer *l,
t_lexer_state *s)
static inline bool advance_map_inner(t_u32 *map, t_u32 elems, t_lexer *l, t_lexer_state *s)
{
t_u32 i;
@ -193,8 +188,7 @@ static inline bool advance_map_inner(t_u32 *map, t_u32 elems, t_lexer *l,
return (false);
};
static inline t_lex_modes lex_mode_external(t_u16 lex_state,
t_u16 ext_lex_state)
static inline t_lex_modes lex_mode_external(t_u16 lex_state, t_u16 ext_lex_state)
{
return ((t_lex_modes){
.lex_state = lex_state,
@ -202,19 +196,19 @@ static inline t_lex_modes lex_mode_external(t_u16 lex_state,
});
};
static inline t_lex_modes lex_mode_normal(t_u16 lex_state)
static inline t_lex_modes lex_mode_normal(t_u16 lex_state)
{
return ((t_lex_modes){
.lex_state = lex_state,
});
};
static inline t_u16 actions(t_u16 val)
static inline t_u16 actions(t_u16 val)
{
return (val);
};
static inline t_u16 state(t_u16 val)
static inline t_u16 state(t_u16 val)
{
return (val);
};

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

@ -16,12 +16,10 @@ void alias_sequences_0(t_alias_sequences_array *v)
{
v->a[8][1] = anon_sym_POUND;
v->a[9][0] = anon_sym_POUND;
v->a[10][1] = alias_sym_terminator;
v->a[12][0] = anon_sym_DOLLAR;
v->a[23][0] = sym__immediate_double_hash;
v->a[25][1] = sym_string_content;
v->a[27][0] = anon_sym_POUND;
v->a[32][2] = alias_sym_terminator;
v->a[35][1] = alias_sym_statements;
v->a[38][1] = sym__immediate_double_hash;
v->a[39][2] = sym_string_content;
@ -34,20 +32,20 @@ void alias_sequences_0(t_alias_sequences_array *v)
v->a[46][1] = alias_sym_statements;
v->a[51][1] = alias_sym_statements;
v->a[51][3] = alias_sym_statements;
v->a[52][1] = alias_sym_statements;
v->a[52][3] = alias_sym_statements;
alias_sequences_1(v);
}
void alias_sequences_1(t_alias_sequences_array *v)
{
v->a[52][1] = alias_sym_statements;
v->a[52][3] = alias_sym_statements;
v->a[53][1] = alias_sym_statements;
v->a[55][2] = alias_sym_statements;
v->a[54][2] = alias_sym_statements;
v->a[62][1] = alias_sym_statements;
v->a[62][3] = alias_sym_statements;
v->a[63][3] = alias_sym_statements;
v->a[64][3] = alias_sym_statements;
v->a[65][3] = alias_sym_statements;
v->a[66][3] = alias_sym_statements;
v->a[72][4] = alias_sym_statements;
v->a[73][4] = alias_sym_statements;
v->a[74][4] = alias_sym_statements;

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

@ -48,6 +48,7 @@ void external_scanner_states_1(t_external_scanner_states_array *v)
v->a[3][ts_external_token_LT_LT_DASH] = true;
v->a[3][ts_external_token_heredoc_redirect_token1] = true;
v->a[3][ts_external_token_LPAREN] = true;
v->a[3][ts_external_token_esac] = true;
v->a[4][ts_external_token_file_descriptor] = true;
v->a[4][ts_external_token_variable_name] = true;
v->a[4][ts_external_token__bare_dollar] = true;
@ -55,7 +56,6 @@ void external_scanner_states_1(t_external_scanner_states_array *v)
v->a[4][ts_external_token_LT_LT_DASH] = true;
v->a[4][ts_external_token_heredoc_redirect_token1] = true;
v->a[4][ts_external_token_LPAREN] = true;
v->a[4][ts_external_token_esac] = true;
v->a[5][ts_external_token_file_descriptor] = true;
v->a[5][ts_external_token_variable_name] = true;
v->a[5][ts_external_token__bare_dollar] = true;
@ -96,29 +96,29 @@ void external_scanner_states_3(t_external_scanner_states_array *v)
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_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__bare_dollar] = 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_heredoc_redirect_token1] = 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__bare_dollar] = 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_heredoc_redirect_token1] = true;
v->a[11][ts_external_token_esac] = true;
v->a[12][ts_external_token_file_descriptor] = true;
external_scanner_states_4(v);
}
void external_scanner_states_4(t_external_scanner_states_array *v)
{
v->a[12][ts_external_token_file_descriptor] = true;
v->a[12][ts_external_token__bare_dollar] = true;
v->a[12][ts_external_token_LT_LT] = true;
v->a[12][ts_external_token_LT_LT_DASH] = true;
v->a[12][ts_external_token_heredoc_redirect_token1] = true;
v->a[12][ts_external_token_esac] = true;
v->a[13][ts_external_token_file_descriptor] = true;
v->a[13][ts_external_token_variable_name] = true;
v->a[13][ts_external_token__bare_dollar] = true;
@ -129,11 +129,11 @@ void external_scanner_states_4(t_external_scanner_states_array *v)
v->a[14][ts_external_token_LT_LT] = true;
v->a[14][ts_external_token_LT_LT_DASH] = true;
v->a[14][ts_external_token_heredoc_redirect_token1] = true;
v->a[14][ts_external_token_esac] = true;
v->a[15][ts_external_token_file_descriptor] = true;
v->a[15][ts_external_token_LT_LT] = true;
v->a[15][ts_external_token_LT_LT_DASH] = true;
v->a[15][ts_external_token_heredoc_redirect_token1] = true;
v->a[15][ts_external_token_esac] = true;
external_scanner_states_5(v);
}

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

@ -20,11 +20,11 @@ void external_scanner_states_5(t_external_scanner_states_array *v)
v->a[16][ts_external_token_LT_LT] = true;
v->a[16][ts_external_token_LT_LT_DASH] = 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_LT_LT] = true;
v->a[17][ts_external_token_LT_LT_DASH] = true;
v->a[17][ts_external_token_heredoc_redirect_token1] = true;
v->a[18][ts_external_token_file_descriptor] = true;
v->a[18][ts_external_token_heredoc_redirect_token1] = true;
v->a[18][ts_external_token_variable_name] = true;
v->a[18][ts_external_token_LT_LT] = true;
v->a[18][ts_external_token_LT_LT_DASH] = true;
v->a[19][ts_external_token_file_descriptor] = true;
v->a[19][ts_external_token__concat] = true;
v->a[19][ts_external_token__bare_dollar] = true;
@ -33,44 +33,48 @@ void external_scanner_states_5(t_external_scanner_states_array *v)
v->a[19][ts_external_token_heredoc_redirect_token1] = true;
v->a[19][ts_external_token_LPAREN] = true;
v->a[20][ts_external_token_file_descriptor] = true;
v->a[20][ts_external_token__concat] = true;
v->a[20][ts_external_token__bare_dollar] = true;
external_scanner_states_6(v);
}
void external_scanner_states_6(t_external_scanner_states_array *v)
{
v->a[20][ts_external_token__bare_dollar] = true;
v->a[20][ts_external_token_LT_LT] = true;
v->a[20][ts_external_token_LT_LT_DASH] = true;
v->a[20][ts_external_token_heredoc_redirect_token1] = true;
v->a[20][ts_external_token_LPAREN] = true;
v->a[20][ts_external_token_esac] = true;
v->a[21][ts_external_token_file_descriptor] = true;
v->a[21][ts_external_token__concat] = true;
v->a[21][ts_external_token__bare_dollar] = true;
v->a[21][ts_external_token_LT_LT] = true;
v->a[21][ts_external_token_LT_LT_DASH] = true;
v->a[21][ts_external_token_heredoc_redirect_token1] = true;
v->a[21][ts_external_token_LPAREN] = true;
v->a[21][ts_external_token_esac] = true;
v->a[22][ts_external_token_file_descriptor] = true;
v->a[22][ts_external_token__concat] = true;
v->a[22][ts_external_token__bare_dollar] = true;
v->a[22][ts_external_token_LT_LT] = true;
v->a[22][ts_external_token_LT_LT_DASH] = true;
v->a[22][ts_external_token_heredoc_redirect_token1] = true;
v->a[23][ts_external_token_file_descriptor] = true;
v->a[23][ts_external_token__concat] = true;
v->a[23][ts_external_token_variable_name] = true;
v->a[23][ts_external_token_LT_LT] = true;
v->a[23][ts_external_token_LT_LT_DASH] = true;
v->a[23][ts_external_token_heredoc_redirect_token1] = true;
v->a[24][ts_external_token_file_descriptor] = true;
v->a[24][ts_external_token__concat] = true;
external_scanner_states_7(v);
}
void external_scanner_states_7(t_external_scanner_states_array *v)
{
v->a[24][ts_external_token__bare_dollar] = true;
v->a[23][ts_external_token_LT_LT] = true;
v->a[23][ts_external_token_LT_LT_DASH] = true;
v->a[23][ts_external_token_heredoc_redirect_token1] = true;
v->a[24][ts_external_token_file_descriptor] = true;
v->a[24][ts_external_token__concat] = true;
v->a[24][ts_external_token_variable_name] = true;
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[25][ts_external_token_file_descriptor] = true;
v->a[25][ts_external_token_variable_name] = true;
v->a[25][ts_external_token_heredoc_redirect_token1] = true;
v->a[24][ts_external_token_esac] = true;
v->a[25][ts_external_token_LT_LT] = true;
v->a[26][ts_external_token_file_descriptor] = true;
v->a[26][ts_external_token__concat] = true;
v->a[26][ts_external_token__bare_dollar] = true;
@ -79,22 +83,19 @@ void external_scanner_states_7(t_external_scanner_states_array *v)
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__concat] = true;
v->a[27][ts_external_token_variable_name] = true;
v->a[27][ts_external_token_LT_LT] = true;
v->a[27][ts_external_token_LT_LT_DASH] = true;
v->a[27][ts_external_token_heredoc_redirect_token1] = true;
external_scanner_states_8(v);
}
void external_scanner_states_8(t_external_scanner_states_array *v)
{
v->a[27][ts_external_token_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__concat] = true;
v->a[28][ts_external_token_LT_LT] = true;
v->a[28][ts_external_token_LT_LT_DASH] = true;
v->a[28][ts_external_token_heredoc_redirect_token1] = true;
v->a[28][ts_external_token_esac] = true;
v->a[29][ts_external_token_file_descriptor] = true;
v->a[29][ts_external_token__bare_dollar] = true;
v->a[29][ts_external_token_LT_LT] = true;
@ -104,7 +105,6 @@ void external_scanner_states_8(t_external_scanner_states_array *v)
v->a[30][ts_external_token_LT_LT] = true;
v->a[30][ts_external_token_LT_LT_DASH] = true;
v->a[30][ts_external_token_heredoc_redirect_token1] = true;
v->a[30][ts_external_token_esac] = true;
v->a[31][ts_external_token_file_descriptor] = true;
v->a[31][ts_external_token_LT_LT] = true;
v->a[31][ts_external_token_LT_LT_DASH] = true;

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

@ -21,13 +21,13 @@ void external_scanner_states_10(t_external_scanner_states_array *v)
v->a[37][ts_external_token_LT_LT_DASH] = true;
v->a[38][ts_external_token_variable_name] = true;
v->a[38][ts_external_token_LPAREN] = true;
v->a[39][ts_external_token_file_descriptor] = true;
v->a[39][ts_external_token__concat] = true;
v->a[39][ts_external_token_extglob_pattern] = true;
v->a[39][ts_external_token_heredoc_redirect_token1] = true;
v->a[40][ts_external_token_extglob_pattern] = true;
v->a[39][ts_external_token_LPAREN] = true;
v->a[39][ts_external_token_esac] = true;
v->a[40][ts_external_token_file_descriptor] = true;
v->a[40][ts_external_token__concat] = true;
v->a[40][ts_external_token_heredoc_redirect_token1] = true;
v->a[40][ts_external_token_LPAREN] = true;
v->a[40][ts_external_token_esac] = true;
v->a[41][ts_external_token_file_descriptor] = true;
v->a[41][ts_external_token__concat] = true;
v->a[41][ts_external_token_variable_name] = true;

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

@ -30,21 +30,21 @@ void field_map_entries_5(t_field_map_entries_array *v)
v->a[113] = fmap_entry(field_else, 4, false);
v->a[114] = fmap_entry(field_stmt, 1, true);
v->a[115] = fmap_entry(field_terminator, 1, true);
v->a[116] = fmap_entry(field_body, 4, true);
v->a[117] = fmap_entry(field_cases, 4, false);
v->a[118] = fmap_entry(field_value, 1, false);
v->a[119] = fmap_entry(field_value, 4, true);
v->a[116] = fmap_entry(field_body, 2, false);
v->a[117] = fmap_entry(field_stmt, 2, true);
v->a[118] = fmap_entry(field_terminator, 2, true);
v->a[119] = fmap_entry(field_value, 0, false);
field_map_entries_6(v);
}
void field_map_entries_6(t_field_map_entries_array *v)
{
v->a[120] = fmap_entry(field_body, 2, false);
v->a[121] = fmap_entry(field_stmt, 2, true);
v->a[122] = fmap_entry(field_terminator, 2, true);
v->a[123] = fmap_entry(field_value, 0, false);
v->a[124] = fmap_entry(field_value, 0, true);
v->a[125] = fmap_entry(field_value, 1, true);
v->a[120] = fmap_entry(field_value, 0, true);
v->a[121] = fmap_entry(field_value, 1, true);
v->a[122] = fmap_entry(field_body, 4, true);
v->a[123] = fmap_entry(field_cases, 4, false);
v->a[124] = fmap_entry(field_value, 1, false);
v->a[125] = fmap_entry(field_value, 4, true);
v->a[126] = fmap_entry(field_body, 4, true);
v->a[127] = fmap_entry(field_cases, 3, true);
v->a[128] = fmap_entry(field_cases, 4, false);
@ -77,25 +77,25 @@ void field_map_entries_7(t_field_map_entries_array *v)
v->a[150] = fmap_entry(field_stmt, 3, true);
v->a[151] = fmap_entry(field_terminator, 3, true);
v->a[152] = fmap_entry(field_value, 1, false);
v->a[153] = fmap_entry(field_body, 5, true);
v->a[154] = fmap_entry(field_cases, 4, true);
v->a[155] = fmap_entry(field_cases, 5, false);
v->a[156] = fmap_entry(field_value, 1, false);
v->a[157] = fmap_entry(field_value, 5, true);
v->a[158] = fmap_entry(field_body, 3, false);
v->a[159] = fmap_entry(field_stmt, 3, true);
v->a[153] = fmap_entry(field_body, 3, false);
v->a[154] = fmap_entry(field_stmt, 3, true);
v->a[155] = fmap_entry(field_terminator, 3, true);
v->a[156] = fmap_entry(field_value, 0, false);
v->a[157] = fmap_entry(field_body, 3, false);
v->a[158] = fmap_entry(field_stmt, 3, true);
v->a[159] = fmap_entry(field_terminator, 3, true);
field_map_entries_8(v);
}
void field_map_entries_8(t_field_map_entries_array *v)
{
v->a[160] = fmap_entry(field_terminator, 3, true);
v->a[161] = fmap_entry(field_value, 0, false);
v->a[162] = fmap_entry(field_body, 3, false);
v->a[163] = fmap_entry(field_stmt, 3, true);
v->a[164] = fmap_entry(field_terminator, 3, true);
v->a[165] = fmap_entry(field_value, 0, false);
v->a[166] = fmap_entry(field_value, 1, true);
v->a[160] = fmap_entry(field_value, 0, false);
v->a[161] = fmap_entry(field_value, 1, true);
v->a[162] = fmap_entry(field_body, 5, true);
v->a[163] = fmap_entry(field_cases, 4, true);
v->a[164] = fmap_entry(field_cases, 5, false);
v->a[165] = fmap_entry(field_value, 1, false);
v->a[166] = fmap_entry(field_value, 5, true);
v->a[167] = fmap_entry(field_body, 5, true);
v->a[168] = fmap_entry(field_cases, 5, false);
v->a[169] = fmap_entry(field_value, 1, false);

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

@ -73,8 +73,8 @@ void field_map_slices_2(t_field_map_slices_array *v)
v->a[52] = fmap_slice(104, 7);
v->a[53] = fmap_slice(111, 5);
v->a[54] = fmap_slice(116, 4);
v->a[55] = fmap_slice(120, 4);
v->a[56] = fmap_slice(124, 2);
v->a[55] = fmap_slice(120, 2);
v->a[56] = fmap_slice(122, 4);
v->a[57] = fmap_slice(126, 5);
v->a[58] = fmap_slice(131, 3);
v->a[59] = fmap_slice(134, 3);
@ -82,8 +82,8 @@ void field_map_slices_2(t_field_map_slices_array *v)
v->a[61] = fmap_slice(139, 2);
v->a[62] = fmap_slice(141, 8);
v->a[63] = fmap_slice(149, 4);
v->a[64] = fmap_slice(153, 5);
v->a[65] = fmap_slice(158, 4);
v->a[64] = fmap_slice(153, 4);
v->a[65] = fmap_slice(157, 5);
field_map_slices_3(v);
}

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

@ -14,10 +14,10 @@
# define CONSTANTS_H
# define LANGUAGE_VERSION 14
# define STATE_COUNT 2485
# define STATE_COUNT 2340
# define LARGE_STATE_COUNT 2
# define SYMBOL_COUNT 182
# define ALIAS_COUNT 2
# define SYMBOL_COUNT 183
# define ALIAS_COUNT 1
# define TOKEN_COUNT 115
# define EXTERNAL_TOKEN_COUNT 20
# define FIELD_COUNT 20

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

@ -178,25 +178,25 @@ enum e_symbols {
sym__concatenation_in_expansion = 162,
sym_command_substitution = 163,
sym__extglob_blob = 164,
aux_sym__statements_repeat1 = 165,
aux_sym_redirected_statement_repeat1 = 166,
aux_sym_redirected_statement_repeat2 = 167,
aux_sym_for_statement_repeat1 = 168,
aux_sym_if_statement_repeat1 = 169,
aux_sym_case_statement_repeat1 = 170,
aux_sym__case_item_last_repeat1 = 171,
aux_sym__case_item_last_repeat2 = 172,
aux_sym_pipeline_repeat1 = 173,
aux_sym_command_repeat1 = 174,
aux_sym_command_repeat2 = 175,
aux_sym__variable_assignments_repeat1 = 176,
aux_sym_heredoc_body_repeat1 = 177,
aux_sym_concatenation_repeat1 = 178,
aux_sym_string_repeat1 = 179,
aux_sym_expansion_regex_repeat1 = 180,
aux_sym__concatenation_in_expansion_repeat1 = 181,
alias_sym_statements = 182,
alias_sym_terminator = 183,
sym_terminator = 165,
aux_sym__statements_repeat1 = 166,
aux_sym_redirected_statement_repeat1 = 167,
aux_sym_redirected_statement_repeat2 = 168,
aux_sym_for_statement_repeat1 = 169,
aux_sym_if_statement_repeat1 = 170,
aux_sym_case_statement_repeat1 = 171,
aux_sym__case_item_last_repeat1 = 172,
aux_sym__case_item_last_repeat2 = 173,
aux_sym_pipeline_repeat1 = 174,
aux_sym_command_repeat1 = 175,
aux_sym_command_repeat2 = 176,
aux_sym__variable_assignments_repeat1 = 177,
aux_sym_heredoc_body_repeat1 = 178,
aux_sym_concatenation_repeat1 = 179,
aux_sym_string_repeat1 = 180,
aux_sym_expansion_regex_repeat1 = 181,
aux_sym__concatenation_in_expansion_repeat1 = 182,
alias_sym_statements = 183,
};
#endif // SYMBOLS_H

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

@ -51,20 +51,20 @@ static inline bool lex_normal_map10(t_lexer *lexer, \
static uint32_t map[] = {'\n', 310, '!', 286, '"', 395, \
'#', 410, '$', 393, '&', 359, '\'', 219, '(', 271, '*', \
371, '-', 367, '0', 474, ';', 530, '<', 292, '>', 295, \
'?', 378, '@', 472, '\\', 13, '_', 477, '`', 430, '|', \
276};
'?', 378, '@', 472, '\\', 13, '_', 477, '`', 430, 'e', \
439, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map49(t_lexer *lexer, \
static inline bool lex_normal_map48(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 311, '!', 285, '#', 410, \
'$', 392, '&', 359, '*', 368, '-', 365, '0', 475, ';', \
530, '<', 292, '>', 295, '?', 377, '@', 471, '\\', 51, \
'_', 478, '|', 276};
'$', 392, '&', 359, ')', 277, '*', 368, '-', 365, '0', \
475, ';', 530, '<', 292, '>', 295, '?', 377, '@', 471, \
'\\', 50, '_', 478, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -76,8 +76,8 @@ static inline bool lex_normal_map94(t_lexer *lexer, \
static uint32_t map[] = {'\n', 313, '!', 286, '"', 395, \
'#', 410, '$', 393, '&', 359, '\'', 219, '(', 271, '*', \
371, '-', 367, '0', 474, ';', 530, '<', 292, '>', 295, \
'?', 378, '@', 472, '\\', 22, '_', 477, '`', 430, 'e', \
439, '|', 276};
'?', 378, '@', 472, '\\', 19, '_', 477, '`', 430, '|', \
276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));

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

@ -23,8 +23,8 @@ static inline bool lex_normal_map105(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 314, '"', 395, '#', 435, \
'$', 393, '&', 359, '\'', 219, '(', 271, ';', 530, '<', \
292, '>', 295, '\\', 147, '`', 430, 'e', 527, '|', 276};
'$', 393, '&', 359, '\'', 219, '(', 271, ')', 277, ';', \
530, '<', 292, '>', 295, '\\', 147, '`', 430, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -34,8 +34,8 @@ static inline bool lex_normal_map106(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 315, '"', 395, '#', 435, \
'$', 393, '&', 359, '\'', 219, '(', 271, ')', 277, ';', \
530, '<', 292, '>', 295, '\\', 149, '`', 430, '|', 276};
'$', 393, '&', 359, '\'', 219, '(', 271, ';', 530, '<', \
292, '>', 295, '\\', 149, '`', 430, 'e', 527, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -45,10 +45,10 @@ static inline bool lex_normal_map107(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 316, '!', 286, '"', 395, \
'#', 410, '$', 393, '&', 359, '\'', 219, '(', 271, ')', \
277, '*', 371, '-', 367, '0', 474, ';', 530, '<', 292, \
'>', 295, '?', 378, '@', 472, '\\', 19, '_', 477, '`', \
430, '|', 276};
'#', 410, '$', 393, '&', 359, '\'', 219, '*', 371, '-', \
367, '0', 474, ';', 530, '<', 292, '>', 295, '?', 378, \
'@', 472, '\\', 25, '_', 477, '`', 430, 'e', 439, '|', \
276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -60,7 +60,7 @@ static inline bool lex_normal_map108(t_lexer *lexer, \
static uint32_t map[] = {'\n', 317, '!', 285, '#', 410, \
'$', 392, '&', 359, '*', 368, '-', 365, '0', 475, ';', \
530, '<', 292, '>', 295, '?', 377, '@', 471, '\\', 53, \
'_', 478, 'e', 444, '|', 276};
'_', 478, '`', 430, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -70,10 +70,10 @@ static inline bool lex_normal_map109(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 318, '!', 286, '"', 395, \
'#', 410, '$', 393, '&', 359, '\'', 219, '*', 371, '-', \
367, '0', 474, ';', 530, '<', 292, '>', 295, '?', 378, \
'@', 472, '\\', 25, '_', 477, '`', 430, 'e', 439, '|', \
276};
'#', 410, '$', 393, '&', 359, '\'', 219, '(', 271, ')', \
277, '*', 371, '-', 367, '0', 474, ';', 530, '<', 292, \
'>', 295, '?', 378, '@', 472, '\\', 22, '_', 477, '`', \
430, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));

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

@ -19,26 +19,25 @@
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map239(t_lexer *lexer, \
static inline bool lex_normal_map244(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 310, '!', 286, '"', 395, \
static uint32_t map[] = {'\n', 313, '!', 286, '"', 395, \
'#', 410, '$', 393, '&', 359, '\'', 219, '(', 271, '*', \
371, '-', 367, '0', 474, ';', 530, '<', 292, '>', 295, \
'?', 378, '@', 472, '\\', 13, '_', 477, '`', 430, '|', \
'?', 378, '@', 472, '\\', 19, '_', 477, '`', 430, '|', \
276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map241(t_lexer *lexer, \
static inline bool lex_normal_map245(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 311, '!', 285, '#', 410, \
'$', 392, '&', 359, '*', 368, '-', 365, '0', 475, ';', \
530, '<', 292, '>', 295, '?', 377, '@', 471, '\\', 51, \
'_', 478, '|', 276};
static uint32_t map[] = {'\n', 314, '"', 395, '#', 435, \
'$', 393, '&', 359, '\'', 219, '(', 271, ')', 277, ';', \
530, '<', 292, '>', 295, '\\', 147, '`', 430, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -47,9 +46,10 @@ static inline bool lex_normal_map241(t_lexer *lexer, \
static inline bool lex_normal_map246(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 315, '"', 395, '#', 435, \
'$', 393, '&', 359, '\'', 219, '(', 271, ')', 277, ';', \
530, '<', 292, '>', 295, '\\', 149, '`', 430, '|', 276};
static uint32_t map[] = {'\n', 321, '!', 285, '#', 410, \
'$', 392, '&', 359, '*', 368, '-', 365, '0', 475, ';', \
530, '<', 292, '>', 295, '?', 377, '@', 471, '\\', 55, \
'_', 478, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -58,7 +58,7 @@ static inline bool lex_normal_map246(t_lexer *lexer, \
static inline bool lex_normal_map247(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 324, '"', 395, '#', 435, \
static uint32_t map[] = {'\n', 323, '"', 395, '#', 435, \
'$', 393, '&', 359, '\'', 219, '(', 271, ')', 277, ';', \
530, '<', 292, '>', 295, '\\', 153, '`', 431, '|', 276};
@ -69,7 +69,7 @@ static inline bool lex_normal_map247(t_lexer *lexer, \
static inline bool lex_normal_map248(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 325, '!', 286, '"', 395, \
static uint32_t map[] = {'\n', 326, '!', 286, '"', 395, \
'#', 410, '$', 393, '&', 359, '\'', 219, '*', 371, '-', \
367, '0', 474, ';', 530, '<', 292, '>', 295, '?', 378, \
'@', 472, '\\', 31, '_', 477, '`', 430, '|', 276};

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

@ -25,8 +25,8 @@ static inline bool lex_normal_map446(t_lexer *lexer, \
static uint32_t map[] = {'\n', 310, '!', 286, '"', 395, \
'#', 410, '$', 393, '&', 359, '\'', 219, '(', 271, '*', \
371, '-', 367, '0', 474, ';', 530, '<', 292, '>', 295, \
'?', 378, '@', 472, '\\', 13, '_', 477, '`', 430, '|', \
276};
'?', 378, '@', 472, '\\', 13, '_', 477, '`', 430, 'e', \
439, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -36,9 +36,9 @@ static inline bool lex_normal_map447(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 311, '!', 285, '#', 410, \
'$', 392, '&', 359, '*', 368, '-', 365, '0', 475, ';', \
530, '<', 292, '>', 295, '?', 377, '@', 471, '\\', 51, \
'_', 478, '|', 276};
'$', 392, '&', 359, ')', 277, '*', 368, '-', 365, '0', \
475, ';', 530, '<', 292, '>', 295, '?', 377, '@', 471, \
'\\', 50, '_', 478, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -50,8 +50,8 @@ static inline bool lex_normal_map448(t_lexer *lexer, \
static uint32_t map[] = {'\n', 313, '!', 286, '"', 395, \
'#', 410, '$', 393, '&', 359, '\'', 219, '(', 271, '*', \
371, '-', 367, '0', 474, ';', 530, '<', 292, '>', 295, \
'?', 378, '@', 472, '\\', 22, '_', 477, '`', 430, 'e', \
439, '|', 276};
'?', 378, '@', 472, '\\', 19, '_', 477, '`', 430, '|', \
276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -61,10 +61,10 @@ static inline bool lex_normal_map449(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 316, '!', 286, '"', 395, \
'#', 410, '$', 393, '&', 359, '\'', 219, '(', 271, ')', \
277, '*', 371, '-', 367, '0', 474, ';', 530, '<', 292, \
'>', 295, '?', 378, '@', 472, '\\', 19, '_', 477, '`', \
430, '|', 276};
'#', 410, '$', 393, '&', 359, '\'', 219, '*', 371, '-', \
367, '0', 474, ';', 530, '<', 292, '>', 295, '?', 378, \
'@', 472, '\\', 25, '_', 477, '`', 430, 'e', 439, '|', \
276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -76,7 +76,7 @@ static inline bool lex_normal_map450(t_lexer *lexer, \
static uint32_t map[] = {'\n', 317, '!', 285, '#', 410, \
'$', 392, '&', 359, '*', 368, '-', 365, '0', 475, ';', \
530, '<', 292, '>', 295, '?', 377, '@', 471, '\\', 53, \
'_', 478, 'e', 444, '|', 276};
'_', 478, '`', 430, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));

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

@ -23,10 +23,10 @@ static inline bool lex_normal_map451(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 318, '!', 286, '"', 395, \
'#', 410, '$', 393, '&', 359, '\'', 219, '*', 371, '-', \
367, '0', 474, ';', 530, '<', 292, '>', 295, '?', 378, \
'@', 472, '\\', 25, '_', 477, '`', 430, 'e', 439, '|', \
276};
'#', 410, '$', 393, '&', 359, '\'', 219, '(', 271, ')', \
277, '*', 371, '-', 367, '0', 474, ';', 530, '<', 292, \
'>', 295, '?', 378, '@', 472, '\\', 22, '_', 477, '`', \
430, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -35,7 +35,19 @@ static inline bool lex_normal_map451(t_lexer *lexer, \
static inline bool lex_normal_map452(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 321, '!', 286, '"', 395, \
static uint32_t map[] = {'\n', 321, '!', 285, '#', 410, \
'$', 392, '&', 359, '*', 368, '-', 365, '0', 475, ';', \
530, '<', 292, '>', 295, '?', 377, '@', 471, '\\', 55, \
'_', 478, '|', 276};
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', 322, '!', 286, '"', 395, \
'#', 410, '$', 393, '&', 359, '\'', 219, ')', 277, '*', \
371, '-', 367, '0', 474, ';', 530, '<', 292, '>', 295, \
'?', 378, '@', 472, '\\', 28, '_', 477, '`', 430, '|', \
@ -45,25 +57,13 @@ static inline bool lex_normal_map452(t_lexer *lexer, \
lexer, s));
}
static inline bool lex_normal_map453(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 322, '!', 285, '#', 410, \
'$', 392, '&', 359, '*', 368, '-', 365, '0', 475, ';', \
530, '<', 292, '>', 295, '?', 377, '@', 471, '\\', 55, \
'_', 478, '`', 430, '|', 276};
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', 325, '!', 286, '"', 395, \
'#', 410, '$', 393, '&', 359, '\'', 219, '*', 371, '-', \
367, '0', 474, ';', 530, '<', 292, '>', 295, '?', 378, \
'@', 472, '\\', 31, '_', 477, '`', 430, '|', 276};
static uint32_t map[] = {'\n', 325, '!', 285, '#', 410, \
'$', 392, '&', 359, '*', 368, '-', 365, '0', 475, ';', \
530, '<', 292, '>', 295, '?', 377, '@', 471, '\\', 57, \
'_', 478, 'e', 444, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -72,10 +72,10 @@ static inline bool lex_normal_map454(t_lexer *lexer, \
static inline bool lex_normal_map455(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 326, '!', 285, '#', 410, \
'$', 392, '&', 359, ')', 277, '*', 368, '-', 365, '0', \
475, ';', 530, '<', 292, '>', 295, '?', 377, '@', 471, \
'\\', 57, '_', 478, '|', 276};
static uint32_t map[] = {'\n', 326, '!', 286, '"', 395, \
'#', 410, '$', 393, '&', 359, '\'', 219, '*', 371, '-', \
367, '0', 474, ';', 530, '<', 292, '>', 295, '?', 378, \
'@', 472, '\\', 31, '_', 477, '`', 430, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));

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

@ -22,19 +22,7 @@
static inline bool lex_normal_map456(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 328, '!', 286, '"', 395, \
'#', 410, '$', 393, '&', 218, '\'', 219, '(', 271, '*', \
371, '-', 367, '0', 474, '<', 292, '>', 295, '?', 378, \
'@', 472, '\\', 36, '_', 477, '`', 430, '|', 276};
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', 329, '!', 285, '#', 410, \
static uint32_t map[] = {'\n', 328, '!', 285, '#', 410, \
'$', 392, '&', 218, '*', 368, '-', 365, '0', 475, '<', \
292, '>', 295, '?', 377, '@', 471, '\\', 63, '_', 478, \
'|', 276};
@ -43,22 +31,22 @@ static inline bool lex_normal_map457(t_lexer *lexer, \
lexer, s));
}
static inline bool lex_normal_map458(t_lexer *lexer, \
static inline bool lex_normal_map457(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 331, '!', 286, '"', 395, \
'#', 410, '$', 393, '&', 218, '\'', 219, '*', 371, '-', \
367, '0', 474, '<', 292, '>', 295, '?', 378, '@', 472, \
'\\', 42, '_', 477, '`', 430, '|', 276};
static uint32_t map[] = {'\n', 329, '!', 286, '"', 395, \
'#', 410, '$', 393, '&', 218, '\'', 219, '(', 271, '*', \
371, '-', 367, '0', 474, '<', 292, '>', 295, '?', 378, \
'@', 472, '\\', 36, '_', 477, '`', 430, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map459(t_lexer *lexer, \
static inline bool lex_normal_map458(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 332, '!', 285, '#', 410, \
static uint32_t map[] = {'\n', 331, '!', 285, '#', 410, \
'$', 392, '&', 218, '*', 368, '-', 365, '0', 475, '<', \
290, '>', 295, '?', 377, '@', 471, '\\', 102, '_', 478, \
'|', 237};
@ -67,13 +55,24 @@ static inline bool lex_normal_map459(t_lexer *lexer, \
lexer, s));
}
static inline bool lex_normal_map459(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 332, '!', 286, '"', 395, \
'#', 410, '$', 393, '&', 218, '\'', 219, '*', 371, '-', \
367, '0', 474, '<', 292, '>', 295, '?', 378, '@', 472, \
'\\', 39, '_', 477, '`', 430, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map460(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 333, '!', 286, '"', 395, \
'#', 410, '$', 393, '&', 218, '\'', 219, '*', 371, '-', \
367, '0', 474, '<', 290, '>', 295, '?', 378, '@', 472, \
'\\', 99, '_', 477, '`', 430, '|', 237};
static uint32_t map[] = {'\n', 333, '!', 285, '#', 410, \
'$', 392, '&', 356, '*', 368, '-', 365, '0', 475, ';', \
530, '?', 377, '@', 471, '\\', 80, '_', 478, 'i', 443};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));

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

@ -22,9 +22,10 @@
static inline bool lex_normal_map461(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 334, '!', 285, '#', 410, \
'$', 392, '&', 356, '*', 368, '-', 365, '0', 475, ';', \
530, '?', 377, '@', 471, '\\', 80, '_', 478, 'i', 443};
static uint32_t map[] = {'\n', 334, '!', 286, '"', 395, \
'#', 410, '$', 393, '&', 218, '\'', 219, '*', 371, '-', \
367, '0', 474, '<', 290, '>', 295, '?', 378, '@', 472, \
'\\', 99, '_', 477, '`', 430, '|', 237};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -47,7 +48,7 @@ static inline bool lex_normal_map463(t_lexer *lexer, \
{
static uint32_t map[] = {'\n', 336, '!', 286, '"', 395, \
'#', 410, '$', 393, '\'', 219, '*', 371, '-', 367, '0', \
474, '?', 378, '@', 472, '\\', 75, '_', 477, '`', 430};
474, '?', 378, '@', 472, '\\', 76, '_', 477, '`', 430};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -71,7 +72,7 @@ static inline bool lex_normal_map465(t_lexer *lexer, \
static uint32_t map[] = {'!', 286, '"', 395, '#', 410, \
'$', 393, '&', 218, '\'', 219, '(', 271, '*', 371, '-', \
367, '0', 474, '<', 292, '>', 295, '?', 378, '@', 472, \
'\\', 39, '_', 477, '`', 430, '|', 276};
'\\', 42, '_', 477, '`', 430, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));

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

@ -69,7 +69,7 @@ static inline bool lex_normal_map480(t_lexer *lexer, \
{
static uint32_t map[] = {'\n', 310, '!', 286, '#', 411, \
'*', 371, '-', 367, '0', 474, '?', 378, '@', 472, '\\', \
12, '_', 477};
12, '_', 477, 'e', 439};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));

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

@ -24,7 +24,7 @@ static inline bool lex_normal_map481(t_lexer *lexer, \
{
static uint32_t map[] = {'\n', 313, '!', 286, '#', 411, \
'*', 371, '-', 367, '0', 474, '?', 378, '@', 472, '\\', \
21, '_', 477, 'e', 439};
18, '_', 477};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -35,7 +35,7 @@ static inline bool lex_normal_map484(t_lexer *lexer, \
{
static uint32_t map[] = {'\n', 316, '!', 286, '#', 411, \
'*', 371, '-', 367, '0', 474, '?', 378, '@', 472, '\\', \
18, '_', 477};
24, '_', 477, 'e', 439};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -46,7 +46,7 @@ static inline bool lex_normal_map485(t_lexer *lexer, \
{
static uint32_t map[] = {'\n', 318, '!', 286, '#', 411, \
'*', 371, '-', 367, '0', 474, '?', 378, '@', 472, '\\', \
24, '_', 477, 'e', 439};
21, '_', 477};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -55,7 +55,7 @@ static inline bool lex_normal_map485(t_lexer *lexer, \
static inline bool lex_normal_map488(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 321, '!', 286, '#', 411, \
static uint32_t map[] = {'\n', 322, '!', 286, '#', 411, \
'*', 371, '-', 367, '0', 474, '?', 378, '@', 472, '\\', \
27, '_', 477};
@ -66,7 +66,7 @@ static inline bool lex_normal_map488(t_lexer *lexer, \
static inline bool lex_normal_map491(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 325, '!', 286, '#', 411, \
static uint32_t map[] = {'\n', 326, '!', 286, '#', 411, \
'*', 371, '-', 367, '0', 474, '?', 378, '@', 472, '\\', \
30, '_', 477};

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

@ -22,7 +22,7 @@
static inline bool lex_normal_map493(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 328, '!', 286, '#', 411, \
static uint32_t map[] = {'\n', 329, '!', 286, '#', 411, \
'*', 371, '-', 367, '0', 474, '?', 378, '@', 472, '\\', \
35, '_', 477};
@ -33,9 +33,9 @@ static inline bool lex_normal_map493(t_lexer *lexer, \
static inline bool lex_normal_map495(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 331, '!', 286, '#', 411, \
static uint32_t map[] = {'\n', 332, '!', 286, '#', 411, \
'*', 371, '-', 367, '0', 474, '?', 378, '@', 472, '\\', \
41, '_', 477};
38, '_', 477};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -44,7 +44,7 @@ static inline bool lex_normal_map495(t_lexer *lexer, \
static inline bool lex_normal_map496(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 333, '!', 286, '#', 411, \
static uint32_t map[] = {'\n', 334, '!', 286, '#', 411, \
'*', 371, '-', 367, '0', 474, '?', 378, '@', 472, '\\', \
98, '_', 477};
@ -68,7 +68,7 @@ static inline bool lex_normal_map498(t_lexer *lexer, \
{
static uint32_t map[] = {'\n', 336, '!', 286, '#', 411, \
'*', 371, '-', 367, '0', 474, '?', 378, '@', 472, '\\', \
74, '_', 477};
75, '_', 477};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));

2
parser/static/lex_funcs/lex_normal/inline/inline_impl19.h
View file

@ -36,7 +36,7 @@ static inline bool lex_normal_map500(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 286, '#', 411, '*', 371, \
'-', 367, '0', 474, '?', 378, '@', 472, '\\', 38, '_', \
'-', 367, '0', 474, '?', 378, '@', 472, '\\', 41, '_', \
477};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \

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

@ -23,8 +23,8 @@ static inline bool lex_normal_map110(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 319, '"', 395, '#', 435, \
'$', 393, '&', 359, '\'', 219, '(', 271, ';', 530, '<', \
292, '>', 295, '\\', 155, '`', 431, 'e', 527, '|', 276};
'$', 393, '&', 218, '\'', 219, '<', 290, '>', 295, '\\', \
151, '`', 430, '|', 274};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -34,8 +34,8 @@ static inline bool lex_normal_map111(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 320, '"', 395, '#', 435, \
'$', 393, '&', 218, '\'', 219, '<', 290, '>', 295, '\\', \
151, '`', 430, '|', 274};
'$', 393, '&', 359, '\'', 219, '(', 271, ';', 530, '<', \
292, '>', 295, '\\', 157, '`', 431, 'e', 527, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -44,7 +44,19 @@ static inline bool lex_normal_map111(t_lexer *lexer, \
static inline bool lex_normal_map112(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 321, '!', 286, '"', 395, \
static uint32_t map[] = {'\n', 321, '!', 285, '#', 410, \
'$', 392, '&', 359, '*', 368, '-', 365, '0', 475, ';', \
530, '<', 292, '>', 295, '?', 377, '@', 471, '\\', 55, \
'_', 478, '|', 276};
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', 322, '!', 286, '"', 395, \
'#', 410, '$', 393, '&', 359, '\'', 219, ')', 277, '*', \
371, '-', 367, '0', 474, ';', 530, '<', 292, '>', 295, \
'?', 378, '@', 472, '\\', 28, '_', 477, '`', 430, '|', \
@ -54,24 +66,12 @@ static inline bool lex_normal_map112(t_lexer *lexer, \
lexer, s));
}
static inline bool lex_normal_map113(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 322, '!', 285, '#', 410, \
'$', 392, '&', 359, '*', 368, '-', 365, '0', 475, ';', \
530, '<', 292, '>', 295, '?', 377, '@', 471, '\\', 55, \
'_', 478, '`', 430, '|', 276};
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', 323, '"', 395, '#', 435, \
'$', 393, '&', 356, '\'', 219, '(', 271, ';', 530, '\\', \
165, '`', 430, 'e', 527};
'$', 393, '&', 359, '\'', 219, '(', 271, ')', 277, ';', \
530, '<', 292, '>', 295, '\\', 153, '`', 431, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));

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

@ -23,8 +23,8 @@ static inline bool lex_normal_map115(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 324, '"', 395, '#', 435, \
'$', 393, '&', 359, '\'', 219, '(', 271, ')', 277, ';', \
530, '<', 292, '>', 295, '\\', 153, '`', 431, '|', 276};
'$', 393, '&', 356, '\'', 219, '(', 271, ';', 530, '\\', \
165, '`', 430, 'e', 527};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -33,10 +33,10 @@ static inline bool lex_normal_map115(t_lexer *lexer, \
static inline bool lex_normal_map116(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 325, '!', 286, '"', 395, \
'#', 410, '$', 393, '&', 359, '\'', 219, '*', 371, '-', \
367, '0', 474, ';', 530, '<', 292, '>', 295, '?', 378, \
'@', 472, '\\', 31, '_', 477, '`', 430, '|', 276};
static uint32_t map[] = {'\n', 325, '!', 285, '#', 410, \
'$', 392, '&', 359, '*', 368, '-', 365, '0', 475, ';', \
530, '<', 292, '>', 295, '?', 377, '@', 471, '\\', 57, \
'_', 478, 'e', 444, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -45,10 +45,10 @@ static inline bool lex_normal_map116(t_lexer *lexer, \
static inline bool lex_normal_map117(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 326, '!', 285, '#', 410, \
'$', 392, '&', 359, ')', 277, '*', 368, '-', 365, '0', \
475, ';', 530, '<', 292, '>', 295, '?', 377, '@', 471, \
'\\', 57, '_', 478, '|', 276};
static uint32_t map[] = {'\n', 326, '!', 286, '"', 395, \
'#', 410, '$', 393, '&', 359, '\'', 219, '*', 371, '-', \
367, '0', 474, ';', 530, '<', 292, '>', 295, '?', 378, \
'@', 472, '\\', 31, '_', 477, '`', 430, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -68,10 +68,10 @@ static inline bool lex_normal_map118(t_lexer *lexer, \
static inline bool lex_normal_map119(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 328, '!', 286, '"', 395, \
'#', 410, '$', 393, '&', 218, '\'', 219, '(', 271, '*', \
371, '-', 367, '0', 474, '<', 292, '>', 295, '?', 378, \
'@', 472, '\\', 36, '_', 477, '`', 430, '|', 276};
static uint32_t map[] = {'\n', 328, '!', 285, '#', 410, \
'$', 392, '&', 218, '*', 368, '-', 365, '0', 475, '<', \
292, '>', 295, '?', 377, '@', 471, '\\', 63, '_', 478, \
'|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));

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

@ -22,10 +22,10 @@
static inline bool lex_normal_map120(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 329, '!', 285, '#', 410, \
'$', 392, '&', 218, '*', 368, '-', 365, '0', 475, '<', \
292, '>', 295, '?', 377, '@', 471, '\\', 63, '_', 478, \
'|', 276};
static uint32_t map[] = {'\n', 329, '!', 286, '"', 395, \
'#', 410, '$', 393, '&', 218, '\'', 219, '(', 271, '*', \
371, '-', 367, '0', 474, '<', 292, '>', 295, '?', 378, \
'@', 472, '\\', 36, '_', 477, '`', 430, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -45,19 +45,7 @@ static inline bool lex_normal_map121(t_lexer *lexer, \
static inline bool lex_normal_map122(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 331, '!', 286, '"', 395, \
'#', 410, '$', 393, '&', 218, '\'', 219, '*', 371, '-', \
367, '0', 474, '<', 292, '>', 295, '?', 378, '@', 472, \
'\\', 42, '_', 477, '`', 430, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map123(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 332, '!', 285, '#', 410, \
static uint32_t map[] = {'\n', 331, '!', 285, '#', 410, \
'$', 392, '&', 218, '*', 368, '-', 365, '0', 475, '<', \
290, '>', 295, '?', 377, '@', 471, '\\', 102, '_', 478, \
'|', 237};
@ -66,13 +54,24 @@ static inline bool lex_normal_map123(t_lexer *lexer, \
lexer, s));
}
static inline bool lex_normal_map123(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 332, '!', 286, '"', 395, \
'#', 410, '$', 393, '&', 218, '\'', 219, '*', 371, '-', \
367, '0', 474, '<', 292, '>', 295, '?', 378, '@', 472, \
'\\', 39, '_', 477, '`', 430, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map124(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 333, '!', 286, '"', 395, \
'#', 410, '$', 393, '&', 218, '\'', 219, '*', 371, '-', \
367, '0', 474, '<', 290, '>', 295, '?', 378, '@', 472, \
'\\', 99, '_', 477, '`', 430, '|', 237};
static uint32_t map[] = {'\n', 333, '!', 285, '#', 410, \
'$', 392, '&', 356, '*', 368, '-', 365, '0', 475, ';', \
530, '?', 377, '@', 471, '\\', 80, '_', 478, 'i', 443};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));

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

@ -22,9 +22,10 @@
static inline bool lex_normal_map125(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 334, '!', 285, '#', 410, \
'$', 392, '&', 356, '*', 368, '-', 365, '0', 475, ';', \
530, '?', 377, '@', 471, '\\', 80, '_', 478, 'i', 443};
static uint32_t map[] = {'\n', 334, '!', 286, '"', 395, \
'#', 410, '$', 393, '&', 218, '\'', 219, '*', 371, '-', \
367, '0', 474, '<', 290, '>', 295, '?', 378, '@', 472, \
'\\', 99, '_', 477, '`', 430, '|', 237};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -47,7 +48,7 @@ static inline bool lex_normal_map127(t_lexer *lexer, \
{
static uint32_t map[] = {'\n', 336, '!', 286, '"', 395, \
'#', 410, '$', 393, '\'', 219, '*', 371, '-', 367, '0', \
474, '?', 378, '@', 472, '\\', 75, '_', 477, '`', 430};
474, '?', 378, '@', 472, '\\', 76, '_', 477, '`', 430};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));

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

@ -25,7 +25,7 @@ static inline bool lex_normal_map188(t_lexer *lexer, \
static uint32_t map[] = {'!', 286, '"', 395, '#', 410, \
'$', 393, '&', 218, '\'', 219, '(', 271, '*', 371, '-', \
367, '0', 474, '<', 292, '>', 295, '?', 378, '@', 472, \
'\\', 39, '_', 477, '`', 430, '|', 276};
'\\', 42, '_', 477, '`', 430, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));

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

@ -35,7 +35,7 @@ static inline bool lex_normal_map194(t_lexer *lexer, \
{
static uint32_t map[] = {'!', 286, '"', 395, '#', 435, \
'$', 393, '&', 225, '\'', 219, '(', 271, '<', 290, '>', \
295, '\\', 141, '`', 430, '{', 280, '}', 282};
295, '\\', 141, '`', 430, 'f', 521, '{', 280};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -46,7 +46,7 @@ static inline bool lex_normal_map195(t_lexer *lexer, \
{
static uint32_t map[] = {'!', 286, '"', 395, '#', 435, \
'$', 393, '&', 225, '\'', 219, '(', 271, '<', 290, '>', \
295, '\\', 143, '`', 430, 'f', 521, '{', 280};
295, '\\', 143, '`', 430, '{', 280, '}', 282};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));

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

@ -46,7 +46,7 @@ static inline bool lex_normal_map205(t_lexer *lexer, \
{
static uint32_t map[] = {'"', 395, '#', 435, '$', 393, \
'&', 218, '\'', 219, '(', 271, '<', 292, '>', 295, '\\', \
157, '`', 430, '|', 276};
155, '`', 430, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));

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

@ -16,18 +16,18 @@ bool lex_normal_s50(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(447, 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(447, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(50, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(49, lexer, s));
return (lex_skip(196, lexer, s));
return (lex_end_state(lexer, s));
}
@ -53,6 +53,6 @@ bool lex_normal_s53(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s54(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(453, lexer, s));
return (lex_advance(452, lexer, s));
return (lex_end_state(lexer, s));
}

8
parser/static/lex_funcs/lex_normal/state_101.c
View file

@ -44,10 +44,10 @@ bool lex_normal_s506(t_lexer *lexer, t_lexer_state *s)
return (lex_advance(529, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(140, lexer, s));
if (s->lookahead == 'f')
return (lex_advance(521, lexer, s));
if (s->lookahead == '{')
return (lex_advance(280, lexer, s));
if (s->lookahead == '}')
return (lex_advance(282, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(506, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
@ -67,10 +67,10 @@ bool lex_normal_s507(t_lexer *lexer, t_lexer_state *s)
return (lex_advance(529, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(142, lexer, s));
if (s->lookahead == 'f')
return (lex_advance(521, lexer, s));
if (s->lookahead == '{')
return (lex_advance(280, lexer, s));
if (s->lookahead == '}')
return (lex_advance(282, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(507, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))

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

@ -18,7 +18,7 @@ bool lex_normal_s510(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '#')
return (lex_advance(529, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(156, lexer, s));
return (lex_advance(154, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(510, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))

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

@ -15,31 +15,31 @@
bool lex_normal_s55(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(453, lexer, s));
return (lex_advance(452, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(54, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(113, lexer, s));
return (lex_skip(112, 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(455, lexer, s));
return (lex_advance(454, 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_advance(455, lexer, s));
return (lex_advance(454, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(56, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(117, lexer, s));
return (lex_skip(116, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -44,19 +44,19 @@ bool lex_normal_s61(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s62(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(457, lexer, s));
return (lex_advance(456, 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(457, lexer, s));
return (lex_advance(456, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(62, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(120, lexer, s));
return (lex_skip(119, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -25,6 +25,13 @@ bool lex_normal_s65(t_lexer *lexer, t_lexer_state *s)
}
bool lex_normal_s66(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(198, 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(312, lexer, s));
@ -35,28 +42,21 @@ bool lex_normal_s66(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == ';')
return (lex_advance(530, lexer, s));
if (s->lookahead == '\\')
return (lex_skip(185, lexer, s));
return (lex_skip(183, lexer, s));
if (s->lookahead == '`')
return (lex_advance(226, lexer, s));
if (s->lookahead == 'i')
return (lex_advance(234, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(66, 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_skip(198, lexer, s));
return (lex_skip(67, 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_skip(114, lexer, s));
return (lex_skip(115, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -51,7 +51,7 @@ bool lex_normal_s72(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s73(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(463, lexer, s));
return (lex_skip(118, lexer, s));
return (lex_end_state(lexer, s));
}
@ -59,13 +59,5 @@ bool lex_normal_s74(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(463, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(73, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(498, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(127, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -17,9 +17,10 @@ bool lex_normal_s75(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(463, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(73, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_advance(74, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(498, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(127, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
@ -29,7 +30,14 @@ bool lex_normal_s75(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s76(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(118, lexer, s));
return (lex_advance(463, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(74, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(127, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
@ -50,6 +58,6 @@ bool lex_normal_s78(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s79(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(461, lexer, s));
return (lex_advance(460, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -15,12 +15,12 @@
bool lex_normal_s80(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(461, lexer, s));
return (lex_advance(460, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(79, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(125, lexer, s));
return (lex_skip(124, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -27,21 +27,21 @@ bool lex_normal_s90(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s91(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(208, lexer, s));
return (lex_skip(67, 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_skip(211, lexer, s));
return (lex_skip(208, 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_skip(66, lexer, s));
return (lex_skip(211, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -15,34 +15,34 @@
bool lex_normal_s95(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(110, lexer, s));
return (lex_skip(114, 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(115, lexer, s));
return (lex_skip(111, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s97(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(460, lexer, s));
return (lex_advance(461, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s98(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(460, lexer, s));
return (lex_advance(461, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(97, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(496, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(124, lexer, s));
return (lex_skip(125, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
@ -51,12 +51,12 @@ bool lex_normal_s98(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s99(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(460, lexer, s));
return (lex_advance(461, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(97, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(124, lexer, s));
return (lex_skip(125, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));

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

@ -22,19 +22,19 @@ bool lex_normal_s100(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s101(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(459, lexer, s));
return (lex_advance(458, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s102(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(459, lexer, s));
return (lex_advance(458, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(101, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(123, lexer, s));
return (lex_skip(122, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -22,8 +22,7 @@ bool lex_normal_s105(t_lexer *lexer, t_lexer_state *s)
return (lex_advance(482, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(407, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')')))
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
@ -38,7 +37,8 @@ bool lex_normal_s106(t_lexer *lexer, t_lexer_state *s)
return (lex_advance(483, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(407, lexer, s));
if (s->lookahead != 0)
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')')))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
@ -56,7 +56,8 @@ bool lex_normal_s107(t_lexer *lexer, t_lexer_state *s)
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(440, lexer, s));
if (s->lookahead != 0)
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*')))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
@ -88,8 +89,7 @@ bool lex_normal_s109(t_lexer *lexer, t_lexer_state *s)
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(440, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*')))
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -23,7 +23,8 @@ bool lex_normal_s110(t_lexer *lexer, t_lexer_state *s)
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(407, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')')))
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<'))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
@ -39,8 +40,7 @@ bool lex_normal_s111(t_lexer *lexer, t_lexer_state *s)
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(407, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<'))
s->lookahead < ')')))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
@ -49,8 +49,22 @@ 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 == ' '))
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(112, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(445, 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(488, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
@ -64,20 +78,6 @@ bool lex_normal_s112(t_lexer *lexer, t_lexer_state *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 <= '\r') || \
s->lookahead == ' '))
return (lex_skip(113, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(445, 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))
@ -88,9 +88,7 @@ bool lex_normal_s114(t_lexer *lexer, t_lexer_state *s)
return (lex_advance(489, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(407, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '>' && s->lookahead != '|'))
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -22,7 +22,9 @@ bool lex_normal_s115(t_lexer *lexer, t_lexer_state *s)
return (lex_advance(490, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(407, lexer, s));
if (s->lookahead != 0)
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '>' && s->lookahead != '|'))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
@ -31,8 +33,22 @@ bool lex_normal_s116(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map116(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(116, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(445, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s117(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map117(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(117, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(491, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
@ -46,20 +62,6 @@ bool lex_normal_s116(t_lexer *lexer, t_lexer_state *s)
return (lex_end_state(lexer, s));
}
bool lex_normal_s117(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map117(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(117, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(445, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s118(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map118(lexer, s))
@ -81,18 +83,12 @@ bool lex_normal_s119(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map119(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(119, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(493, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(408, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(440, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*') && s->lookahead != ';' && s->lookahead \
!= '<'))
return (lex_advance(528, lexer, s));
return (lex_advance(445, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -16,13 +16,19 @@ bool lex_normal_s120(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map120(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(120, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(493, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(408, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(445, lexer, s));
return (lex_advance(440, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*') && s->lookahead != ';' && s->lookahead \
!= '<'))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
@ -47,8 +53,22 @@ bool lex_normal_s122(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map122(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(122, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(445, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s123(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map123(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(123, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(495, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
@ -63,36 +83,16 @@ bool lex_normal_s122(t_lexer *lexer, t_lexer_state *s)
return (lex_end_state(lexer, s));
}
bool lex_normal_s123(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s124(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map123(lexer, s))
if (lex_normal_map124(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(123, lexer, s));
return (lex_skip(124, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(445, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s124(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map124(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(124, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(496, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(408, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(440, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*') && s->lookahead != ';' && s->lookahead \
!= '<'))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -16,13 +16,19 @@ bool lex_normal_s125(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map125(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(125, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(496, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(408, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(445, lexer, s));
return (lex_advance(440, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*') && s->lookahead != ';' && s->lookahead \
!= '<'))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -36,20 +36,20 @@ bool lex_normal_s16(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s17(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(449, lexer, s));
return (lex_advance(448, 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(449, lexer, s));
return (lex_advance(448, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(17, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(484, lexer, s));
return (lex_advance(481, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(107, lexer, s));
return (lex_skip(94, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
@ -58,12 +58,12 @@ bool lex_normal_s18(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s19(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(449, lexer, s));
return (lex_advance(448, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(17, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(107, lexer, s));
return (lex_skip(94, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));

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

@ -17,9 +17,9 @@ bool lex_normal_s150(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\r')
return (lex_skip(46, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(487, lexer, s));
return (lex_advance(486, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(111, lexer, s));
return (lex_skip(110, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
@ -31,7 +31,7 @@ bool lex_normal_s151(t_lexer *lexer, t_lexer_state *s)
return (lex_skip(46, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(111, lexer, s));
return (lex_skip(110, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
@ -40,11 +40,11 @@ bool lex_normal_s151(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s152(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(96, lexer, s));
return (lex_skip(95, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(490, lexer, s));
return (lex_advance(489, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(115, lexer, s));
return (lex_skip(114, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
@ -53,10 +53,10 @@ bool lex_normal_s152(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s153(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(96, lexer, s));
return (lex_skip(95, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(115, lexer, s));
return (lex_skip(114, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
@ -65,11 +65,11 @@ bool lex_normal_s153(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s154(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(95, lexer, s));
return (lex_skip(47, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(486, lexer, s));
return (lex_advance(510, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(110, lexer, s));
return (lex_skip(205, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));

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

@ -15,10 +15,10 @@
bool lex_normal_s155(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(95, lexer, s));
return (lex_skip(47, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(110, lexer, s));
return (lex_skip(205, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
@ -27,11 +27,11 @@ bool lex_normal_s155(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s156(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(47, lexer, s));
return (lex_skip(96, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(510, lexer, s));
return (lex_advance(487, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(205, lexer, s));
return (lex_skip(111, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
@ -40,10 +40,10 @@ bool lex_normal_s156(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s157(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(47, lexer, s));
return (lex_skip(96, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(205, lexer, s));
return (lex_skip(111, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
@ -52,7 +52,7 @@ bool lex_normal_s157(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s158(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(48, lexer, s));
return (lex_skip(51, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(196, lexer, s));

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

@ -52,7 +52,7 @@ bool lex_normal_s162(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s163(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(67, lexer, s));
return (lex_skip(66, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(198, lexer, s));
@ -64,9 +64,9 @@ bool lex_normal_s164(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\r')
return (lex_skip(68, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(489, lexer, s));
return (lex_advance(490, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(114, lexer, s));
return (lex_skip(115, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));

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

@ -18,7 +18,7 @@ bool lex_normal_s165(t_lexer *lexer, t_lexer_state *s)
return (lex_skip(68, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(114, lexer, s));
return (lex_skip(115, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
@ -52,7 +52,7 @@ bool lex_normal_s167(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s168(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(76, lexer, s));
return (lex_skip(73, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(492, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
@ -65,7 +65,7 @@ bool lex_normal_s168(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s169(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(76, lexer, s));
return (lex_skip(73, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(118, lexer, s));

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

@ -53,7 +53,7 @@ bool lex_normal_s183(t_lexer *lexer, t_lexer_state *s)
return (lex_skip(91, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(208, lexer, s));
return (lex_skip(67, lexer, s));
return (lex_end_state(lexer, s));
}
@ -63,6 +63,6 @@ bool lex_normal_s184(t_lexer *lexer, t_lexer_state *s)
return (lex_skip(92, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(211, lexer, s));
return (lex_skip(208, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -18,7 +18,7 @@ bool lex_normal_s185(t_lexer *lexer, t_lexer_state *s)
return (lex_skip(93, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(66, lexer, s));
return (lex_skip(211, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -96,7 +96,7 @@ bool lex_normal_s194(t_lexer *lexer, t_lexer_state *s)
return (lex_advance(407, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && (s->lookahead > '{' && s->lookahead < '}')))
!= '<' && s->lookahead != '{' && s->lookahead != '|'))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -25,7 +25,7 @@ bool lex_normal_s195(t_lexer *lexer, t_lexer_state *s)
return (lex_advance(407, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '{' && s->lookahead != '|'))
!= '<' && (s->lookahead > '{' && s->lookahead < '}')))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -15,52 +15,16 @@
bool lex_normal_s20(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(448, lexer, s));
return (lex_advance(451, 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(448, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(20, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(481, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(94, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, 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(448, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(20, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(94, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, 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(451, 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(451, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(23, lexer, s));
return (lex_advance(20, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(485, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
@ -69,3 +33,39 @@ bool lex_normal_s24(t_lexer *lexer, t_lexer_state *s)
return (lex_advance(528, 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(451, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(20, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(109, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, 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(449, 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(449, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(23, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(484, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(107, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -77,7 +77,7 @@ bool lex_normal_s208(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == ')')
return (lex_advance(277, lexer, s));
if (s->lookahead == '\\')
return (lex_skip(183, lexer, s));
return (lex_skip(184, lexer, s));
if (s->lookahead == '`')
return (lex_advance(430, lexer, s));
if (s->lookahead == '|')

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

@ -49,7 +49,7 @@ bool lex_normal_s211(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == ')')
return (lex_advance(277, lexer, s));
if (s->lookahead == '\\')
return (lex_skip(184, lexer, s));
return (lex_skip(185, lexer, s));
if (s->lookahead == '}')
return (lex_advance(281, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \

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

@ -45,19 +45,7 @@ bool lex_normal_s239(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(255, lexer, s));
if (lex_normal_map239(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(239, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(480, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(408, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(440, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*')))
return (lex_advance(528, lexer, s));
if (s->lookahead == '\n')
return (lex_skip(254, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -17,36 +17,11 @@ bool lex_normal_s240(t_lexer *lexer, t_lexer_state *s)
if (s->eof)
return (lex_advance(255, lexer, s));
if (s->lookahead == '\n')
return (lex_skip(254, lexer, s));
return (lex_skip(241, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s241(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(255, lexer, s));
if (lex_normal_map241(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(241, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(445, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s242(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(255, lexer, s));
if (s->lookahead == '\n')
return (lex_skip(243, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s243(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(255, lexer, s));
@ -74,11 +49,11 @@ bool lex_normal_s243(t_lexer *lexer, t_lexer_state *s)
return (lex_advance(276, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(243, lexer, s));
return (lex_skip(241, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s244(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s242(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(255, lexer, s));
@ -104,6 +79,36 @@ bool lex_normal_s244(t_lexer *lexer, t_lexer_state *s)
return (lex_advance(276, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(244, lexer, s));
return (lex_skip(242, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s243(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(255, lexer, s));
if (s->lookahead == '\n')
return (lex_skip(242, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s244(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(255, lexer, s));
if (lex_normal_map244(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(244, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(481, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(408, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(440, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*')))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -16,8 +16,16 @@ bool lex_normal_s245(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(255, lexer, s));
if (s->lookahead == '\n')
return (lex_skip(244, lexer, s));
if (lex_normal_map245(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(245, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(482, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(407, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
@ -27,14 +35,13 @@ bool lex_normal_s246(t_lexer *lexer, t_lexer_state *s)
return (lex_advance(255, lexer, s));
if (lex_normal_map246(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(246, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(483, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(407, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(445, lexer, s));
return (lex_end_state(lexer, s));
}
@ -47,7 +54,7 @@ bool lex_normal_s247(t_lexer *lexer, t_lexer_state *s)
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(247, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(490, lexer, s));
return (lex_advance(489, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(407, lexer, s));
if (s->lookahead != 0)
@ -81,7 +88,7 @@ bool lex_normal_s249(t_lexer *lexer, t_lexer_state *s)
if (s->eof)
return (lex_advance(255, lexer, s));
if (s->lookahead == '\r')
return (lex_skip(240, lexer, s));
return (lex_skip(239, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(254, lexer, s));

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

@ -15,12 +15,12 @@
bool lex_normal_s25(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(451, lexer, s));
return (lex_advance(449, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(23, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(109, lexer, s));
return (lex_skip(107, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
@ -29,20 +29,20 @@ bool lex_normal_s25(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s26(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(452, lexer, s));
return (lex_advance(453, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s27(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(452, lexer, s));
return (lex_advance(453, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(26, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(488, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(112, lexer, s));
return (lex_skip(113, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
@ -51,12 +51,12 @@ bool lex_normal_s27(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s28(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(452, lexer, s));
return (lex_advance(453, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(26, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(112, lexer, s));
return (lex_skip(113, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
@ -65,6 +65,6 @@ bool lex_normal_s28(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s29(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(454, lexer, s));
return (lex_advance(455, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -17,10 +17,10 @@ bool lex_normal_s250(t_lexer *lexer, t_lexer_state *s)
if (s->eof)
return (lex_advance(255, lexer, s));
if (s->lookahead == '\r')
return (lex_skip(242, lexer, s));
return (lex_skip(240, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(243, lexer, s));
return (lex_skip(241, lexer, s));
return (lex_end_state(lexer, s));
}
@ -29,10 +29,10 @@ bool lex_normal_s251(t_lexer *lexer, t_lexer_state *s)
if (s->eof)
return (lex_advance(255, lexer, s));
if (s->lookahead == '\r')
return (lex_skip(245, lexer, s));
return (lex_skip(243, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(244, lexer, s));
return (lex_skip(242, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -15,13 +15,13 @@
bool lex_normal_s30(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(454, lexer, s));
return (lex_advance(455, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(29, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(491, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(116, lexer, s));
return (lex_skip(117, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
@ -30,12 +30,12 @@ bool lex_normal_s30(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s31(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(454, lexer, s));
return (lex_advance(455, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(29, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(116, lexer, s));
return (lex_skip(117, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
@ -58,6 +58,6 @@ bool lex_normal_s33(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s34(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(456, lexer, s));
return (lex_advance(457, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -32,7 +32,7 @@ bool lex_normal_s311(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(311, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(51, lexer, s));
return (lex_advance(50, lexer, s));
return (lex_end_state(lexer, s));
}
@ -52,7 +52,7 @@ bool lex_normal_s313(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(313, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(22, lexer, s));
return (lex_advance(19, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(481, lexer, s));
return (lex_end_state(lexer, s));

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

@ -32,7 +32,7 @@ bool lex_normal_s316(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(316, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(19, lexer, s));
return (lex_advance(25, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(484, lexer, s));
return (lex_end_state(lexer, s));
@ -56,7 +56,7 @@ bool lex_normal_s318(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(318, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(25, lexer, s));
return (lex_advance(22, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(485, lexer, s));
return (lex_end_state(lexer, s));
@ -69,7 +69,7 @@ bool lex_normal_s319(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(319, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(155, lexer, s));
return (lex_advance(151, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(486, lexer, s));
return (lex_end_state(lexer, s));

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

@ -19,7 +19,7 @@ bool lex_normal_s320(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(320, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(151, lexer, s));
return (lex_advance(157, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(487, lexer, s));
return (lex_end_state(lexer, s));
@ -32,9 +32,7 @@ bool lex_normal_s321(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(321, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(28, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(488, lexer, s));
return (lex_advance(55, lexer, s));
return (lex_end_state(lexer, s));
}
@ -45,7 +43,9 @@ bool lex_normal_s322(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(322, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(55, lexer, s));
return (lex_advance(28, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
@ -56,7 +56,7 @@ bool lex_normal_s323(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(323, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(165, lexer, s));
return (lex_advance(153, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(489, lexer, s));
return (lex_end_state(lexer, s));
@ -69,7 +69,7 @@ bool lex_normal_s324(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(324, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(153, lexer, s));
return (lex_advance(165, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(490, lexer, s));
return (lex_end_state(lexer, s));

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

@ -19,9 +19,7 @@ bool lex_normal_s325(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(325, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(31, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(491, lexer, s));
return (lex_advance(57, lexer, s));
return (lex_end_state(lexer, s));
}
@ -32,7 +30,9 @@ bool lex_normal_s326(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(326, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(57, lexer, s));
return (lex_advance(31, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(491, lexer, s));
return (lex_end_state(lexer, s));
}
@ -56,9 +56,7 @@ bool lex_normal_s328(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(328, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(36, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(493, lexer, s));
return (lex_advance(63, lexer, s));
return (lex_end_state(lexer, s));
}
@ -69,6 +67,8 @@ bool lex_normal_s329(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(329, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(63, lexer, s));
return (lex_advance(36, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(493, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -32,9 +32,7 @@ bool lex_normal_s331(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(331, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(42, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(495, lexer, s));
return (lex_advance(102, lexer, s));
return (lex_end_state(lexer, s));
}
@ -45,7 +43,9 @@ bool lex_normal_s332(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(332, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(102, lexer, s));
return (lex_advance(39, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(495, lexer, s));
return (lex_end_state(lexer, s));
}
@ -56,9 +56,7 @@ bool lex_normal_s333(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(333, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(99, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(496, lexer, s));
return (lex_advance(80, lexer, s));
return (lex_end_state(lexer, s));
}
@ -69,6 +67,8 @@ bool lex_normal_s334(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(334, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(80, lexer, s));
return (lex_advance(99, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(496, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -32,7 +32,7 @@ bool lex_normal_s336(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(336, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(75, lexer, s));
return (lex_advance(76, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(498, lexer, s));
return (lex_end_state(lexer, s));

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

@ -15,13 +15,13 @@
bool lex_normal_s35(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(456, lexer, s));
return (lex_advance(457, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(34, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(493, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(119, lexer, s));
return (lex_skip(120, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
@ -30,12 +30,12 @@ bool lex_normal_s35(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s36(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(456, lexer, s));
return (lex_advance(457, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(34, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(119, lexer, s));
return (lex_skip(120, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
@ -44,20 +44,20 @@ bool lex_normal_s36(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s37(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(465, lexer, s));
return (lex_advance(459, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s38(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(465, lexer, s));
return (lex_advance(459, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(37, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(500, lexer, s));
return (lex_advance(495, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(188, lexer, s));
return (lex_skip(123, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
@ -66,12 +66,12 @@ bool lex_normal_s38(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s39(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(465, lexer, s));
return (lex_advance(459, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(37, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(188, lexer, s));
return (lex_skip(123, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));

12
parser/static/lex_funcs/lex_normal/state_8.c
View file

@ -15,20 +15,20 @@
bool lex_normal_s40(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(458, lexer, s));
return (lex_advance(465, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s41(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(458, lexer, s));
return (lex_advance(465, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(40, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(495, lexer, s));
return (lex_advance(500, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(122, lexer, s));
return (lex_skip(188, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
@ -37,12 +37,12 @@ bool lex_normal_s41(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s42(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(458, lexer, s));
return (lex_advance(465, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(40, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(122, lexer, s));
return (lex_skip(188, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));

5
parser/static/lex_funcs/lex_normal/state_89.c
View file

@ -53,7 +53,7 @@ bool lex_normal_s447(t_lexer *lexer, t_lexer_state *s)
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(49, lexer, s));
return (lex_skip(48, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
@ -97,7 +97,8 @@ bool lex_normal_s449(t_lexer *lexer, t_lexer_state *s)
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(440, lexer, s));
if (s->lookahead != 0)
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*')))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -29,7 +29,7 @@ bool lex_normal_s45(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s46(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(111, lexer, s));
return (lex_skip(110, lexer, s));
return (lex_end_state(lexer, s));
}
@ -42,21 +42,21 @@ bool lex_normal_s47(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s48(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(196, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s49(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map49(lexer, s))
if (lex_normal_map48(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(49, lexer, s));
return (lex_skip(48, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(445, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s49(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(447, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -43,8 +43,7 @@ bool lex_normal_s451(t_lexer *lexer, t_lexer_state *s)
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(440, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*')))
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
@ -55,8 +54,24 @@ bool lex_normal_s452(t_lexer *lexer, t_lexer_state *s)
lexer, s);
if (lex_normal_map452(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(112, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(445, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s453(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(aux_sym__multiline_variable_name_token1, \
lexer, s);
if (lex_normal_map453(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(488, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
@ -70,39 +85,18 @@ bool lex_normal_s452(t_lexer *lexer, t_lexer_state *s)
return (lex_end_state(lexer, s));
}
bool lex_normal_s453(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(aux_sym__multiline_variable_name_token1, \
lexer, s);
if (lex_normal_map453(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(113, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(445, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s454(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(aux_sym__multiline_variable_name_token1, \
lexer, s);
if (lex_normal_map454(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(116, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(491, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(408, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(440, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*')))
return (lex_advance(528, lexer, s));
return (lex_advance(445, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -18,13 +18,18 @@ bool lex_normal_s455(t_lexer *lexer, t_lexer_state *s)
lexer, s);
if (lex_normal_map455(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(117, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(491, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(408, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(445, lexer, s));
return (lex_advance(440, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*')))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
@ -34,8 +39,24 @@ bool lex_normal_s456(t_lexer *lexer, t_lexer_state *s)
lexer, s);
if (lex_normal_map456(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(119, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(445, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s457(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(aux_sym__multiline_variable_name_token1, \
lexer, s);
if (lex_normal_map457(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(120, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(493, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
@ -50,15 +71,15 @@ bool lex_normal_s456(t_lexer *lexer, t_lexer_state *s)
return (lex_end_state(lexer, s));
}
bool lex_normal_s457(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s458(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(aux_sym__multiline_variable_name_token1, \
lexer, s);
if (lex_normal_map457(lexer, s))
if (lex_normal_map458(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(120, lexer, s));
return (lex_skip(122, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
@ -66,14 +87,14 @@ bool lex_normal_s457(t_lexer *lexer, t_lexer_state *s)
return (lex_end_state(lexer, s));
}
bool lex_normal_s458(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s459(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(aux_sym__multiline_variable_name_token1, \
lexer, s);
if (lex_normal_map458(lexer, s))
if (lex_normal_map459(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(122, lexer, s));
return (lex_skip(123, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(495, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
@ -87,19 +108,3 @@ bool lex_normal_s458(t_lexer *lexer, t_lexer_state *s)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s459(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(aux_sym__multiline_variable_name_token1, \
lexer, s);
if (lex_normal_map459(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(123, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(445, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -18,8 +18,24 @@ bool lex_normal_s460(t_lexer *lexer, t_lexer_state *s)
lexer, s);
if (lex_normal_map460(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(124, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(445, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s461(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(aux_sym__multiline_variable_name_token1, \
lexer, s);
if (lex_normal_map461(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(125, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(496, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
@ -34,22 +50,6 @@ bool lex_normal_s460(t_lexer *lexer, t_lexer_state *s)
return (lex_end_state(lexer, s));
}
bool lex_normal_s461(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(aux_sym__multiline_variable_name_token1, \
lexer, s);
if (lex_normal_map461(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(125, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(445, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s462(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(aux_sym__multiline_variable_name_token1, \

4
parser/static/lex_funcs/lex_normal/state_96.c
View file

@ -57,8 +57,6 @@ bool lex_normal_s482(t_lexer *lexer, t_lexer_state *s)
return (lex_advance(529, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(146, lexer, s));
if (s->lookahead == 'e')
return (lex_advance(527, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(482, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
@ -78,6 +76,8 @@ bool lex_normal_s483(t_lexer *lexer, t_lexer_state *s)
return (lex_advance(529, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(148, lexer, s));
if (s->lookahead == 'e')
return (lex_advance(527, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(483, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))

12
parser/static/lex_funcs/lex_normal/state_97.c
View file

@ -38,9 +38,7 @@ bool lex_normal_s486(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '#')
return (lex_advance(529, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(154, lexer, s));
if (s->lookahead == 'e')
return (lex_advance(527, lexer, s));
return (lex_advance(150, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(486, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
@ -59,7 +57,9 @@ bool lex_normal_s487(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '#')
return (lex_advance(529, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(150, lexer, s));
return (lex_advance(156, lexer, s));
if (s->lookahead == 'e')
return (lex_advance(527, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(487, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
@ -96,9 +96,7 @@ bool lex_normal_s489(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '#')
return (lex_advance(529, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(164, lexer, s));
if (s->lookahead == 'e')
return (lex_advance(527, lexer, s));
return (lex_advance(152, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(489, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))

4
parser/static/lex_funcs/lex_normal/state_98.c
View file

@ -20,7 +20,9 @@ bool lex_normal_s490(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '#')
return (lex_advance(529, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(152, lexer, s));
return (lex_advance(164, lexer, s));
if (s->lookahead == 'e')
return (lex_advance(527, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(490, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))

8
parser/static/lex_modes/lex_modes.h
View file

@ -137,13 +137,5 @@ void lex_modes_113(t_lex_modes_array *v);
void lex_modes_114(t_lex_modes_array *v);
void lex_modes_115(t_lex_modes_array *v);
void lex_modes_116(t_lex_modes_array *v);
void lex_modes_117(t_lex_modes_array *v);
void lex_modes_118(t_lex_modes_array *v);
void lex_modes_119(t_lex_modes_array *v);
void lex_modes_120(t_lex_modes_array *v);
void lex_modes_121(t_lex_modes_array *v);
void lex_modes_122(t_lex_modes_array *v);
void lex_modes_123(t_lex_modes_array *v);
void lex_modes_124(t_lex_modes_array *v);
#endif // LEX_MODES_H

38
parser/static/lex_modes/lex_modes_0.c
View file

@ -42,20 +42,20 @@ void lex_modes_1(t_lex_modes_array *v)
v->a[20] = lex_mode_external(5, 2);
v->a[21] = lex_mode_external(5, 2);
v->a[22] = lex_mode_external(5, 2);
v->a[23] = lex_mode_external(192, 2);
v->a[24] = lex_mode_external(5, 2);
v->a[23] = lex_mode_external(5, 2);
v->a[24] = lex_mode_external(192, 2);
v->a[25] = lex_mode_external(5, 2);
v->a[26] = lex_mode_external(5, 2);
v->a[27] = lex_mode_external(5, 2);
v->a[27] = lex_mode_external(192, 2);
v->a[28] = lex_mode_external(5, 2);
v->a[29] = lex_mode_external(5, 2);
v->a[30] = lex_mode_external(192, 2);
v->a[30] = lex_mode_external(5, 2);
v->a[31] = lex_mode_external(5, 2);
v->a[32] = lex_mode_external(5, 2);
v->a[32] = lex_mode_external(192, 2);
v->a[33] = lex_mode_external(5, 2);
v->a[34] = lex_mode_external(192, 2);
v->a[35] = lex_mode_external(253, 2);
v->a[36] = lex_mode_external(193, 2);
v->a[34] = lex_mode_external(5, 2);
v->a[35] = lex_mode_external(193, 2);
v->a[36] = lex_mode_external(253, 2);
v->a[37] = lex_mode_external(193, 2);
v->a[38] = lex_mode_external(193, 2);
v->a[39] = lex_mode_external(253, 2);
@ -70,15 +70,15 @@ void lex_modes_2(t_lex_modes_array *v)
v->a[43] = lex_mode_external(253, 2);
v->a[44] = lex_mode_external(253, 2);
v->a[45] = lex_mode_external(253, 2);
v->a[46] = lex_mode_external(253, 2);
v->a[46] = lex_mode_external(194, 2);
v->a[47] = lex_mode_external(253, 2);
v->a[48] = lex_mode_external(194, 2);
v->a[49] = lex_mode_external(253, 2);
v->a[48] = lex_mode_external(253, 2);
v->a[49] = lex_mode_external(195, 2);
v->a[50] = lex_mode_external(253, 2);
v->a[51] = lex_mode_external(195, 2);
v->a[51] = lex_mode_external(253, 2);
v->a[52] = lex_mode_external(253, 2);
v->a[53] = lex_mode_external(253, 2);
v->a[54] = lex_mode_external(195, 2);
v->a[54] = lex_mode_external(253, 2);
v->a[55] = lex_mode_external(253, 2);
v->a[56] = lex_mode_external(253, 2);
v->a[57] = lex_mode_external(253, 2);
@ -101,14 +101,14 @@ void lex_modes_3(t_lex_modes_array *v)
v->a[69] = lex_mode_external(253, 2);
v->a[70] = lex_mode_external(253, 2);
v->a[71] = lex_mode_external(253, 2);
v->a[72] = lex_mode_external(253, 2);
v->a[72] = lex_mode_external(194, 2);
v->a[73] = lex_mode_external(253, 2);
v->a[74] = lex_mode_external(253, 2);
v->a[75] = lex_mode_external(253, 2);
v->a[76] = lex_mode_external(253, 2);
v->a[77] = lex_mode_external(253, 2);
v->a[78] = lex_mode_external(253, 2);
v->a[79] = lex_mode_external(253, 2);
v->a[79] = lex_mode_external(194, 2);
lex_modes_4(v);
}
@ -121,7 +121,7 @@ void lex_modes_4(t_lex_modes_array *v)
v->a[84] = lex_mode_external(253, 2);
v->a[85] = lex_mode_external(253, 2);
v->a[86] = lex_mode_external(253, 2);
v->a[87] = lex_mode_external(195, 2);
v->a[87] = lex_mode_external(253, 2);
v->a[88] = lex_mode_external(253, 2);
v->a[89] = lex_mode_external(253, 2);
v->a[90] = lex_mode_external(253, 2);
@ -130,10 +130,10 @@ void lex_modes_4(t_lex_modes_array *v)
v->a[93] = lex_mode_external(253, 2);
v->a[94] = lex_mode_external(253, 2);
v->a[95] = lex_mode_external(253, 2);
v->a[96] = lex_mode_external(253, 2);
v->a[96] = lex_mode_external(195, 2);
v->a[97] = lex_mode_external(253, 2);
v->a[98] = lex_mode_external(253, 2);
v->a[99] = lex_mode_external(194, 2);
v->a[98] = lex_mode_external(195, 2);
v->a[99] = lex_mode_external(253, 2);
lex_modes_5(v);
}

74
parser/static/lex_modes/lex_modes_1.c
View file

@ -16,7 +16,7 @@ void lex_modes_5(t_lex_modes_array *v)
{
v->a[100] = lex_mode_external(253, 2);
v->a[101] = lex_mode_external(253, 2);
v->a[102] = lex_mode_external(194, 2);
v->a[102] = lex_mode_external(253, 2);
v->a[103] = lex_mode_external(253, 2);
v->a[104] = lex_mode_external(253, 2);
v->a[105] = lex_mode_external(253, 2);
@ -27,13 +27,13 @@ void lex_modes_5(t_lex_modes_array *v)
v->a[110] = lex_mode_external(253, 2);
v->a[111] = lex_mode_external(253, 2);
v->a[112] = lex_mode_external(253, 2);
v->a[113] = lex_mode_external(253, 2);
v->a[113] = lex_mode_external(195, 2);
v->a[114] = lex_mode_external(253, 2);
v->a[115] = lex_mode_external(253, 2);
v->a[116] = lex_mode_external(253, 2);
v->a[117] = lex_mode_external(193, 2);
v->a[118] = lex_mode_external(253, 2);
v->a[119] = lex_mode_external(194, 2);
v->a[117] = lex_mode_external(253, 2);
v->a[118] = lex_mode_external(193, 2);
v->a[119] = lex_mode_external(253, 2);
lex_modes_6(v);
}
@ -94,46 +94,46 @@ void lex_modes_8(t_lex_modes_array *v)
v->a[162] = lex_mode_external(204, 2);
v->a[163] = lex_mode_external(204, 2);
v->a[164] = lex_mode_external(204, 2);
v->a[165] = lex_mode_external(239, 3);
v->a[166] = lex_mode_external(107, 3);
v->a[167] = lex_mode_external(94, 4);
v->a[168] = lex_mode_external(109, 5);
v->a[169] = lex_mode_external(112, 6);
v->a[170] = lex_mode_external(239, 3);
v->a[165] = lex_mode_external(10, 3);
v->a[166] = lex_mode_external(244, 4);
v->a[167] = lex_mode_external(109, 4);
v->a[168] = lex_mode_external(244, 4);
v->a[169] = lex_mode_external(107, 5);
v->a[170] = lex_mode_external(113, 6);
v->a[171] = lex_mode_external(248, 6);
v->a[172] = lex_mode_external(248, 7);
v->a[173] = lex_mode_external(112, 7);
v->a[172] = lex_mode_external(113, 7);
v->a[173] = lex_mode_external(248, 7);
v->a[174] = lex_mode_external(248, 6);
v->a[175] = lex_mode_external(112, 7);
v->a[175] = lex_mode_external(107, 8);
v->a[176] = lex_mode_external(248, 7);
v->a[177] = lex_mode_external(109, 8);
v->a[178] = lex_mode_external(109, 8);
v->a[179] = lex_mode_external(105, 9);
v->a[177] = lex_mode_external(113, 7);
v->a[178] = lex_mode_external(107, 8);
v->a[179] = lex_mode_external(245, 9);
lex_modes_9(v);
}
void lex_modes_9(t_lex_modes_array *v)
{
v->a[180] = lex_mode_external(248, 7);
v->a[181] = lex_mode_external(246, 10);
v->a[182] = lex_mode_external(105, 9);
v->a[183] = lex_mode_external(246, 10);
v->a[184] = lex_mode_external(246, 10);
v->a[185] = lex_mode_external(246, 10);
v->a[186] = lex_mode_external(248, 7);
v->a[187] = lex_mode_external(246, 10);
v->a[188] = lex_mode_external(119, 3);
v->a[189] = lex_mode_external(246, 10);
v->a[190] = lex_mode_external(246, 10);
v->a[191] = lex_mode_external(246, 10);
v->a[192] = lex_mode_external(105, 11);
v->a[193] = lex_mode_external(246, 7);
v->a[194] = lex_mode_external(246, 12);
v->a[195] = lex_mode_external(188, 13);
v->a[196] = lex_mode_external(246, 12);
v->a[197] = lex_mode_external(246, 7);
v->a[198] = lex_mode_external(246, 7);
v->a[199] = lex_mode_external(246, 12);
v->a[180] = lex_mode_external(245, 9);
v->a[181] = lex_mode_external(248, 7);
v->a[182] = lex_mode_external(248, 7);
v->a[183] = lex_mode_external(245, 9);
v->a[184] = lex_mode_external(106, 10);
v->a[185] = lex_mode_external(245, 9);
v->a[186] = lex_mode_external(106, 10);
v->a[187] = lex_mode_external(245, 9);
v->a[188] = lex_mode_external(120, 4);
v->a[189] = lex_mode_external(245, 9);
v->a[190] = lex_mode_external(245, 9);
v->a[191] = lex_mode_external(245, 9);
v->a[192] = lex_mode_external(245, 7);
v->a[193] = lex_mode_external(245, 7);
v->a[194] = lex_mode_external(245, 11);
v->a[195] = lex_mode_external(245, 7);
v->a[196] = lex_mode_external(245, 11);
v->a[197] = lex_mode_external(245, 7);
v->a[198] = lex_mode_external(106, 12);
v->a[199] = lex_mode_external(245, 11);
lex_modes_10(v);
}

200
parser/static/lex_modes/lex_modes_10.c
View file

@ -14,126 +14,126 @@
void lex_modes_50(t_lex_modes_array *v)
{
v->a[1000] = lex_mode_external(206, 37);
v->a[1001] = lex_mode_external(206, 35);
v->a[1002] = lex_mode_external(206, 35);
v->a[1003] = lex_mode_external(205, 32);
v->a[1004] = lex_mode_external(206, 35);
v->a[1005] = lex_mode_external(206, 35);
v->a[1006] = lex_mode_external(206, 35);
v->a[1007] = lex_mode_external(206, 35);
v->a[1008] = lex_mode_external(206, 35);
v->a[1009] = lex_mode_external(206, 35);
v->a[1010] = lex_mode_external(206, 35);
v->a[1011] = lex_mode_external(206, 35);
v->a[1012] = lex_mode_external(206, 37);
v->a[1013] = lex_mode_external(206, 35);
v->a[1014] = lex_mode_external(206, 35);
v->a[1015] = lex_mode_external(206, 36);
v->a[1016] = lex_mode_external(206, 36);
v->a[1017] = lex_mode_external(205, 32);
v->a[1018] = lex_mode_external(206, 36);
v->a[1019] = lex_mode_external(206, 36);
v->a[1000] = lex_mode_external(198, 38);
v->a[1001] = lex_mode_external(247, 40);
v->a[1002] = lex_mode_external(241, 23);
v->a[1003] = lex_mode_external(241, 14);
v->a[1004] = lex_mode_external(241, 30);
v->a[1005] = lex_mode_external(241, 24);
v->a[1006] = lex_mode_external(241, 15);
v->a[1007] = lex_mode_external(241, 24);
v->a[1008] = lex_mode_external(241, 14);
v->a[1009] = lex_mode_external(241, 24);
v->a[1010] = lex_mode_external(242, 15);
v->a[1011] = lex_mode_external(247, 40);
v->a[1012] = lex_mode_external(242, 15);
v->a[1013] = lex_mode_external(242, 15);
v->a[1014] = lex_mode_external(247, 40);
v->a[1015] = lex_mode_external(242, 15);
v->a[1016] = lex_mode_external(247, 40);
v->a[1017] = lex_mode_external(247, 40);
v->a[1018] = lex_mode_external(242, 15);
v->a[1019] = lex_mode_external(242, 15);
lex_modes_51(v);
}
void lex_modes_51(t_lex_modes_array *v)
{
v->a[1020] = lex_mode_external(206, 36);
v->a[1021] = lex_mode_external(206, 36);
v->a[1022] = lex_mode_external(199, 17);
v->a[1023] = lex_mode_external(206, 36);
v->a[1024] = lex_mode_external(206, 36);
v->a[1025] = lex_mode_external(206, 36);
v->a[1026] = lex_mode_external(206, 36);
v->a[1027] = lex_mode_external(206, 36);
v->a[1028] = lex_mode_external(206, 37);
v->a[1029] = lex_mode_external(206, 35);
v->a[1030] = lex_mode_external(206, 35);
v->a[1031] = lex_mode_external(206, 36);
v->a[1032] = lex_mode_external(199, 17);
v->a[1033] = lex_mode_external(206, 36);
v->a[1034] = lex_mode_external(205, 32);
v->a[1035] = lex_mode_external(206, 37);
v->a[1036] = lex_mode_external(243, 23);
v->a[1037] = lex_mode_external(198, 38);
v->a[1038] = lex_mode_external(206, 37);
v->a[1039] = lex_mode_external(206, 37);
v->a[1020] = lex_mode_external(247, 40);
v->a[1021] = lex_mode_external(242, 15);
v->a[1022] = lex_mode_external(242, 15);
v->a[1023] = lex_mode_external(242, 15);
v->a[1024] = lex_mode_external(242, 15);
v->a[1025] = lex_mode_external(242, 15);
v->a[1026] = lex_mode_external(241, 14);
v->a[1027] = lex_mode_external(242, 15);
v->a[1028] = lex_mode_external(247, 40);
v->a[1029] = lex_mode_external(247, 40);
v->a[1030] = lex_mode_external(247, 40);
v->a[1031] = lex_mode_external(241, 15);
v->a[1032] = lex_mode_external(247, 40);
v->a[1033] = lex_mode_external(247, 40);
v->a[1034] = lex_mode_external(247, 40);
v->a[1035] = lex_mode_external(241, 15);
v->a[1036] = lex_mode_external(247, 40);
v->a[1037] = lex_mode_external(241, 15);
v->a[1038] = lex_mode_external(247, 40);
v->a[1039] = lex_mode_external(247, 40);
lex_modes_52(v);
}
void lex_modes_52(t_lex_modes_array *v)
{
v->a[1040] = lex_mode_external(206, 37);
v->a[1041] = lex_mode_external(198, 38);
v->a[1042] = lex_mode_external(198, 38);
v->a[1043] = lex_mode_external(198, 38);
v->a[1044] = lex_mode_external(198, 38);
v->a[1045] = lex_mode_external(198, 38);
v->a[1046] = lex_mode_external(198, 38);
v->a[1047] = lex_mode_external(198, 38);
v->a[1048] = lex_mode_external(198, 38);
v->a[1049] = lex_mode_external(198, 38);
v->a[1050] = lex_mode_external(198, 38);
v->a[1051] = lex_mode_external(198, 38);
v->a[1052] = lex_mode_external(198, 38);
v->a[1053] = lex_mode_external(198, 38);
v->a[1054] = lex_mode_external(198, 38);
v->a[1055] = lex_mode_external(198, 38);
v->a[1056] = lex_mode_external(206, 37);
v->a[1057] = lex_mode_external(206, 37);
v->a[1058] = lex_mode_external(206, 37);
v->a[1059] = lex_mode_external(198, 38);
v->a[1040] = lex_mode_external(241, 30);
v->a[1041] = lex_mode_external(241, 15);
v->a[1042] = lex_mode_external(241, 23);
v->a[1043] = lex_mode_external(241, 15);
v->a[1044] = lex_mode_external(241, 14);
v->a[1045] = lex_mode_external(241, 14);
v->a[1046] = lex_mode_external(241, 14);
v->a[1047] = lex_mode_external(241, 14);
v->a[1048] = lex_mode_external(241, 14);
v->a[1049] = lex_mode_external(241, 14);
v->a[1050] = lex_mode_external(241, 15);
v->a[1051] = lex_mode_external(241, 15);
v->a[1052] = lex_mode_external(241, 23);
v->a[1053] = lex_mode_external(241, 30);
v->a[1054] = lex_mode_external(241, 15);
v->a[1055] = lex_mode_external(241, 15);
v->a[1056] = lex_mode_external(241, 15);
v->a[1057] = lex_mode_external(242, 15);
v->a[1058] = lex_mode_external(241, 15);
v->a[1059] = lex_mode_external(241, 15);
lex_modes_53(v);
}
void lex_modes_53(t_lex_modes_array *v)
{
v->a[1060] = lex_mode_external(198, 38);
v->a[1061] = lex_mode_external(198, 38);
v->a[1062] = lex_mode_external(206, 37);
v->a[1063] = lex_mode_external(198, 38);
v->a[1064] = lex_mode_external(205, 32);
v->a[1065] = lex_mode_external(198, 38);
v->a[1066] = lex_mode_external(198, 38);
v->a[1067] = lex_mode_external(198, 38);
v->a[1068] = lex_mode_external(198, 38);
v->a[1069] = lex_mode_external(198, 38);
v->a[1070] = lex_mode_external(205, 21);
v->a[1071] = lex_mode_external(198, 38);
v->a[1072] = lex_mode_external(198, 38);
v->a[1073] = lex_mode_external(198, 38);
v->a[1074] = lex_mode_external(206, 37);
v->a[1075] = lex_mode_external(198, 38);
v->a[1076] = lex_mode_external(206, 37);
v->a[1077] = lex_mode_external(205, 32);
v->a[1078] = lex_mode_external(206, 37);
v->a[1079] = lex_mode_external(206, 37);
v->a[1060] = lex_mode_external(241, 15);
v->a[1061] = lex_mode_external(241, 30);
v->a[1062] = lex_mode_external(241, 15);
v->a[1063] = lex_mode_external(241, 15);
v->a[1064] = lex_mode_external(241, 14);
v->a[1065] = lex_mode_external(241, 23);
v->a[1066] = lex_mode_external(241, 15);
v->a[1067] = lex_mode_external(241, 15);
v->a[1068] = lex_mode_external(241, 15);
v->a[1069] = lex_mode_external(241, 15);
v->a[1070] = lex_mode_external(241, 15);
v->a[1071] = lex_mode_external(241, 14);
v->a[1072] = lex_mode_external(241, 15);
v->a[1073] = lex_mode_external(241, 14);
v->a[1074] = lex_mode_external(241, 15);
v->a[1075] = lex_mode_external(241, 30);
v->a[1076] = lex_mode_external(241, 30);
v->a[1077] = lex_mode_external(241, 30);
v->a[1078] = lex_mode_external(241, 30);
v->a[1079] = lex_mode_external(241, 30);
lex_modes_54(v);
}
void lex_modes_54(t_lex_modes_array *v)
{
v->a[1080] = lex_mode_external(206, 37);
v->a[1081] = lex_mode_external(206, 37);
v->a[1082] = lex_mode_external(198, 38);
v->a[1083] = lex_mode_external(243, 23);
v->a[1084] = lex_mode_external(247, 39);
v->a[1085] = lex_mode_external(243, 23);
v->a[1086] = lex_mode_external(243, 23);
v->a[1087] = lex_mode_external(243, 23);
v->a[1088] = lex_mode_external(243, 23);
v->a[1089] = lex_mode_external(243, 23);
v->a[1090] = lex_mode_external(205, 17);
v->a[1091] = lex_mode_external(114, 40);
v->a[1092] = lex_mode_external(243, 23);
v->a[1093] = lex_mode_external(205, 17);
v->a[1094] = lex_mode_external(243, 23);
v->a[1095] = lex_mode_external(243, 23);
v->a[1096] = lex_mode_external(243, 23);
v->a[1097] = lex_mode_external(198, 38);
v->a[1098] = lex_mode_external(243, 23);
v->a[1099] = lex_mode_external(247, 39);
v->a[1080] = lex_mode_external(241, 30);
v->a[1081] = lex_mode_external(241, 30);
v->a[1082] = lex_mode_external(241, 23);
v->a[1083] = lex_mode_external(241, 23);
v->a[1084] = lex_mode_external(241, 15);
v->a[1085] = lex_mode_external(241, 30);
v->a[1086] = lex_mode_external(241, 14);
v->a[1087] = lex_mode_external(241, 15);
v->a[1088] = lex_mode_external(241, 15);
v->a[1089] = lex_mode_external(241, 30);
v->a[1090] = lex_mode_external(241, 23);
v->a[1091] = lex_mode_external(241, 30);
v->a[1092] = lex_mode_external(206, 41);
v->a[1093] = lex_mode_external(241, 7);
v->a[1094] = lex_mode_external(241, 14);
v->a[1095] = lex_mode_external(241, 15);
v->a[1096] = lex_mode_external(241, 14);
v->a[1097] = lex_mode_external(241, 14);
v->a[1098] = lex_mode_external(241, 14);
v->a[1099] = lex_mode_external(241, 8);
lex_modes_55(v);
}

200
parser/static/lex_modes/lex_modes_11.c
View file

@ -14,126 +14,126 @@
void lex_modes_55(t_lex_modes_array *v)
{
v->a[1100] = lex_mode_external(114, 40);
v->a[1101] = lex_mode_external(247, 39);
v->a[1102] = lex_mode_external(114, 40);
v->a[1103] = lex_mode_external(198, 38);
v->a[1104] = lex_mode_external(198, 38);
v->a[1105] = lex_mode_external(198, 38);
v->a[1106] = lex_mode_external(205, 17);
v->a[1107] = lex_mode_external(114, 40);
v->a[1108] = lex_mode_external(243, 28);
v->a[1109] = lex_mode_external(205, 29);
v->a[1110] = lex_mode_external(243, 23);
v->a[1111] = lex_mode_external(205, 17);
v->a[1112] = lex_mode_external(243, 23);
v->a[1113] = lex_mode_external(243, 23);
v->a[1114] = lex_mode_external(205, 29);
v->a[1115] = lex_mode_external(198, 38);
v->a[1116] = lex_mode_external(198, 38);
v->a[1117] = lex_mode_external(198, 38);
v->a[1118] = lex_mode_external(198, 38);
v->a[1119] = lex_mode_external(198, 38);
v->a[1100] = lex_mode_external(205, 32);
v->a[1101] = lex_mode_external(242, 7);
v->a[1102] = lex_mode_external(241, 15);
v->a[1103] = lex_mode_external(241, 24);
v->a[1104] = lex_mode_external(241, 24);
v->a[1105] = lex_mode_external(206, 41);
v->a[1106] = lex_mode_external(241, 24);
v->a[1107] = lex_mode_external(241, 15);
v->a[1108] = lex_mode_external(241, 24);
v->a[1109] = lex_mode_external(206, 41);
v->a[1110] = lex_mode_external(241, 15);
v->a[1111] = lex_mode_external(241, 30);
v->a[1112] = lex_mode_external(241, 15);
v->a[1113] = lex_mode_external(241, 14);
v->a[1114] = lex_mode_external(241, 15);
v->a[1115] = lex_mode_external(241, 30);
v->a[1116] = lex_mode_external(241, 15);
v->a[1117] = lex_mode_external(241, 15);
v->a[1118] = lex_mode_external(241, 30);
v->a[1119] = lex_mode_external(241, 15);
lex_modes_56(v);
}
void lex_modes_56(t_lex_modes_array *v)
{
v->a[1120] = lex_mode_external(198, 38);
v->a[1121] = lex_mode_external(198, 38);
v->a[1122] = lex_mode_external(198, 38);
v->a[1123] = lex_mode_external(198, 38);
v->a[1124] = lex_mode_external(205, 17);
v->a[1125] = lex_mode_external(198, 38);
v->a[1126] = lex_mode_external(198, 38);
v->a[1127] = lex_mode_external(198, 38);
v->a[1128] = lex_mode_external(198, 38);
v->a[1129] = lex_mode_external(198, 38);
v->a[1130] = lex_mode_external(114, 40);
v->a[1131] = lex_mode_external(198, 38);
v->a[1132] = lex_mode_external(198, 38);
v->a[1133] = lex_mode_external(198, 38);
v->a[1134] = lex_mode_external(198, 38);
v->a[1135] = lex_mode_external(198, 38);
v->a[1136] = lex_mode_external(198, 38);
v->a[1137] = lex_mode_external(198, 38);
v->a[1138] = lex_mode_external(198, 38);
v->a[1139] = lex_mode_external(114, 40);
v->a[1120] = lex_mode_external(241, 24);
v->a[1121] = lex_mode_external(241, 24);
v->a[1122] = lex_mode_external(241, 24);
v->a[1123] = lex_mode_external(241, 14);
v->a[1124] = lex_mode_external(241, 24);
v->a[1125] = lex_mode_external(241, 24);
v->a[1126] = lex_mode_external(126, 42);
v->a[1127] = lex_mode_external(241, 24);
v->a[1128] = lex_mode_external(206, 41);
v->a[1129] = lex_mode_external(241, 30);
v->a[1130] = lex_mode_external(241, 15);
v->a[1131] = lex_mode_external(241, 7);
v->a[1132] = lex_mode_external(241, 24);
v->a[1133] = lex_mode_external(241, 15);
v->a[1134] = lex_mode_external(241, 30);
v->a[1135] = lex_mode_external(241, 15);
v->a[1136] = lex_mode_external(241, 8);
v->a[1137] = lex_mode_external(241, 15);
v->a[1138] = lex_mode_external(241, 30);
v->a[1139] = lex_mode_external(206, 41);
lex_modes_57(v);
}
void lex_modes_57(t_lex_modes_array *v)
{
v->a[1140] = lex_mode_external(198, 38);
v->a[1141] = lex_mode_external(198, 38);
v->a[1142] = lex_mode_external(123, 25);
v->a[1143] = lex_mode_external(198, 38);
v->a[1144] = lex_mode_external(198, 38);
v->a[1145] = lex_mode_external(198, 38);
v->a[1146] = lex_mode_external(198, 38);
v->a[1147] = lex_mode_external(198, 38);
v->a[1148] = lex_mode_external(198, 38);
v->a[1149] = lex_mode_external(198, 38);
v->a[1150] = lex_mode_external(243, 28);
v->a[1151] = lex_mode_external(243, 23);
v->a[1152] = lex_mode_external(243, 27);
v->a[1153] = lex_mode_external(243, 23);
v->a[1154] = lex_mode_external(243, 23);
v->a[1155] = lex_mode_external(243, 27);
v->a[1156] = lex_mode_external(243, 27);
v->a[1157] = lex_mode_external(243, 23);
v->a[1158] = lex_mode_external(247, 39);
v->a[1159] = lex_mode_external(247, 39);
v->a[1140] = lex_mode_external(241, 15);
v->a[1141] = lex_mode_external(241, 15);
v->a[1142] = lex_mode_external(242, 7);
v->a[1143] = lex_mode_external(241, 7);
v->a[1144] = lex_mode_external(241, 15);
v->a[1145] = lex_mode_external(241, 15);
v->a[1146] = lex_mode_external(241, 15);
v->a[1147] = lex_mode_external(241, 15);
v->a[1148] = lex_mode_external(242, 7);
v->a[1149] = lex_mode_external(241, 24);
v->a[1150] = lex_mode_external(241, 23);
v->a[1151] = lex_mode_external(241, 15);
v->a[1152] = lex_mode_external(241, 30);
v->a[1153] = lex_mode_external(241, 15);
v->a[1154] = lex_mode_external(241, 15);
v->a[1155] = lex_mode_external(241, 15);
v->a[1156] = lex_mode_external(241, 30);
v->a[1157] = lex_mode_external(242, 15);
v->a[1158] = lex_mode_external(241, 28);
v->a[1159] = lex_mode_external(241, 23);
lex_modes_58(v);
}
void lex_modes_58(t_lex_modes_array *v)
{
v->a[1160] = lex_mode_external(247, 39);
v->a[1161] = lex_mode_external(247, 39);
v->a[1162] = lex_mode_external(247, 39);
v->a[1163] = lex_mode_external(247, 39);
v->a[1164] = lex_mode_external(247, 39);
v->a[1165] = lex_mode_external(247, 39);
v->a[1166] = lex_mode_external(247, 39);
v->a[1167] = lex_mode_external(247, 39);
v->a[1168] = lex_mode_external(247, 39);
v->a[1169] = lex_mode_external(247, 39);
v->a[1170] = lex_mode_external(247, 39);
v->a[1171] = lex_mode_external(247, 39);
v->a[1172] = lex_mode_external(243, 23);
v->a[1173] = lex_mode_external(243, 28);
v->a[1174] = lex_mode_external(243, 28);
v->a[1175] = lex_mode_external(243, 28);
v->a[1176] = lex_mode_external(243, 28);
v->a[1177] = lex_mode_external(243, 28);
v->a[1178] = lex_mode_external(243, 28);
v->a[1179] = lex_mode_external(243, 23);
v->a[1160] = lex_mode_external(241, 28);
v->a[1161] = lex_mode_external(241, 15);
v->a[1162] = lex_mode_external(241, 15);
v->a[1163] = lex_mode_external(241, 7);
v->a[1164] = lex_mode_external(241, 15);
v->a[1165] = lex_mode_external(241, 15);
v->a[1166] = lex_mode_external(242, 15);
v->a[1167] = lex_mode_external(206, 41);
v->a[1168] = lex_mode_external(241, 15);
v->a[1169] = lex_mode_external(241, 28);
v->a[1170] = lex_mode_external(242, 15);
v->a[1171] = lex_mode_external(241, 30);
v->a[1172] = lex_mode_external(241, 24);
v->a[1173] = lex_mode_external(241, 28);
v->a[1174] = lex_mode_external(241, 15);
v->a[1175] = lex_mode_external(241, 15);
v->a[1176] = lex_mode_external(242, 15);
v->a[1177] = lex_mode_external(241, 24);
v->a[1178] = lex_mode_external(242, 15);
v->a[1179] = lex_mode_external(242, 15);
lex_modes_59(v);
}
void lex_modes_59(t_lex_modes_array *v)
{
v->a[1180] = lex_mode_external(243, 28);
v->a[1181] = lex_mode_external(243, 28);
v->a[1182] = lex_mode_external(243, 28);
v->a[1183] = lex_mode_external(243, 28);
v->a[1184] = lex_mode_external(243, 28);
v->a[1185] = lex_mode_external(243, 28);
v->a[1186] = lex_mode_external(243, 28);
v->a[1187] = lex_mode_external(243, 14);
v->a[1188] = lex_mode_external(243, 14);
v->a[1189] = lex_mode_external(243, 28);
v->a[1190] = lex_mode_external(243, 28);
v->a[1191] = lex_mode_external(243, 30);
v->a[1192] = lex_mode_external(243, 30);
v->a[1193] = lex_mode_external(243, 30);
v->a[1194] = lex_mode_external(243, 28);
v->a[1195] = lex_mode_external(243, 23);
v->a[1196] = lex_mode_external(243, 14);
v->a[1197] = lex_mode_external(243, 27);
v->a[1198] = lex_mode_external(244, 7);
v->a[1199] = lex_mode_external(244, 7);
v->a[1180] = lex_mode_external(241, 15);
v->a[1181] = lex_mode_external(242, 15);
v->a[1182] = lex_mode_external(242, 15);
v->a[1183] = lex_mode_external(206, 41);
v->a[1184] = lex_mode_external(242, 15);
v->a[1185] = lex_mode_external(241, 30);
v->a[1186] = lex_mode_external(241, 30);
v->a[1187] = lex_mode_external(242, 15);
v->a[1188] = lex_mode_external(241, 15);
v->a[1189] = lex_mode_external(241, 15);
v->a[1190] = lex_mode_external(242, 15);
v->a[1191] = lex_mode_external(241, 15);
v->a[1192] = lex_mode_external(205, 32);
v->a[1193] = lex_mode_external(205, 32);
v->a[1194] = lex_mode_external(241, 15);
v->a[1195] = lex_mode_external(241, 14);
v->a[1196] = lex_mode_external(242, 15);
v->a[1197] = lex_mode_external(242, 15);
v->a[1198] = lex_mode_external(241, 28);
v->a[1199] = lex_mode_external(241, 28);
lex_modes_60(v);
}

200
parser/static/lex_modes/lex_modes_12.c
View file

@ -14,126 +14,126 @@
void lex_modes_60(t_lex_modes_array *v)
{
v->a[1200] = lex_mode_external(206, 41);
v->a[1201] = lex_mode_external(206, 41);
v->a[1202] = lex_mode_external(243, 27);
v->a[1203] = lex_mode_external(243, 27);
v->a[1204] = lex_mode_external(243, 7);
v->a[1205] = lex_mode_external(243, 14);
v->a[1206] = lex_mode_external(243, 14);
v->a[1207] = lex_mode_external(243, 7);
v->a[1208] = lex_mode_external(243, 7);
v->a[1209] = lex_mode_external(243, 14);
v->a[1210] = lex_mode_external(243, 14);
v->a[1211] = lex_mode_external(244, 14);
v->a[1212] = lex_mode_external(243, 14);
v->a[1213] = lex_mode_external(243, 28);
v->a[1214] = lex_mode_external(243, 15);
v->a[1215] = lex_mode_external(243, 14);
v->a[1216] = lex_mode_external(243, 8);
v->a[1217] = lex_mode_external(243, 15);
v->a[1218] = lex_mode_external(243, 15);
v->a[1219] = lex_mode_external(243, 15);
v->a[1200] = lex_mode_external(241, 15);
v->a[1201] = lex_mode_external(242, 15);
v->a[1202] = lex_mode_external(241, 28);
v->a[1203] = lex_mode_external(242, 15);
v->a[1204] = lex_mode_external(242, 15);
v->a[1205] = lex_mode_external(242, 15);
v->a[1206] = lex_mode_external(242, 15);
v->a[1207] = lex_mode_external(242, 15);
v->a[1208] = lex_mode_external(241, 28);
v->a[1209] = lex_mode_external(241, 28);
v->a[1210] = lex_mode_external(242, 15);
v->a[1211] = lex_mode_external(242, 15);
v->a[1212] = lex_mode_external(241, 28);
v->a[1213] = lex_mode_external(242, 15);
v->a[1214] = lex_mode_external(242, 15);
v->a[1215] = lex_mode_external(241, 14);
v->a[1216] = lex_mode_external(241, 15);
v->a[1217] = lex_mode_external(242, 15);
v->a[1218] = lex_mode_external(241, 15);
v->a[1219] = lex_mode_external(241, 15);
lex_modes_61(v);
}
void lex_modes_61(t_lex_modes_array *v)
{
v->a[1220] = lex_mode_external(243, 15);
v->a[1221] = lex_mode_external(243, 15);
v->a[1222] = lex_mode_external(243, 15);
v->a[1223] = lex_mode_external(244, 14);
v->a[1224] = lex_mode_external(244, 14);
v->a[1225] = lex_mode_external(206, 41);
v->a[1226] = lex_mode_external(244, 14);
v->a[1227] = lex_mode_external(243, 15);
v->a[1228] = lex_mode_external(243, 28);
v->a[1229] = lex_mode_external(243, 15);
v->a[1230] = lex_mode_external(243, 15);
v->a[1231] = lex_mode_external(244, 14);
v->a[1232] = lex_mode_external(243, 15);
v->a[1233] = lex_mode_external(243, 15);
v->a[1234] = lex_mode_external(243, 15);
v->a[1235] = lex_mode_external(206, 41);
v->a[1236] = lex_mode_external(244, 7);
v->a[1237] = lex_mode_external(243, 14);
v->a[1238] = lex_mode_external(244, 14);
v->a[1239] = lex_mode_external(244, 14);
v->a[1220] = lex_mode_external(242, 15);
v->a[1221] = lex_mode_external(241, 28);
v->a[1222] = lex_mode_external(242, 15);
v->a[1223] = lex_mode_external(241, 15);
v->a[1224] = lex_mode_external(242, 15);
v->a[1225] = lex_mode_external(242, 15);
v->a[1226] = lex_mode_external(242, 15);
v->a[1227] = lex_mode_external(241, 28);
v->a[1228] = lex_mode_external(242, 15);
v->a[1229] = lex_mode_external(242, 15);
v->a[1230] = lex_mode_external(242, 15);
v->a[1231] = lex_mode_external(242, 15);
v->a[1232] = lex_mode_external(242, 15);
v->a[1233] = lex_mode_external(242, 15);
v->a[1234] = lex_mode_external(241, 28);
v->a[1235] = lex_mode_external(241, 15);
v->a[1236] = lex_mode_external(242, 15);
v->a[1237] = lex_mode_external(241, 28);
v->a[1238] = lex_mode_external(242, 15);
v->a[1239] = lex_mode_external(241, 15);
lex_modes_62(v);
}
void lex_modes_62(t_lex_modes_array *v)
{
v->a[1240] = lex_mode_external(243, 14);
v->a[1241] = lex_mode_external(205, 32);
v->a[1242] = lex_mode_external(243, 14);
v->a[1243] = lex_mode_external(243, 14);
v->a[1244] = lex_mode_external(243, 14);
v->a[1245] = lex_mode_external(243, 14);
v->a[1246] = lex_mode_external(244, 14);
v->a[1247] = lex_mode_external(243, 28);
v->a[1248] = lex_mode_external(244, 14);
v->a[1249] = lex_mode_external(244, 14);
v->a[1250] = lex_mode_external(243, 28);
v->a[1251] = lex_mode_external(244, 14);
v->a[1252] = lex_mode_external(244, 14);
v->a[1253] = lex_mode_external(244, 14);
v->a[1254] = lex_mode_external(244, 14);
v->a[1255] = lex_mode_external(244, 14);
v->a[1256] = lex_mode_external(244, 14);
v->a[1257] = lex_mode_external(243, 14);
v->a[1258] = lex_mode_external(243, 14);
v->a[1259] = lex_mode_external(244, 14);
v->a[1240] = lex_mode_external(242, 15);
v->a[1241] = lex_mode_external(242, 15);
v->a[1242] = lex_mode_external(241, 28);
v->a[1243] = lex_mode_external(241, 28);
v->a[1244] = lex_mode_external(242, 15);
v->a[1245] = lex_mode_external(206, 41);
v->a[1246] = lex_mode_external(241, 15);
v->a[1247] = lex_mode_external(205, 32);
v->a[1248] = lex_mode_external(206, 41);
v->a[1249] = lex_mode_external(241, 14);
v->a[1250] = lex_mode_external(241, 28);
v->a[1251] = lex_mode_external(241, 30);
v->a[1252] = lex_mode_external(242, 15);
v->a[1253] = lex_mode_external(242, 15);
v->a[1254] = lex_mode_external(242, 15);
v->a[1255] = lex_mode_external(242, 15);
v->a[1256] = lex_mode_external(241, 15);
v->a[1257] = lex_mode_external(206, 41);
v->a[1258] = lex_mode_external(242, 15);
v->a[1259] = lex_mode_external(242, 15);
lex_modes_63(v);
}
void lex_modes_63(t_lex_modes_array *v)
{
v->a[1260] = lex_mode_external(206, 41);
v->a[1261] = lex_mode_external(243, 14);
v->a[1262] = lex_mode_external(243, 30);
v->a[1263] = lex_mode_external(243, 14);
v->a[1264] = lex_mode_external(243, 14);
v->a[1265] = lex_mode_external(243, 14);
v->a[1266] = lex_mode_external(243, 14);
v->a[1267] = lex_mode_external(243, 14);
v->a[1268] = lex_mode_external(243, 14);
v->a[1269] = lex_mode_external(243, 15);
v->a[1270] = lex_mode_external(243, 28);
v->a[1271] = lex_mode_external(243, 15);
v->a[1272] = lex_mode_external(126, 42);
v->a[1273] = lex_mode_external(243, 15);
v->a[1274] = lex_mode_external(243, 8);
v->a[1275] = lex_mode_external(243, 27);
v->a[1276] = lex_mode_external(243, 28);
v->a[1277] = lex_mode_external(243, 14);
v->a[1278] = lex_mode_external(243, 27);
v->a[1279] = lex_mode_external(243, 27);
v->a[1260] = lex_mode_external(242, 15);
v->a[1261] = lex_mode_external(242, 15);
v->a[1262] = lex_mode_external(242, 15);
v->a[1263] = lex_mode_external(242, 15);
v->a[1264] = lex_mode_external(241, 15);
v->a[1265] = lex_mode_external(241, 15);
v->a[1266] = lex_mode_external(241, 15);
v->a[1267] = lex_mode_external(205, 32);
v->a[1268] = lex_mode_external(242, 15);
v->a[1269] = lex_mode_external(241, 15);
v->a[1270] = lex_mode_external(241, 7);
v->a[1271] = lex_mode_external(205, 32);
v->a[1272] = lex_mode_external(206, 41);
v->a[1273] = lex_mode_external(242, 15);
v->a[1274] = lex_mode_external(242, 15);
v->a[1275] = lex_mode_external(242, 15);
v->a[1276] = lex_mode_external(206, 41);
v->a[1277] = lex_mode_external(242, 15);
v->a[1278] = lex_mode_external(242, 15);
v->a[1279] = lex_mode_external(242, 15);
lex_modes_64(v);
}
void lex_modes_64(t_lex_modes_array *v)
{
v->a[1280] = lex_mode_external(206, 41);
v->a[1281] = lex_mode_external(243, 27);
v->a[1282] = lex_mode_external(243, 27);
v->a[1283] = lex_mode_external(243, 14);
v->a[1284] = lex_mode_external(243, 14);
v->a[1285] = lex_mode_external(243, 7);
v->a[1286] = lex_mode_external(243, 23);
v->a[1287] = lex_mode_external(243, 27);
v->a[1288] = lex_mode_external(243, 27);
v->a[1289] = lex_mode_external(243, 14);
v->a[1290] = lex_mode_external(243, 14);
v->a[1291] = lex_mode_external(243, 27);
v->a[1292] = lex_mode_external(243, 27);
v->a[1293] = lex_mode_external(243, 27);
v->a[1294] = lex_mode_external(243, 14);
v->a[1295] = lex_mode_external(243, 14);
v->a[1296] = lex_mode_external(243, 15);
v->a[1297] = lex_mode_external(244, 14);
v->a[1298] = lex_mode_external(243, 27);
v->a[1299] = lex_mode_external(243, 14);
v->a[1280] = lex_mode_external(242, 15);
v->a[1281] = lex_mode_external(206, 41);
v->a[1282] = lex_mode_external(242, 15);
v->a[1283] = lex_mode_external(242, 15);
v->a[1284] = lex_mode_external(206, 41);
v->a[1285] = lex_mode_external(241, 7);
v->a[1286] = lex_mode_external(205, 32);
v->a[1287] = lex_mode_external(241, 28);
v->a[1288] = lex_mode_external(206, 41);
v->a[1289] = lex_mode_external(241, 15);
v->a[1290] = lex_mode_external(205, 32);
v->a[1291] = lex_mode_external(242, 15);
v->a[1292] = lex_mode_external(206, 41);
v->a[1293] = lex_mode_external(206, 41);
v->a[1294] = lex_mode_external(206, 41);
v->a[1295] = lex_mode_external(206, 41);
v->a[1296] = lex_mode_external(206, 41);
v->a[1297] = lex_mode_external(242, 15);
v->a[1298] = lex_mode_external(242, 15);
v->a[1299] = lex_mode_external(207, 43);
lex_modes_65(v);
}

200
parser/static/lex_modes/lex_modes_13.c
View file

@ -14,126 +14,126 @@
void lex_modes_65(t_lex_modes_array *v)
{
v->a[1300] = lex_mode_external(243, 14);
v->a[1301] = lex_mode_external(243, 14);
v->a[1302] = lex_mode_external(243, 14);
v->a[1303] = lex_mode_external(206, 41);
v->a[1304] = lex_mode_external(244, 14);
v->a[1305] = lex_mode_external(206, 41);
v->a[1306] = lex_mode_external(244, 14);
v->a[1307] = lex_mode_external(244, 14);
v->a[1308] = lex_mode_external(244, 14);
v->a[1309] = lex_mode_external(244, 14);
v->a[1310] = lex_mode_external(243, 14);
v->a[1311] = lex_mode_external(206, 41);
v->a[1312] = lex_mode_external(243, 14);
v->a[1313] = lex_mode_external(206, 41);
v->a[1314] = lex_mode_external(243, 14);
v->a[1315] = lex_mode_external(244, 14);
v->a[1316] = lex_mode_external(244, 14);
v->a[1317] = lex_mode_external(243, 14);
v->a[1318] = lex_mode_external(244, 14);
v->a[1319] = lex_mode_external(244, 14);
v->a[1300] = lex_mode_external(207, 43);
v->a[1301] = lex_mode_external(241, 15);
v->a[1302] = lex_mode_external(242, 15);
v->a[1303] = lex_mode_external(241, 15);
v->a[1304] = lex_mode_external(241, 15);
v->a[1305] = lex_mode_external(241, 8);
v->a[1306] = lex_mode_external(207, 43);
v->a[1307] = lex_mode_external(241, 15);
v->a[1308] = lex_mode_external(207, 43);
v->a[1309] = lex_mode_external(241, 15);
v->a[1310] = lex_mode_external(242, 15);
v->a[1311] = lex_mode_external(241, 14);
v->a[1312] = lex_mode_external(207, 43);
v->a[1313] = lex_mode_external(207, 43);
v->a[1314] = lex_mode_external(241, 15);
v->a[1315] = lex_mode_external(241, 15);
v->a[1316] = lex_mode_external(241, 14);
v->a[1317] = lex_mode_external(241, 14);
v->a[1318] = lex_mode_external(205, 44);
v->a[1319] = lex_mode_external(205, 44);
lex_modes_66(v);
}
void lex_modes_66(t_lex_modes_array *v)
{
v->a[1320] = lex_mode_external(243, 14);
v->a[1321] = lex_mode_external(243, 15);
v->a[1322] = lex_mode_external(243, 14);
v->a[1323] = lex_mode_external(244, 14);
v->a[1324] = lex_mode_external(243, 14);
v->a[1325] = lex_mode_external(244, 14);
v->a[1326] = lex_mode_external(244, 14);
v->a[1327] = lex_mode_external(244, 14);
v->a[1328] = lex_mode_external(244, 14);
v->a[1329] = lex_mode_external(244, 14);
v->a[1330] = lex_mode_external(244, 14);
v->a[1331] = lex_mode_external(243, 14);
v->a[1332] = lex_mode_external(244, 14);
v->a[1333] = lex_mode_external(244, 14);
v->a[1334] = lex_mode_external(243, 28);
v->a[1335] = lex_mode_external(244, 14);
v->a[1336] = lex_mode_external(243, 14);
v->a[1337] = lex_mode_external(243, 15);
v->a[1338] = lex_mode_external(243, 28);
v->a[1339] = lex_mode_external(205, 32);
v->a[1320] = lex_mode_external(241, 14);
v->a[1321] = lex_mode_external(241, 14);
v->a[1322] = lex_mode_external(241, 14);
v->a[1323] = lex_mode_external(118, 45);
v->a[1324] = lex_mode_external(241, 14);
v->a[1325] = lex_mode_external(241, 14);
v->a[1326] = lex_mode_external(241, 15);
v->a[1327] = lex_mode_external(205, 32);
v->a[1328] = lex_mode_external(241, 14);
v->a[1329] = lex_mode_external(241, 23);
v->a[1330] = lex_mode_external(241, 14);
v->a[1331] = lex_mode_external(241, 14);
v->a[1332] = lex_mode_external(241, 14);
v->a[1333] = lex_mode_external(241, 14);
v->a[1334] = lex_mode_external(241, 14);
v->a[1335] = lex_mode_external(241, 14);
v->a[1336] = lex_mode_external(205, 32);
v->a[1337] = lex_mode_external(241, 14);
v->a[1338] = lex_mode_external(205, 44);
v->a[1339] = lex_mode_external(241, 14);
lex_modes_67(v);
}
void lex_modes_67(t_lex_modes_array *v)
{
v->a[1340] = lex_mode_external(243, 14);
v->a[1341] = lex_mode_external(244, 14);
v->a[1342] = lex_mode_external(244, 14);
v->a[1343] = lex_mode_external(244, 14);
v->a[1344] = lex_mode_external(244, 14);
v->a[1345] = lex_mode_external(244, 14);
v->a[1346] = lex_mode_external(206, 41);
v->a[1347] = lex_mode_external(243, 30);
v->a[1348] = lex_mode_external(244, 14);
v->a[1349] = lex_mode_external(205, 32);
v->a[1350] = lex_mode_external(243, 30);
v->a[1351] = lex_mode_external(243, 30);
v->a[1352] = lex_mode_external(243, 30);
v->a[1353] = lex_mode_external(206, 41);
v->a[1354] = lex_mode_external(243, 30);
v->a[1355] = lex_mode_external(244, 14);
v->a[1356] = lex_mode_external(244, 14);
v->a[1357] = lex_mode_external(244, 14);
v->a[1358] = lex_mode_external(243, 30);
v->a[1359] = lex_mode_external(243, 14);
v->a[1340] = lex_mode_external(241, 14);
v->a[1341] = lex_mode_external(205, 32);
v->a[1342] = lex_mode_external(241, 14);
v->a[1343] = lex_mode_external(205, 32);
v->a[1344] = lex_mode_external(241, 14);
v->a[1345] = lex_mode_external(241, 14);
v->a[1346] = lex_mode_external(241, 14);
v->a[1347] = lex_mode_external(241, 14);
v->a[1348] = lex_mode_external(241, 14);
v->a[1349] = lex_mode_external(241, 14);
v->a[1350] = lex_mode_external(205, 44);
v->a[1351] = lex_mode_external(241, 14);
v->a[1352] = lex_mode_external(241, 14);
v->a[1353] = lex_mode_external(241, 14);
v->a[1354] = lex_mode_external(205, 44);
v->a[1355] = lex_mode_external(241, 15);
v->a[1356] = lex_mode_external(241, 23);
v->a[1357] = lex_mode_external(241, 14);
v->a[1358] = lex_mode_external(241, 14);
v->a[1359] = lex_mode_external(241, 14);
lex_modes_68(v);
}
void lex_modes_68(t_lex_modes_array *v)
{
v->a[1360] = lex_mode_external(206, 41);
v->a[1361] = lex_mode_external(244, 14);
v->a[1362] = lex_mode_external(244, 14);
v->a[1363] = lex_mode_external(244, 14);
v->a[1364] = lex_mode_external(244, 14);
v->a[1365] = lex_mode_external(244, 14);
v->a[1366] = lex_mode_external(244, 14);
v->a[1367] = lex_mode_external(244, 14);
v->a[1368] = lex_mode_external(244, 14);
v->a[1369] = lex_mode_external(244, 14);
v->a[1370] = lex_mode_external(244, 14);
v->a[1371] = lex_mode_external(243, 14);
v->a[1372] = lex_mode_external(243, 30);
v->a[1373] = lex_mode_external(244, 14);
v->a[1374] = lex_mode_external(206, 41);
v->a[1375] = lex_mode_external(205, 32);
v->a[1376] = lex_mode_external(244, 14);
v->a[1377] = lex_mode_external(206, 41);
v->a[1378] = lex_mode_external(206, 41);
v->a[1379] = lex_mode_external(244, 14);
v->a[1360] = lex_mode_external(205, 44);
v->a[1361] = lex_mode_external(127, 42);
v->a[1362] = lex_mode_external(241, 14);
v->a[1363] = lex_mode_external(241, 14);
v->a[1364] = lex_mode_external(241, 14);
v->a[1365] = lex_mode_external(205, 44);
v->a[1366] = lex_mode_external(241, 14);
v->a[1367] = lex_mode_external(241, 14);
v->a[1368] = lex_mode_external(241, 14);
v->a[1369] = lex_mode_external(241, 14);
v->a[1370] = lex_mode_external(241, 14);
v->a[1371] = lex_mode_external(241, 14);
v->a[1372] = lex_mode_external(205, 44);
v->a[1373] = lex_mode_external(118, 45);
v->a[1374] = lex_mode_external(241, 14);
v->a[1375] = lex_mode_external(205, 44);
v->a[1376] = lex_mode_external(241, 14);
v->a[1377] = lex_mode_external(241, 14);
v->a[1378] = lex_mode_external(241, 14);
v->a[1379] = lex_mode_external(118, 45);
lex_modes_69(v);
}
void lex_modes_69(t_lex_modes_array *v)
{
v->a[1380] = lex_mode_external(243, 14);
v->a[1381] = lex_mode_external(243, 14);
v->a[1382] = lex_mode_external(244, 14);
v->a[1383] = lex_mode_external(243, 14);
v->a[1384] = lex_mode_external(243, 14);
v->a[1385] = lex_mode_external(244, 14);
v->a[1386] = lex_mode_external(243, 14);
v->a[1387] = lex_mode_external(243, 14);
v->a[1388] = lex_mode_external(244, 14);
v->a[1389] = lex_mode_external(243, 14);
v->a[1390] = lex_mode_external(243, 14);
v->a[1391] = lex_mode_external(243, 30);
v->a[1392] = lex_mode_external(244, 14);
v->a[1393] = lex_mode_external(244, 14);
v->a[1394] = lex_mode_external(243, 30);
v->a[1395] = lex_mode_external(243, 14);
v->a[1396] = lex_mode_external(243, 14);
v->a[1397] = lex_mode_external(206, 41);
v->a[1398] = lex_mode_external(243, 14);
v->a[1399] = lex_mode_external(243, 30);
v->a[1380] = lex_mode_external(241, 14);
v->a[1381] = lex_mode_external(205, 44);
v->a[1382] = lex_mode_external(205, 44);
v->a[1383] = lex_mode_external(241, 14);
v->a[1384] = lex_mode_external(241, 14);
v->a[1385] = lex_mode_external(241, 14);
v->a[1386] = lex_mode_external(241, 14);
v->a[1387] = lex_mode_external(241, 14);
v->a[1388] = lex_mode_external(241, 14);
v->a[1389] = lex_mode_external(241, 14);
v->a[1390] = lex_mode_external(241, 14);
v->a[1391] = lex_mode_external(241, 14);
v->a[1392] = lex_mode_external(241, 14);
v->a[1393] = lex_mode_external(205, 44);
v->a[1394] = lex_mode_external(241, 14);
v->a[1395] = lex_mode_external(241, 15);
v->a[1396] = lex_mode_external(205, 44);
v->a[1397] = lex_mode_external(241, 15);
v->a[1398] = lex_mode_external(241, 30);
v->a[1399] = lex_mode_external(241, 30);
lex_modes_70(v);
}

200
parser/static/lex_modes/lex_modes_14.c
View file

@ -14,126 +14,126 @@
void lex_modes_70(t_lex_modes_array *v)
{
v->a[1400] = lex_mode_external(244, 14);
v->a[1401] = lex_mode_external(243, 30);
v->a[1402] = lex_mode_external(243, 28);
v->a[1403] = lex_mode_external(243, 14);
v->a[1404] = lex_mode_external(243, 14);
v->a[1405] = lex_mode_external(243, 14);
v->a[1406] = lex_mode_external(243, 15);
v->a[1407] = lex_mode_external(243, 14);
v->a[1408] = lex_mode_external(243, 30);
v->a[1409] = lex_mode_external(243, 15);
v->a[1410] = lex_mode_external(244, 14);
v->a[1411] = lex_mode_external(243, 30);
v->a[1412] = lex_mode_external(243, 30);
v->a[1413] = lex_mode_external(243, 14);
v->a[1414] = lex_mode_external(244, 14);
v->a[1415] = lex_mode_external(243, 7);
v->a[1416] = lex_mode_external(244, 14);
v->a[1417] = lex_mode_external(243, 7);
v->a[1418] = lex_mode_external(205, 32);
v->a[1419] = lex_mode_external(243, 14);
v->a[1400] = lex_mode_external(217, 35);
v->a[1401] = lex_mode_external(241, 30);
v->a[1402] = lex_mode_external(118, 45);
v->a[1403] = lex_mode_external(241, 7);
v->a[1404] = lex_mode_external(241, 7);
v->a[1405] = lex_mode_external(217, 35);
v->a[1406] = lex_mode_external(241, 15);
v->a[1407] = lex_mode_external(241, 15);
v->a[1408] = lex_mode_external(241, 15);
v->a[1409] = lex_mode_external(241, 15);
v->a[1410] = lex_mode_external(217, 35);
v->a[1411] = lex_mode_external(241, 15);
v->a[1412] = lex_mode_external(217, 35);
v->a[1413] = lex_mode_external(217, 35);
v->a[1414] = lex_mode_external(217, 37);
v->a[1415] = lex_mode_external(241, 15);
v->a[1416] = lex_mode_external(217, 35);
v->a[1417] = lex_mode_external(217, 37);
v->a[1418] = lex_mode_external(217, 35);
v->a[1419] = lex_mode_external(217, 37);
lex_modes_71(v);
}
void lex_modes_71(t_lex_modes_array *v)
{
v->a[1420] = lex_mode_external(244, 14);
v->a[1421] = lex_mode_external(243, 14);
v->a[1422] = lex_mode_external(244, 14);
v->a[1423] = lex_mode_external(244, 14);
v->a[1424] = lex_mode_external(206, 41);
v->a[1425] = lex_mode_external(243, 14);
v->a[1426] = lex_mode_external(206, 41);
v->a[1427] = lex_mode_external(206, 41);
v->a[1428] = lex_mode_external(205, 32);
v->a[1429] = lex_mode_external(244, 14);
v->a[1430] = lex_mode_external(205, 32);
v->a[1431] = lex_mode_external(244, 14);
v->a[1432] = lex_mode_external(243, 15);
v->a[1433] = lex_mode_external(244, 14);
v->a[1434] = lex_mode_external(243, 14);
v->a[1435] = lex_mode_external(205, 32);
v->a[1436] = lex_mode_external(244, 14);
v->a[1437] = lex_mode_external(244, 14);
v->a[1438] = lex_mode_external(244, 14);
v->a[1439] = lex_mode_external(243, 14);
v->a[1420] = lex_mode_external(241, 15);
v->a[1421] = lex_mode_external(217, 35);
v->a[1422] = lex_mode_external(217, 35);
v->a[1423] = lex_mode_external(217, 35);
v->a[1424] = lex_mode_external(217, 35);
v->a[1425] = lex_mode_external(217, 35);
v->a[1426] = lex_mode_external(217, 35);
v->a[1427] = lex_mode_external(217, 35);
v->a[1428] = lex_mode_external(198, 18);
v->a[1429] = lex_mode_external(198, 31);
v->a[1430] = lex_mode_external(217, 35);
v->a[1431] = lex_mode_external(241, 15);
v->a[1432] = lex_mode_external(198, 18);
v->a[1433] = lex_mode_external(198, 31);
v->a[1434] = lex_mode_external(198, 31);
v->a[1435] = lex_mode_external(198, 31);
v->a[1436] = lex_mode_external(217, 35);
v->a[1437] = lex_mode_external(217, 37);
v->a[1438] = lex_mode_external(217, 35);
v->a[1439] = lex_mode_external(241, 15);
lex_modes_72(v);
}
void lex_modes_72(t_lex_modes_array *v)
{
v->a[1440] = lex_mode_external(243, 14);
v->a[1441] = lex_mode_external(207, 43);
v->a[1442] = lex_mode_external(243, 15);
v->a[1443] = lex_mode_external(243, 14);
v->a[1444] = lex_mode_external(207, 43);
v->a[1445] = lex_mode_external(244, 14);
v->a[1446] = lex_mode_external(243, 14);
v->a[1447] = lex_mode_external(207, 43);
v->a[1448] = lex_mode_external(243, 14);
v->a[1449] = lex_mode_external(243, 15);
v->a[1450] = lex_mode_external(243, 14);
v->a[1451] = lex_mode_external(243, 14);
v->a[1452] = lex_mode_external(243, 15);
v->a[1453] = lex_mode_external(207, 43);
v->a[1454] = lex_mode_external(243, 14);
v->a[1455] = lex_mode_external(243, 14);
v->a[1456] = lex_mode_external(207, 43);
v->a[1457] = lex_mode_external(243, 14);
v->a[1458] = lex_mode_external(207, 43);
v->a[1459] = lex_mode_external(243, 14);
v->a[1440] = lex_mode_external(198, 31);
v->a[1441] = lex_mode_external(217, 37);
v->a[1442] = lex_mode_external(198, 31);
v->a[1443] = lex_mode_external(198, 31);
v->a[1444] = lex_mode_external(198, 31);
v->a[1445] = lex_mode_external(198, 31);
v->a[1446] = lex_mode_external(241, 15);
v->a[1447] = lex_mode_external(198, 31);
v->a[1448] = lex_mode_external(198, 31);
v->a[1449] = lex_mode_external(241, 15);
v->a[1450] = lex_mode_external(217, 37);
v->a[1451] = lex_mode_external(217, 37);
v->a[1452] = lex_mode_external(217, 37);
v->a[1453] = lex_mode_external(198, 31);
v->a[1454] = lex_mode_external(217, 37);
v->a[1455] = lex_mode_external(217, 37);
v->a[1456] = lex_mode_external(198, 31);
v->a[1457] = lex_mode_external(217, 37);
v->a[1458] = lex_mode_external(198, 31);
v->a[1459] = lex_mode_external(217, 37);
lex_modes_73(v);
}
void lex_modes_73(t_lex_modes_array *v)
{
v->a[1460] = lex_mode_external(243, 14);
v->a[1461] = lex_mode_external(243, 8);
v->a[1462] = lex_mode_external(243, 14);
v->a[1463] = lex_mode_external(243, 14);
v->a[1464] = lex_mode_external(243, 14);
v->a[1465] = lex_mode_external(243, 15);
v->a[1466] = lex_mode_external(243, 15);
v->a[1467] = lex_mode_external(205, 44);
v->a[1468] = lex_mode_external(243, 15);
v->a[1469] = lex_mode_external(243, 15);
v->a[1470] = lex_mode_external(205, 44);
v->a[1471] = lex_mode_external(205, 44);
v->a[1472] = lex_mode_external(243, 15);
v->a[1473] = lex_mode_external(243, 15);
v->a[1474] = lex_mode_external(243, 15);
v->a[1475] = lex_mode_external(205, 44);
v->a[1476] = lex_mode_external(243, 15);
v->a[1477] = lex_mode_external(205, 32);
v->a[1478] = lex_mode_external(205, 44);
v->a[1479] = lex_mode_external(243, 15);
v->a[1460] = lex_mode_external(217, 37);
v->a[1461] = lex_mode_external(217, 37);
v->a[1462] = lex_mode_external(217, 37);
v->a[1463] = lex_mode_external(217, 37);
v->a[1464] = lex_mode_external(217, 37);
v->a[1465] = lex_mode_external(217, 37);
v->a[1466] = lex_mode_external(212, 46);
v->a[1467] = lex_mode_external(212, 46);
v->a[1468] = lex_mode_external(241, 40);
v->a[1469] = lex_mode_external(213, 47);
v->a[1470] = lex_mode_external(213, 47);
v->a[1471] = lex_mode_external(212, 46);
v->a[1472] = lex_mode_external(124, 42);
v->a[1473] = lex_mode_external(245, 45);
v->a[1474] = lex_mode_external(241, 17);
v->a[1475] = lex_mode_external(245, 45);
v->a[1476] = lex_mode_external(212, 46);
v->a[1477] = lex_mode_external(212, 46);
v->a[1478] = lex_mode_external(212, 46);
v->a[1479] = lex_mode_external(213, 47);
lex_modes_74(v);
}
void lex_modes_74(t_lex_modes_array *v)
{
v->a[1480] = lex_mode_external(205, 44);
v->a[1481] = lex_mode_external(243, 23);
v->a[1482] = lex_mode_external(243, 15);
v->a[1483] = lex_mode_external(243, 15);
v->a[1484] = lex_mode_external(243, 15);
v->a[1485] = lex_mode_external(243, 15);
v->a[1486] = lex_mode_external(205, 44);
v->a[1487] = lex_mode_external(243, 15);
v->a[1488] = lex_mode_external(243, 15);
v->a[1489] = lex_mode_external(243, 15);
v->a[1490] = lex_mode_external(205, 44);
v->a[1491] = lex_mode_external(205, 44);
v->a[1492] = lex_mode_external(243, 15);
v->a[1493] = lex_mode_external(243, 15);
v->a[1494] = lex_mode_external(205, 32);
v->a[1495] = lex_mode_external(243, 15);
v->a[1496] = lex_mode_external(243, 15);
v->a[1497] = lex_mode_external(243, 15);
v->a[1498] = lex_mode_external(243, 23);
v->a[1499] = lex_mode_external(243, 15);
v->a[1480] = lex_mode_external(241, 17);
v->a[1481] = lex_mode_external(212, 46);
v->a[1482] = lex_mode_external(212, 46);
v->a[1483] = lex_mode_external(212, 46);
v->a[1484] = lex_mode_external(245, 45);
v->a[1485] = lex_mode_external(212, 46);
v->a[1486] = lex_mode_external(241, 40);
v->a[1487] = lex_mode_external(213, 47);
v->a[1488] = lex_mode_external(212, 46);
v->a[1489] = lex_mode_external(241, 17);
v->a[1490] = lex_mode_external(213, 47);
v->a[1491] = lex_mode_external(245, 45);
v->a[1492] = lex_mode_external(212, 46);
v->a[1493] = lex_mode_external(241, 17);
v->a[1494] = lex_mode_external(212, 46);
v->a[1495] = lex_mode_external(212, 46);
v->a[1496] = lex_mode_external(213, 47);
v->a[1497] = lex_mode_external(212, 46);
v->a[1498] = lex_mode_external(213, 47);
v->a[1499] = lex_mode_external(212, 46);
lex_modes_75(v);
}

200
parser/static/lex_modes/lex_modes_15.c
View file

@ -14,126 +14,126 @@
void lex_modes_75(t_lex_modes_array *v)
{
v->a[1500] = lex_mode_external(205, 44);
v->a[1501] = lex_mode_external(205, 44);
v->a[1502] = lex_mode_external(243, 14);
v->a[1503] = lex_mode_external(243, 15);
v->a[1504] = lex_mode_external(243, 15);
v->a[1505] = lex_mode_external(243, 15);
v->a[1506] = lex_mode_external(243, 15);
v->a[1507] = lex_mode_external(243, 15);
v->a[1508] = lex_mode_external(243, 15);
v->a[1509] = lex_mode_external(243, 15);
v->a[1510] = lex_mode_external(243, 15);
v->a[1511] = lex_mode_external(243, 15);
v->a[1512] = lex_mode_external(243, 15);
v->a[1513] = lex_mode_external(243, 15);
v->a[1514] = lex_mode_external(243, 15);
v->a[1515] = lex_mode_external(243, 15);
v->a[1516] = lex_mode_external(243, 15);
v->a[1517] = lex_mode_external(243, 15);
v->a[1518] = lex_mode_external(243, 15);
v->a[1519] = lex_mode_external(243, 15);
v->a[1500] = lex_mode_external(212, 46);
v->a[1501] = lex_mode_external(212, 46);
v->a[1502] = lex_mode_external(212, 46);
v->a[1503] = lex_mode_external(198, 18);
v->a[1504] = lex_mode_external(212, 46);
v->a[1505] = lex_mode_external(212, 46);
v->a[1506] = lex_mode_external(212, 46);
v->a[1507] = lex_mode_external(213, 47);
v->a[1508] = lex_mode_external(212, 46);
v->a[1509] = lex_mode_external(212, 46);
v->a[1510] = lex_mode_external(213, 47);
v->a[1511] = lex_mode_external(205, 48);
v->a[1512] = lex_mode_external(198, 31);
v->a[1513] = lex_mode_external(212, 46);
v->a[1514] = lex_mode_external(198, 31);
v->a[1515] = lex_mode_external(212, 46);
v->a[1516] = lex_mode_external(212, 46);
v->a[1517] = lex_mode_external(212, 46);
v->a[1518] = lex_mode_external(212, 46);
v->a[1519] = lex_mode_external(212, 46);
lex_modes_76(v);
}
void lex_modes_76(t_lex_modes_array *v)
{
v->a[1520] = lex_mode_external(243, 14);
v->a[1521] = lex_mode_external(243, 15);
v->a[1522] = lex_mode_external(243, 15);
v->a[1523] = lex_mode_external(243, 15);
v->a[1524] = lex_mode_external(243, 15);
v->a[1525] = lex_mode_external(243, 15);
v->a[1526] = lex_mode_external(205, 44);
v->a[1527] = lex_mode_external(243, 15);
v->a[1528] = lex_mode_external(127, 42);
v->a[1529] = lex_mode_external(205, 32);
v->a[1530] = lex_mode_external(243, 15);
v->a[1531] = lex_mode_external(243, 15);
v->a[1532] = lex_mode_external(243, 15);
v->a[1533] = lex_mode_external(243, 15);
v->a[1534] = lex_mode_external(205, 32);
v->a[1535] = lex_mode_external(243, 15);
v->a[1536] = lex_mode_external(243, 15);
v->a[1537] = lex_mode_external(243, 15);
v->a[1538] = lex_mode_external(243, 15);
v->a[1539] = lex_mode_external(118, 45);
v->a[1520] = lex_mode_external(212, 46);
v->a[1521] = lex_mode_external(212, 46);
v->a[1522] = lex_mode_external(212, 46);
v->a[1523] = lex_mode_external(212, 46);
v->a[1524] = lex_mode_external(212, 46);
v->a[1525] = lex_mode_external(212, 46);
v->a[1526] = lex_mode_external(212, 46);
v->a[1527] = lex_mode_external(212, 46);
v->a[1528] = lex_mode_external(212, 46);
v->a[1529] = lex_mode_external(212, 46);
v->a[1530] = lex_mode_external(212, 46);
v->a[1531] = lex_mode_external(213, 47);
v->a[1532] = lex_mode_external(245, 45);
v->a[1533] = lex_mode_external(241, 17);
v->a[1534] = lex_mode_external(212, 46);
v->a[1535] = lex_mode_external(212, 46);
v->a[1536] = lex_mode_external(205, 48);
v->a[1537] = lex_mode_external(212, 46);
v->a[1538] = lex_mode_external(212, 46);
v->a[1539] = lex_mode_external(212, 46);
lex_modes_77(v);
}
void lex_modes_77(t_lex_modes_array *v)
{
v->a[1540] = lex_mode_external(243, 7);
v->a[1541] = lex_mode_external(118, 45);
v->a[1542] = lex_mode_external(243, 28);
v->a[1543] = lex_mode_external(217, 35);
v->a[1544] = lex_mode_external(243, 7);
v->a[1545] = lex_mode_external(118, 45);
v->a[1546] = lex_mode_external(243, 14);
v->a[1547] = lex_mode_external(205, 44);
v->a[1548] = lex_mode_external(217, 35);
v->a[1549] = lex_mode_external(118, 45);
v->a[1550] = lex_mode_external(243, 14);
v->a[1551] = lex_mode_external(243, 28);
v->a[1552] = lex_mode_external(243, 28);
v->a[1553] = lex_mode_external(217, 35);
v->a[1554] = lex_mode_external(243, 14);
v->a[1555] = lex_mode_external(243, 14);
v->a[1556] = lex_mode_external(243, 14);
v->a[1557] = lex_mode_external(243, 14);
v->a[1558] = lex_mode_external(217, 37);
v->a[1559] = lex_mode_external(198, 31);
v->a[1540] = lex_mode_external(212, 46);
v->a[1541] = lex_mode_external(213, 47);
v->a[1542] = lex_mode_external(212, 46);
v->a[1543] = lex_mode_external(212, 46);
v->a[1544] = lex_mode_external(198, 31);
v->a[1545] = lex_mode_external(212, 46);
v->a[1546] = lex_mode_external(212, 46);
v->a[1547] = lex_mode_external(212, 46);
v->a[1548] = lex_mode_external(212, 46);
v->a[1549] = lex_mode_external(212, 46);
v->a[1550] = lex_mode_external(212, 46);
v->a[1551] = lex_mode_external(213, 47);
v->a[1552] = lex_mode_external(212, 46);
v->a[1553] = lex_mode_external(212, 46);
v->a[1554] = lex_mode_external(212, 46);
v->a[1555] = lex_mode_external(212, 46);
v->a[1556] = lex_mode_external(212, 46);
v->a[1557] = lex_mode_external(212, 46);
v->a[1558] = lex_mode_external(245, 45);
v->a[1559] = lex_mode_external(205, 48);
lex_modes_78(v);
}
void lex_modes_78(t_lex_modes_array *v)
{
v->a[1560] = lex_mode_external(217, 37);
v->a[1561] = lex_mode_external(198, 31);
v->a[1562] = lex_mode_external(217, 35);
v->a[1563] = lex_mode_external(198, 31);
v->a[1564] = lex_mode_external(243, 14);
v->a[1565] = lex_mode_external(243, 14);
v->a[1566] = lex_mode_external(217, 35);
v->a[1567] = lex_mode_external(217, 37);
v->a[1568] = lex_mode_external(217, 35);
v->a[1569] = lex_mode_external(217, 35);
v->a[1570] = lex_mode_external(217, 35);
v->a[1571] = lex_mode_external(217, 35);
v->a[1572] = lex_mode_external(217, 35);
v->a[1573] = lex_mode_external(198, 31);
v->a[1574] = lex_mode_external(217, 37);
v->a[1575] = lex_mode_external(217, 35);
v->a[1576] = lex_mode_external(217, 35);
v->a[1577] = lex_mode_external(217, 35);
v->a[1578] = lex_mode_external(217, 35);
v->a[1579] = lex_mode_external(198, 17);
v->a[1560] = lex_mode_external(212, 46);
v->a[1561] = lex_mode_external(212, 46);
v->a[1562] = lex_mode_external(212, 46);
v->a[1563] = lex_mode_external(212, 46);
v->a[1564] = lex_mode_external(212, 46);
v->a[1565] = lex_mode_external(212, 46);
v->a[1566] = lex_mode_external(213, 47);
v->a[1567] = lex_mode_external(241, 17);
v->a[1568] = lex_mode_external(212, 46);
v->a[1569] = lex_mode_external(241, 40);
v->a[1570] = lex_mode_external(212, 46);
v->a[1571] = lex_mode_external(241, 40);
v->a[1572] = lex_mode_external(212, 46);
v->a[1573] = lex_mode_external(212, 46);
v->a[1574] = lex_mode_external(212, 46);
v->a[1575] = lex_mode_external(213, 47);
v->a[1576] = lex_mode_external(212, 46);
v->a[1577] = lex_mode_external(245, 45);
v->a[1578] = lex_mode_external(198, 31);
v->a[1579] = lex_mode_external(198, 31);
lex_modes_79(v);
}
void lex_modes_79(t_lex_modes_array *v)
{
v->a[1580] = lex_mode_external(217, 35);
v->a[1581] = lex_mode_external(243, 14);
v->a[1582] = lex_mode_external(243, 14);
v->a[1583] = lex_mode_external(198, 17);
v->a[1584] = lex_mode_external(217, 35);
v->a[1585] = lex_mode_external(217, 35);
v->a[1586] = lex_mode_external(243, 14);
v->a[1587] = lex_mode_external(217, 37);
v->a[1588] = lex_mode_external(217, 37);
v->a[1589] = lex_mode_external(198, 31);
v->a[1590] = lex_mode_external(198, 31);
v->a[1591] = lex_mode_external(217, 37);
v->a[1592] = lex_mode_external(217, 37);
v->a[1593] = lex_mode_external(217, 37);
v->a[1594] = lex_mode_external(198, 31);
v->a[1595] = lex_mode_external(217, 37);
v->a[1596] = lex_mode_external(217, 37);
v->a[1597] = lex_mode_external(217, 37);
v->a[1598] = lex_mode_external(198, 31);
v->a[1599] = lex_mode_external(217, 37);
v->a[1580] = lex_mode_external(121, 49);
v->a[1581] = lex_mode_normal(205);
v->a[1582] = lex_mode_external(241, 40);
v->a[1583] = lex_mode_external(241, 40);
v->a[1584] = lex_mode_normal(205);
v->a[1585] = lex_mode_external(241, 40);
v->a[1586] = lex_mode_normal(205);
v->a[1587] = lex_mode_external(121, 49);
v->a[1588] = lex_mode_normal(205);
v->a[1589] = lex_mode_external(241, 40);
v->a[1590] = lex_mode_normal(205);
v->a[1591] = lex_mode_external(241, 40);
v->a[1592] = lex_mode_external(241, 40);
v->a[1593] = lex_mode_normal(205);
v->a[1594] = lex_mode_normal(205);
v->a[1595] = lex_mode_normal(205);
v->a[1596] = lex_mode_external(241, 40);
v->a[1597] = lex_mode_external(241, 40);
v->a[1598] = lex_mode_normal(205);
v->a[1599] = lex_mode_normal(205);
lex_modes_80(v);
}

186
parser/static/lex_modes/lex_modes_16.c
View file

@ -14,126 +14,126 @@
void lex_modes_80(t_lex_modes_array *v)
{
v->a[1600] = lex_mode_external(217, 37);
v->a[1601] = lex_mode_external(243, 14);
v->a[1602] = lex_mode_external(198, 31);
v->a[1603] = lex_mode_external(217, 37);
v->a[1604] = lex_mode_external(217, 37);
v->a[1600] = lex_mode_normal(205);
v->a[1601] = lex_mode_external(241, 40);
v->a[1602] = lex_mode_normal(205);
v->a[1603] = lex_mode_normal(205);
v->a[1604] = lex_mode_normal(205);
v->a[1605] = lex_mode_external(198, 31);
v->a[1606] = lex_mode_external(198, 31);
v->a[1607] = lex_mode_external(217, 37);
v->a[1607] = lex_mode_external(198, 31);
v->a[1608] = lex_mode_external(198, 31);
v->a[1609] = lex_mode_external(217, 37);
v->a[1609] = lex_mode_external(241, 17);
v->a[1610] = lex_mode_external(198, 31);
v->a[1611] = lex_mode_external(243, 14);
v->a[1611] = lex_mode_external(198, 31);
v->a[1612] = lex_mode_external(198, 31);
v->a[1613] = lex_mode_external(246, 45);
v->a[1614] = lex_mode_external(212, 46);
v->a[1615] = lex_mode_external(212, 46);
v->a[1616] = lex_mode_external(213, 47);
v->a[1617] = lex_mode_external(212, 46);
v->a[1618] = lex_mode_external(212, 46);
v->a[1619] = lex_mode_external(212, 46);
v->a[1613] = lex_mode_external(198, 31);
v->a[1614] = lex_mode_normal(205);
v->a[1615] = lex_mode_normal(205);
v->a[1616] = lex_mode_external(198, 31);
v->a[1617] = lex_mode_external(198, 31);
v->a[1618] = lex_mode_external(198, 31);
v->a[1619] = lex_mode_external(198, 31);
lex_modes_81(v);
}
void lex_modes_81(t_lex_modes_array *v)
{
v->a[1620] = lex_mode_external(212, 46);
v->a[1621] = lex_mode_external(212, 46);
v->a[1622] = lex_mode_external(212, 46);
v->a[1623] = lex_mode_external(212, 46);
v->a[1624] = lex_mode_external(212, 46);
v->a[1625] = lex_mode_external(243, 39);
v->a[1626] = lex_mode_external(212, 46);
v->a[1627] = lex_mode_external(212, 46);
v->a[1628] = lex_mode_external(212, 46);
v->a[1629] = lex_mode_external(213, 47);
v->a[1630] = lex_mode_external(212, 46);
v->a[1631] = lex_mode_external(205, 48);
v->a[1632] = lex_mode_external(212, 46);
v->a[1633] = lex_mode_external(212, 46);
v->a[1634] = lex_mode_external(243, 39);
v->a[1635] = lex_mode_external(243, 18);
v->a[1636] = lex_mode_external(212, 46);
v->a[1637] = lex_mode_external(212, 46);
v->a[1638] = lex_mode_external(212, 46);
v->a[1639] = lex_mode_external(212, 46);
v->a[1620] = lex_mode_external(198, 31);
v->a[1621] = lex_mode_external(198, 31);
v->a[1622] = lex_mode_external(198, 31);
v->a[1623] = lex_mode_external(198, 31);
v->a[1624] = lex_mode_external(198, 31);
v->a[1625] = lex_mode_external(198, 31);
v->a[1626] = lex_mode_external(198, 31);
v->a[1627] = lex_mode_external(198, 31);
v->a[1628] = lex_mode_external(198, 31);
v->a[1629] = lex_mode_external(198, 31);
v->a[1630] = lex_mode_external(198, 31);
v->a[1631] = lex_mode_external(198, 31);
v->a[1632] = lex_mode_external(198, 31);
v->a[1633] = lex_mode_external(198, 31);
v->a[1634] = lex_mode_external(198, 31);
v->a[1635] = lex_mode_external(198, 31);
v->a[1636] = lex_mode_external(198, 31);
v->a[1637] = lex_mode_external(198, 31);
v->a[1638] = lex_mode_normal(205);
v->a[1639] = lex_mode_external(198, 31);
lex_modes_82(v);
}
void lex_modes_82(t_lex_modes_array *v)
{
v->a[1640] = lex_mode_external(213, 47);
v->a[1641] = lex_mode_external(212, 46);
v->a[1642] = lex_mode_external(125, 42);
v->a[1643] = lex_mode_external(212, 46);
v->a[1644] = lex_mode_external(212, 46);
v->a[1645] = lex_mode_external(212, 46);
v->a[1646] = lex_mode_external(212, 46);
v->a[1647] = lex_mode_external(212, 46);
v->a[1640] = lex_mode_external(198, 31);
v->a[1641] = lex_mode_normal(205);
v->a[1642] = lex_mode_external(241, 40);
v->a[1643] = lex_mode_normal(205);
v->a[1644] = lex_mode_normal(205);
v->a[1645] = lex_mode_external(198, 31);
v->a[1646] = lex_mode_external(241, 40);
v->a[1647] = lex_mode_external(198, 31);
v->a[1648] = lex_mode_external(198, 31);
v->a[1649] = lex_mode_external(212, 46);
v->a[1650] = lex_mode_external(212, 46);
v->a[1651] = lex_mode_external(212, 46);
v->a[1652] = lex_mode_external(213, 47);
v->a[1653] = lex_mode_external(212, 46);
v->a[1654] = lex_mode_external(212, 46);
v->a[1655] = lex_mode_external(212, 46);
v->a[1656] = lex_mode_external(213, 47);
v->a[1657] = lex_mode_external(212, 46);
v->a[1658] = lex_mode_external(212, 46);
v->a[1659] = lex_mode_external(212, 46);
v->a[1649] = lex_mode_external(198, 31);
v->a[1650] = lex_mode_normal(205);
v->a[1651] = lex_mode_external(198, 31);
v->a[1652] = lex_mode_external(198, 31);
v->a[1653] = lex_mode_external(198, 31);
v->a[1654] = lex_mode_external(198, 31);
v->a[1655] = lex_mode_external(198, 31);
v->a[1656] = lex_mode_external(198, 31);
v->a[1657] = lex_mode_external(198, 31);
v->a[1658] = lex_mode_external(198, 31);
v->a[1659] = lex_mode_external(241, 40);
lex_modes_83(v);
}
void lex_modes_83(t_lex_modes_array *v)
{
v->a[1660] = lex_mode_external(212, 46);
v->a[1661] = lex_mode_external(213, 47);
v->a[1662] = lex_mode_external(212, 46);
v->a[1660] = lex_mode_external(198, 31);
v->a[1661] = lex_mode_external(198, 31);
v->a[1662] = lex_mode_external(198, 31);
v->a[1663] = lex_mode_external(198, 31);
v->a[1664] = lex_mode_external(213, 47);
v->a[1665] = lex_mode_external(213, 47);
v->a[1666] = lex_mode_external(212, 46);
v->a[1667] = lex_mode_external(212, 46);
v->a[1668] = lex_mode_external(212, 46);
v->a[1669] = lex_mode_external(212, 46);
v->a[1670] = lex_mode_external(212, 46);
v->a[1671] = lex_mode_external(213, 47);
v->a[1672] = lex_mode_external(243, 18);
v->a[1673] = lex_mode_external(212, 46);
v->a[1674] = lex_mode_external(246, 45);
v->a[1675] = lex_mode_external(212, 46);
v->a[1676] = lex_mode_external(198, 31);
v->a[1677] = lex_mode_external(212, 46);
v->a[1678] = lex_mode_external(246, 45);
v->a[1679] = lex_mode_external(212, 46);
v->a[1664] = lex_mode_normal(205);
v->a[1665] = lex_mode_external(198, 31);
v->a[1666] = lex_mode_external(198, 31);
v->a[1667] = lex_mode_external(198, 31);
v->a[1668] = lex_mode_normal(205);
v->a[1669] = lex_mode_external(121, 49);
v->a[1670] = lex_mode_normal(205);
v->a[1671] = lex_mode_external(241, 40);
v->a[1672] = lex_mode_external(241, 40);
v->a[1673] = lex_mode_normal(205);
v->a[1674] = lex_mode_normal(205);
v->a[1675] = lex_mode_normal(205);
v->a[1676] = lex_mode_normal(205);
v->a[1677] = lex_mode_normal(205);
v->a[1678] = lex_mode_normal(205);
v->a[1679] = lex_mode_normal(205);
lex_modes_84(v);
}
void lex_modes_84(t_lex_modes_array *v)
{
v->a[1680] = lex_mode_external(213, 47);
v->a[1681] = lex_mode_external(213, 47);
v->a[1682] = lex_mode_external(212, 46);
v->a[1683] = lex_mode_external(243, 18);
v->a[1684] = lex_mode_external(212, 46);
v->a[1685] = lex_mode_external(246, 45);
v->a[1686] = lex_mode_external(212, 46);
v->a[1687] = lex_mode_external(212, 46);
v->a[1688] = lex_mode_external(212, 46);
v->a[1689] = lex_mode_external(243, 18);
v->a[1690] = lex_mode_external(212, 46);
v->a[1691] = lex_mode_external(212, 46);
v->a[1692] = lex_mode_external(212, 46);
v->a[1693] = lex_mode_external(212, 46);
v->a[1694] = lex_mode_external(212, 46);
v->a[1695] = lex_mode_external(212, 46);
v->a[1696] = lex_mode_external(213, 47);
v->a[1697] = lex_mode_external(212, 46);
v->a[1698] = lex_mode_external(212, 46);
v->a[1699] = lex_mode_external(212, 46);
v->a[1680] = lex_mode_normal(205);
v->a[1681] = lex_mode_normal(205);
v->a[1682] = lex_mode_external(121, 49);
v->a[1683] = lex_mode_external(121, 49);
v->a[1684] = lex_mode_external(121, 49);
v->a[1685] = lex_mode_external(121, 49);
v->a[1686] = lex_mode_external(121, 49);
v->a[1687] = lex_mode_external(121, 49);
v->a[1688] = lex_mode_external(121, 49);
v->a[1689] = lex_mode_external(121, 49);
v->a[1690] = lex_mode_external(121, 49);
v->a[1691] = lex_mode_external(121, 49);
v->a[1692] = lex_mode_external(121, 49);
v->a[1693] = lex_mode_external(121, 49);
v->a[1694] = lex_mode_external(121, 49);
v->a[1695] = lex_mode_normal(205);
v->a[1696] = lex_mode_normal(205);
v->a[1697] = lex_mode_external(209, 50);
v->a[1698] = lex_mode_external(215, 51);
v->a[1699] = lex_mode_external(215, 51);
lex_modes_85(v);
}

200
parser/static/lex_modes/lex_modes_17.c
View file

@ -14,126 +14,126 @@
void lex_modes_85(t_lex_modes_array *v)
{
v->a[1700] = lex_mode_external(213, 47);
v->a[1701] = lex_mode_external(212, 46);
v->a[1702] = lex_mode_external(212, 46);
v->a[1703] = lex_mode_external(212, 46);
v->a[1704] = lex_mode_external(212, 46);
v->a[1705] = lex_mode_external(212, 46);
v->a[1706] = lex_mode_external(205, 48);
v->a[1707] = lex_mode_external(243, 39);
v->a[1708] = lex_mode_external(246, 45);
v->a[1709] = lex_mode_external(212, 46);
v->a[1710] = lex_mode_external(212, 46);
v->a[1711] = lex_mode_external(213, 47);
v->a[1712] = lex_mode_external(212, 46);
v->a[1713] = lex_mode_external(243, 18);
v->a[1714] = lex_mode_external(198, 17);
v->a[1715] = lex_mode_external(205, 48);
v->a[1716] = lex_mode_external(212, 46);
v->a[1717] = lex_mode_external(212, 46);
v->a[1718] = lex_mode_external(243, 39);
v->a[1719] = lex_mode_external(212, 46);
v->a[1700] = lex_mode_normal(205);
v->a[1701] = lex_mode_external(121, 49);
v->a[1702] = lex_mode_external(197, 52);
v->a[1703] = lex_mode_external(197, 52);
v->a[1704] = lex_mode_external(197, 52);
v->a[1705] = lex_mode_external(197, 52);
v->a[1706] = lex_mode_external(197, 52);
v->a[1707] = lex_mode_external(197, 52);
v->a[1708] = lex_mode_external(197, 52);
v->a[1709] = lex_mode_external(197, 52);
v->a[1710] = lex_mode_external(197, 52);
v->a[1711] = lex_mode_external(197, 52);
v->a[1712] = lex_mode_external(197, 52);
v->a[1713] = lex_mode_external(197, 52);
v->a[1714] = lex_mode_external(197, 52);
v->a[1715] = lex_mode_external(197, 52);
v->a[1716] = lex_mode_external(197, 52);
v->a[1717] = lex_mode_external(197, 52);
v->a[1718] = lex_mode_external(197, 52);
v->a[1719] = lex_mode_external(197, 52);
lex_modes_86(v);
}
void lex_modes_86(t_lex_modes_array *v)
{
v->a[1720] = lex_mode_external(246, 45);
v->a[1721] = lex_mode_external(212, 46);
v->a[1722] = lex_mode_external(212, 46);
v->a[1723] = lex_mode_external(243, 18);
v->a[1724] = lex_mode_external(246, 45);
v->a[1725] = lex_mode_external(198, 31);
v->a[1726] = lex_mode_external(198, 31);
v->a[1727] = lex_mode_external(198, 31);
v->a[1728] = lex_mode_external(198, 31);
v->a[1729] = lex_mode_external(198, 31);
v->a[1730] = lex_mode_normal(205);
v->a[1731] = lex_mode_normal(205);
v->a[1732] = lex_mode_external(198, 31);
v->a[1733] = lex_mode_external(243, 18);
v->a[1734] = lex_mode_external(198, 31);
v->a[1735] = lex_mode_external(198, 31);
v->a[1736] = lex_mode_external(198, 31);
v->a[1737] = lex_mode_external(198, 31);
v->a[1738] = lex_mode_normal(205);
v->a[1739] = lex_mode_external(198, 31);
v->a[1720] = lex_mode_external(197, 52);
v->a[1721] = lex_mode_external(197, 52);
v->a[1722] = lex_mode_external(197, 52);
v->a[1723] = lex_mode_external(197, 52);
v->a[1724] = lex_mode_external(197, 52);
v->a[1725] = lex_mode_external(197, 52);
v->a[1726] = lex_mode_external(241, 17);
v->a[1727] = lex_mode_external(197, 52);
v->a[1728] = lex_mode_external(197, 52);
v->a[1729] = lex_mode_external(197, 52);
v->a[1730] = lex_mode_external(241, 17);
v->a[1731] = lex_mode_external(197, 52);
v->a[1732] = lex_mode_external(197, 52);
v->a[1733] = lex_mode_external(197, 52);
v->a[1734] = lex_mode_external(197, 52);
v->a[1735] = lex_mode_external(197, 52);
v->a[1736] = lex_mode_external(197, 52);
v->a[1737] = lex_mode_external(197, 52);
v->a[1738] = lex_mode_external(197, 52);
v->a[1739] = lex_mode_external(197, 52);
lex_modes_87(v);
}
void lex_modes_87(t_lex_modes_array *v)
{
v->a[1740] = lex_mode_normal(205);
v->a[1741] = lex_mode_external(198, 31);
v->a[1742] = lex_mode_external(198, 31);
v->a[1743] = lex_mode_normal(205);
v->a[1744] = lex_mode_external(121, 49);
v->a[1745] = lex_mode_external(121, 49);
v->a[1746] = lex_mode_external(198, 31);
v->a[1747] = lex_mode_normal(205);
v->a[1748] = lex_mode_external(121, 49);
v->a[1749] = lex_mode_external(198, 31);
v->a[1750] = lex_mode_external(198, 31);
v->a[1751] = lex_mode_external(198, 31);
v->a[1752] = lex_mode_external(198, 31);
v->a[1753] = lex_mode_external(198, 31);
v->a[1754] = lex_mode_normal(205);
v->a[1755] = lex_mode_external(198, 31);
v->a[1756] = lex_mode_external(198, 31);
v->a[1757] = lex_mode_normal(205);
v->a[1758] = lex_mode_normal(205);
v->a[1759] = lex_mode_external(198, 31);
v->a[1740] = lex_mode_external(197, 52);
v->a[1741] = lex_mode_external(197, 52);
v->a[1742] = lex_mode_external(197, 52);
v->a[1743] = lex_mode_external(197, 52);
v->a[1744] = lex_mode_external(200, 52);
v->a[1745] = lex_mode_external(197, 52);
v->a[1746] = lex_mode_external(197, 52);
v->a[1747] = lex_mode_external(197, 52);
v->a[1748] = lex_mode_external(197, 52);
v->a[1749] = lex_mode_external(197, 52);
v->a[1750] = lex_mode_external(197, 52);
v->a[1751] = lex_mode_external(197, 52);
v->a[1752] = lex_mode_external(197, 52);
v->a[1753] = lex_mode_external(197, 52);
v->a[1754] = lex_mode_external(197, 52);
v->a[1755] = lex_mode_external(197, 52);
v->a[1756] = lex_mode_external(197, 52);
v->a[1757] = lex_mode_external(197, 52);
v->a[1758] = lex_mode_external(197, 52);
v->a[1759] = lex_mode_external(197, 52);
lex_modes_88(v);
}
void lex_modes_88(t_lex_modes_array *v)
{
v->a[1760] = lex_mode_external(198, 31);
v->a[1761] = lex_mode_normal(205);
v->a[1762] = lex_mode_external(198, 31);
v->a[1763] = lex_mode_normal(205);
v->a[1764] = lex_mode_external(198, 31);
v->a[1765] = lex_mode_external(198, 31);
v->a[1766] = lex_mode_external(198, 31);
v->a[1767] = lex_mode_external(198, 31);
v->a[1768] = lex_mode_external(198, 31);
v->a[1769] = lex_mode_external(198, 31);
v->a[1770] = lex_mode_external(198, 31);
v->a[1771] = lex_mode_normal(205);
v->a[1772] = lex_mode_normal(205);
v->a[1773] = lex_mode_external(198, 31);
v->a[1774] = lex_mode_external(198, 31);
v->a[1775] = lex_mode_external(243, 39);
v->a[1776] = lex_mode_normal(205);
v->a[1777] = lex_mode_normal(205);
v->a[1778] = lex_mode_external(198, 31);
v->a[1779] = lex_mode_external(243, 39);
v->a[1760] = lex_mode_external(197, 52);
v->a[1761] = lex_mode_external(197, 52);
v->a[1762] = lex_mode_external(197, 52);
v->a[1763] = lex_mode_external(197, 52);
v->a[1764] = lex_mode_external(197, 52);
v->a[1765] = lex_mode_external(197, 52);
v->a[1766] = lex_mode_external(197, 52);
v->a[1767] = lex_mode_external(197, 52);
v->a[1768] = lex_mode_external(197, 52);
v->a[1769] = lex_mode_external(202, 52);
v->a[1770] = lex_mode_external(202, 52);
v->a[1771] = lex_mode_external(202, 52);
v->a[1772] = lex_mode_external(202, 52);
v->a[1773] = lex_mode_external(202, 52);
v->a[1774] = lex_mode_external(202, 52);
v->a[1775] = lex_mode_external(202, 52);
v->a[1776] = lex_mode_external(202, 52);
v->a[1777] = lex_mode_external(202, 52);
v->a[1778] = lex_mode_external(202, 52);
v->a[1779] = lex_mode_external(202, 52);
lex_modes_89(v);
}
void lex_modes_89(t_lex_modes_array *v)
{
v->a[1780] = lex_mode_normal(205);
v->a[1781] = lex_mode_normal(205);
v->a[1782] = lex_mode_normal(205);
v->a[1783] = lex_mode_normal(205);
v->a[1784] = lex_mode_external(243, 39);
v->a[1785] = lex_mode_normal(205);
v->a[1786] = lex_mode_external(198, 31);
v->a[1787] = lex_mode_external(198, 31);
v->a[1788] = lex_mode_normal(205);
v->a[1789] = lex_mode_normal(205);
v->a[1790] = lex_mode_normal(205);
v->a[1791] = lex_mode_external(243, 39);
v->a[1792] = lex_mode_external(243, 39);
v->a[1793] = lex_mode_external(198, 31);
v->a[1794] = lex_mode_external(243, 39);
v->a[1795] = lex_mode_external(198, 31);
v->a[1796] = lex_mode_normal(205);
v->a[1797] = lex_mode_external(243, 39);
v->a[1798] = lex_mode_external(243, 39);
v->a[1799] = lex_mode_external(243, 39);
v->a[1780] = lex_mode_external(202, 52);
v->a[1781] = lex_mode_external(247, 49);
v->a[1782] = lex_mode_external(202, 52);
v->a[1783] = lex_mode_external(202, 52);
v->a[1784] = lex_mode_external(202, 52);
v->a[1785] = lex_mode_external(202, 52);
v->a[1786] = lex_mode_external(202, 52);
v->a[1787] = lex_mode_external(210, 50);
v->a[1788] = lex_mode_external(247, 49);
v->a[1789] = lex_mode_external(202, 52);
v->a[1790] = lex_mode_external(202, 52);
v->a[1791] = lex_mode_external(201, 52);
v->a[1792] = lex_mode_external(202, 52);
v->a[1793] = lex_mode_external(202, 52);
v->a[1794] = lex_mode_external(202, 52);
v->a[1795] = lex_mode_external(202, 52);
v->a[1796] = lex_mode_external(202, 52);
v->a[1797] = lex_mode_external(202, 52);
v->a[1798] = lex_mode_external(202, 52);
v->a[1799] = lex_mode_external(202, 52);
lex_modes_90(v);
}

200
parser/static/lex_modes/lex_modes_18.c
View file

@ -14,126 +14,126 @@
void lex_modes_90(t_lex_modes_array *v)
{
v->a[1800] = lex_mode_external(198, 31);
v->a[1801] = lex_mode_normal(205);
v->a[1802] = lex_mode_normal(205);
v->a[1803] = lex_mode_normal(205);
v->a[1804] = lex_mode_external(198, 31);
v->a[1805] = lex_mode_external(198, 31);
v->a[1806] = lex_mode_external(198, 31);
v->a[1807] = lex_mode_external(243, 39);
v->a[1808] = lex_mode_normal(205);
v->a[1809] = lex_mode_normal(205);
v->a[1810] = lex_mode_external(243, 39);
v->a[1811] = lex_mode_external(198, 31);
v->a[1812] = lex_mode_external(198, 31);
v->a[1813] = lex_mode_external(198, 31);
v->a[1814] = lex_mode_external(243, 39);
v->a[1815] = lex_mode_normal(205);
v->a[1816] = lex_mode_normal(205);
v->a[1817] = lex_mode_external(198, 31);
v->a[1818] = lex_mode_external(198, 31);
v->a[1819] = lex_mode_normal(205);
v->a[1800] = lex_mode_external(202, 52);
v->a[1801] = lex_mode_external(202, 52);
v->a[1802] = lex_mode_external(202, 52);
v->a[1803] = lex_mode_external(202, 52);
v->a[1804] = lex_mode_external(202, 52);
v->a[1805] = lex_mode_external(202, 52);
v->a[1806] = lex_mode_normal(214);
v->a[1807] = lex_mode_external(203, 52);
v->a[1808] = lex_mode_external(198, 53);
v->a[1809] = lex_mode_external(203, 52);
v->a[1810] = lex_mode_external(203, 52);
v->a[1811] = lex_mode_normal(214);
v->a[1812] = lex_mode_external(207, 43);
v->a[1813] = lex_mode_normal(214);
v->a[1814] = lex_mode_external(207, 43);
v->a[1815] = lex_mode_normal(214);
v->a[1816] = lex_mode_external(207, 43);
v->a[1817] = lex_mode_normal(214);
v->a[1818] = lex_mode_external(207, 43);
v->a[1819] = lex_mode_external(207, 43);
lex_modes_91(v);
}
void lex_modes_91(t_lex_modes_array *v)
{
v->a[1820] = lex_mode_external(243, 39);
v->a[1821] = lex_mode_normal(205);
v->a[1822] = lex_mode_external(243, 39);
v->a[1823] = lex_mode_external(198, 31);
v->a[1824] = lex_mode_external(198, 31);
v->a[1825] = lex_mode_external(198, 31);
v->a[1826] = lex_mode_external(198, 31);
v->a[1827] = lex_mode_external(198, 31);
v->a[1828] = lex_mode_external(198, 31);
v->a[1829] = lex_mode_external(209, 50);
v->a[1830] = lex_mode_normal(205);
v->a[1831] = lex_mode_normal(205);
v->a[1832] = lex_mode_external(215, 51);
v->a[1833] = lex_mode_external(215, 51);
v->a[1834] = lex_mode_external(121, 49);
v->a[1835] = lex_mode_external(121, 49);
v->a[1836] = lex_mode_external(121, 49);
v->a[1837] = lex_mode_external(121, 49);
v->a[1838] = lex_mode_external(121, 49);
v->a[1839] = lex_mode_external(121, 49);
v->a[1820] = lex_mode_external(203, 52);
v->a[1821] = lex_mode_normal(214);
v->a[1822] = lex_mode_normal(214);
v->a[1823] = lex_mode_normal(214);
v->a[1824] = lex_mode_external(203, 52);
v->a[1825] = lex_mode_normal(214);
v->a[1826] = lex_mode_external(198, 53);
v->a[1827] = lex_mode_normal(214);
v->a[1828] = lex_mode_external(203, 52);
v->a[1829] = lex_mode_external(203, 52);
v->a[1830] = lex_mode_normal(214);
v->a[1831] = lex_mode_external(198, 53);
v->a[1832] = lex_mode_normal(214);
v->a[1833] = lex_mode_normal(214);
v->a[1834] = lex_mode_external(203, 52);
v->a[1835] = lex_mode_normal(214);
v->a[1836] = lex_mode_normal(214);
v->a[1837] = lex_mode_external(203, 52);
v->a[1838] = lex_mode_normal(214);
v->a[1839] = lex_mode_normal(214);
lex_modes_92(v);
}
void lex_modes_92(t_lex_modes_array *v)
{
v->a[1840] = lex_mode_external(121, 49);
v->a[1841] = lex_mode_external(121, 49);
v->a[1842] = lex_mode_external(121, 49);
v->a[1843] = lex_mode_external(121, 49);
v->a[1844] = lex_mode_external(121, 49);
v->a[1845] = lex_mode_external(121, 49);
v->a[1846] = lex_mode_external(121, 49);
v->a[1847] = lex_mode_external(121, 49);
v->a[1848] = lex_mode_normal(205);
v->a[1849] = lex_mode_external(197, 52);
v->a[1850] = lex_mode_external(197, 52);
v->a[1851] = lex_mode_external(197, 52);
v->a[1852] = lex_mode_external(197, 52);
v->a[1853] = lex_mode_external(197, 52);
v->a[1854] = lex_mode_external(197, 52);
v->a[1855] = lex_mode_external(197, 52);
v->a[1856] = lex_mode_external(197, 52);
v->a[1857] = lex_mode_external(197, 52);
v->a[1858] = lex_mode_external(197, 52);
v->a[1859] = lex_mode_external(197, 52);
v->a[1840] = lex_mode_external(203, 52);
v->a[1841] = lex_mode_normal(214);
v->a[1842] = lex_mode_external(203, 52);
v->a[1843] = lex_mode_normal(214);
v->a[1844] = lex_mode_normal(214);
v->a[1845] = lex_mode_normal(214);
v->a[1846] = lex_mode_normal(214);
v->a[1847] = lex_mode_external(198, 53);
v->a[1848] = lex_mode_normal(214);
v->a[1849] = lex_mode_normal(214);
v->a[1850] = lex_mode_normal(214);
v->a[1851] = lex_mode_normal(214);
v->a[1852] = lex_mode_external(203, 52);
v->a[1853] = lex_mode_external(203, 52);
v->a[1854] = lex_mode_normal(214);
v->a[1855] = lex_mode_normal(214);
v->a[1856] = lex_mode_external(207, 43);
v->a[1857] = lex_mode_normal(214);
v->a[1858] = lex_mode_normal(214);
v->a[1859] = lex_mode_external(203, 52);
lex_modes_93(v);
}
void lex_modes_93(t_lex_modes_array *v)
{
v->a[1860] = lex_mode_external(197, 52);
v->a[1861] = lex_mode_external(197, 52);
v->a[1862] = lex_mode_external(197, 52);
v->a[1863] = lex_mode_external(197, 52);
v->a[1864] = lex_mode_external(197, 52);
v->a[1865] = lex_mode_external(197, 52);
v->a[1866] = lex_mode_external(197, 52);
v->a[1867] = lex_mode_external(197, 52);
v->a[1868] = lex_mode_external(197, 52);
v->a[1869] = lex_mode_external(197, 52);
v->a[1870] = lex_mode_external(197, 52);
v->a[1871] = lex_mode_external(197, 52);
v->a[1872] = lex_mode_external(197, 52);
v->a[1873] = lex_mode_external(197, 52);
v->a[1874] = lex_mode_external(197, 52);
v->a[1875] = lex_mode_external(197, 52);
v->a[1876] = lex_mode_external(197, 52);
v->a[1877] = lex_mode_external(197, 52);
v->a[1878] = lex_mode_external(197, 52);
v->a[1879] = lex_mode_external(197, 52);
v->a[1860] = lex_mode_normal(214);
v->a[1861] = lex_mode_normal(214);
v->a[1862] = lex_mode_normal(214);
v->a[1863] = lex_mode_normal(214);
v->a[1864] = lex_mode_normal(214);
v->a[1865] = lex_mode_external(207, 43);
v->a[1866] = lex_mode_external(203, 52);
v->a[1867] = lex_mode_normal(214);
v->a[1868] = lex_mode_normal(214);
v->a[1869] = lex_mode_external(203, 52);
v->a[1870] = lex_mode_external(207, 43);
v->a[1871] = lex_mode_normal(214);
v->a[1872] = lex_mode_external(198, 53);
v->a[1873] = lex_mode_external(203, 52);
v->a[1874] = lex_mode_normal(214);
v->a[1875] = lex_mode_normal(214);
v->a[1876] = lex_mode_external(207, 43);
v->a[1877] = lex_mode_external(198, 53);
v->a[1878] = lex_mode_normal(214);
v->a[1879] = lex_mode_external(203, 52);
lex_modes_94(v);
}
void lex_modes_94(t_lex_modes_array *v)
{
v->a[1880] = lex_mode_external(197, 52);
v->a[1881] = lex_mode_external(197, 52);
v->a[1882] = lex_mode_external(197, 52);
v->a[1883] = lex_mode_external(197, 52);
v->a[1884] = lex_mode_external(197, 52);
v->a[1885] = lex_mode_external(197, 52);
v->a[1886] = lex_mode_external(197, 52);
v->a[1887] = lex_mode_external(197, 52);
v->a[1888] = lex_mode_external(197, 52);
v->a[1889] = lex_mode_external(197, 52);
v->a[1890] = lex_mode_external(197, 52);
v->a[1891] = lex_mode_external(197, 52);
v->a[1892] = lex_mode_external(197, 52);
v->a[1893] = lex_mode_external(197, 52);
v->a[1894] = lex_mode_external(197, 52);
v->a[1895] = lex_mode_external(200, 52);
v->a[1896] = lex_mode_external(197, 52);
v->a[1897] = lex_mode_external(197, 52);
v->a[1898] = lex_mode_external(197, 52);
v->a[1899] = lex_mode_external(197, 52);
v->a[1880] = lex_mode_normal(214);
v->a[1881] = lex_mode_normal(214);
v->a[1882] = lex_mode_external(203, 52);
v->a[1883] = lex_mode_normal(214);
v->a[1884] = lex_mode_normal(214);
v->a[1885] = lex_mode_normal(214);
v->a[1886] = lex_mode_external(203, 52);
v->a[1887] = lex_mode_external(198, 53);
v->a[1888] = lex_mode_external(207, 43);
v->a[1889] = lex_mode_normal(214);
v->a[1890] = lex_mode_normal(214);
v->a[1891] = lex_mode_external(207, 43);
v->a[1892] = lex_mode_external(203, 52);
v->a[1893] = lex_mode_normal(214);
v->a[1894] = lex_mode_external(203, 52);
v->a[1895] = lex_mode_external(203, 52);
v->a[1896] = lex_mode_normal(214);
v->a[1897] = lex_mode_normal(214);
v->a[1898] = lex_mode_normal(214);
v->a[1899] = lex_mode_external(207, 43);
lex_modes_95(v);
}

198
parser/static/lex_modes/lex_modes_19.c
View file

@ -14,126 +14,126 @@
void lex_modes_95(t_lex_modes_array *v)
{
v->a[1900] = lex_mode_external(197, 52);
v->a[1901] = lex_mode_external(243, 18);
v->a[1902] = lex_mode_external(243, 18);
v->a[1903] = lex_mode_external(197, 52);
v->a[1904] = lex_mode_external(197, 52);
v->a[1905] = lex_mode_external(197, 52);
v->a[1906] = lex_mode_external(197, 52);
v->a[1907] = lex_mode_external(197, 52);
v->a[1908] = lex_mode_external(197, 52);
v->a[1909] = lex_mode_external(197, 52);
v->a[1910] = lex_mode_external(197, 52);
v->a[1911] = lex_mode_external(197, 52);
v->a[1912] = lex_mode_external(197, 52);
v->a[1913] = lex_mode_external(197, 52);
v->a[1914] = lex_mode_external(197, 52);
v->a[1915] = lex_mode_external(197, 52);
v->a[1916] = lex_mode_external(247, 49);
v->a[1917] = lex_mode_external(202, 52);
v->a[1918] = lex_mode_external(202, 52);
v->a[1919] = lex_mode_external(202, 52);
v->a[1900] = lex_mode_normal(214);
v->a[1901] = lex_mode_external(203, 52);
v->a[1902] = lex_mode_external(203, 52);
v->a[1903] = lex_mode_normal(214);
v->a[1904] = lex_mode_external(203, 52);
v->a[1905] = lex_mode_external(203, 52);
v->a[1906] = lex_mode_normal(214);
v->a[1907] = lex_mode_normal(214);
v->a[1908] = lex_mode_normal(214);
v->a[1909] = lex_mode_normal(214);
v->a[1910] = lex_mode_normal(214);
v->a[1911] = lex_mode_normal(214);
v->a[1912] = lex_mode_external(203, 52);
v->a[1913] = lex_mode_normal(214);
v->a[1914] = lex_mode_normal(214);
v->a[1915] = lex_mode_normal(214);
v->a[1916] = lex_mode_external(203, 52);
v->a[1917] = lex_mode_external(203, 52);
v->a[1918] = lex_mode_external(203, 52);
v->a[1919] = lex_mode_normal(214);
lex_modes_96(v);
}
void lex_modes_96(t_lex_modes_array *v)
{
v->a[1920] = lex_mode_external(202, 52);
v->a[1921] = lex_mode_external(202, 52);
v->a[1922] = lex_mode_external(202, 52);
v->a[1923] = lex_mode_external(202, 52);
v->a[1924] = lex_mode_external(202, 52);
v->a[1925] = lex_mode_external(202, 52);
v->a[1926] = lex_mode_external(202, 52);
v->a[1927] = lex_mode_external(210, 50);
v->a[1928] = lex_mode_external(202, 52);
v->a[1929] = lex_mode_external(202, 52);
v->a[1930] = lex_mode_external(202, 52);
v->a[1931] = lex_mode_external(202, 52);
v->a[1932] = lex_mode_external(202, 52);
v->a[1933] = lex_mode_external(202, 52);
v->a[1934] = lex_mode_external(202, 52);
v->a[1935] = lex_mode_external(202, 52);
v->a[1936] = lex_mode_external(202, 52);
v->a[1937] = lex_mode_external(202, 52);
v->a[1938] = lex_mode_external(202, 52);
v->a[1939] = lex_mode_external(202, 52);
v->a[1920] = lex_mode_external(207, 43);
v->a[1921] = lex_mode_normal(214);
v->a[1922] = lex_mode_external(205, 44);
v->a[1923] = lex_mode_external(205, 44);
v->a[1924] = lex_mode_external(205, 44);
v->a[1925] = lex_mode_external(205, 44);
v->a[1926] = lex_mode_external(205, 44);
v->a[1927] = lex_mode_external(205, 44);
v->a[1928] = lex_mode_external(205, 44);
v->a[1929] = lex_mode_external(205, 44);
v->a[1930] = lex_mode_external(205, 44);
v->a[1931] = lex_mode_external(205, 44);
v->a[1932] = lex_mode_external(205, 44);
v->a[1933] = lex_mode_external(205, 44);
v->a[1934] = lex_mode_external(205, 44);
v->a[1935] = lex_mode_normal(198);
v->a[1936] = lex_mode_normal(198);
v->a[1937] = lex_mode_normal(198);
v->a[1938] = lex_mode_normal(198);
v->a[1939] = lex_mode_normal(198);
lex_modes_97(v);
}
void lex_modes_97(t_lex_modes_array *v)
{
v->a[1940] = lex_mode_external(202, 52);
v->a[1941] = lex_mode_external(202, 52);
v->a[1942] = lex_mode_external(202, 52);
v->a[1943] = lex_mode_external(201, 52);
v->a[1944] = lex_mode_external(247, 49);
v->a[1945] = lex_mode_external(202, 52);
v->a[1946] = lex_mode_external(202, 52);
v->a[1947] = lex_mode_external(202, 52);
v->a[1948] = lex_mode_external(202, 52);
v->a[1949] = lex_mode_external(202, 52);
v->a[1950] = lex_mode_external(202, 52);
v->a[1951] = lex_mode_external(202, 52);
v->a[1952] = lex_mode_external(202, 52);
v->a[1953] = lex_mode_external(203, 52);
v->a[1954] = lex_mode_normal(214);
v->a[1955] = lex_mode_normal(214);
v->a[1956] = lex_mode_normal(214);
v->a[1957] = lex_mode_external(203, 52);
v->a[1958] = lex_mode_normal(214);
v->a[1959] = lex_mode_external(203, 52);
v->a[1940] = lex_mode_normal(198);
v->a[1941] = lex_mode_normal(198);
v->a[1942] = lex_mode_external(254, 54);
v->a[1943] = lex_mode_normal(198);
v->a[1944] = lex_mode_external(254, 54);
v->a[1945] = lex_mode_external(254, 54);
v->a[1946] = lex_mode_normal(198);
v->a[1947] = lex_mode_normal(198);
v->a[1948] = lex_mode_normal(198);
v->a[1949] = lex_mode_normal(198);
v->a[1950] = lex_mode_normal(198);
v->a[1951] = lex_mode_normal(198);
v->a[1952] = lex_mode_normal(198);
v->a[1953] = lex_mode_external(245, 45);
v->a[1954] = lex_mode_external(67, 49);
v->a[1955] = lex_mode_normal(208);
v->a[1956] = lex_mode_external(67, 49);
v->a[1957] = lex_mode_external(67, 49);
v->a[1958] = lex_mode_external(214, 55);
v->a[1959] = lex_mode_external(211, 56);
lex_modes_98(v);
}
void lex_modes_98(t_lex_modes_array *v)
{
v->a[1960] = lex_mode_normal(214);
v->a[1961] = lex_mode_normal(214);
v->a[1962] = lex_mode_external(198, 53);
v->a[1963] = lex_mode_normal(214);
v->a[1964] = lex_mode_external(207, 43);
v->a[1965] = lex_mode_normal(214);
v->a[1966] = lex_mode_external(203, 52);
v->a[1967] = lex_mode_normal(214);
v->a[1968] = lex_mode_external(203, 52);
v->a[1969] = lex_mode_normal(214);
v->a[1970] = lex_mode_normal(214);
v->a[1971] = lex_mode_normal(214);
v->a[1972] = lex_mode_normal(214);
v->a[1973] = lex_mode_external(203, 52);
v->a[1974] = lex_mode_normal(214);
v->a[1975] = lex_mode_external(203, 52);
v->a[1976] = lex_mode_external(203, 52);
v->a[1977] = lex_mode_normal(214);
v->a[1978] = lex_mode_normal(214);
v->a[1979] = lex_mode_external(198, 53);
v->a[1960] = lex_mode_external(214, 55);
v->a[1961] = lex_mode_external(214, 55);
v->a[1962] = lex_mode_external(67, 49);
v->a[1963] = lex_mode_external(214, 55);
v->a[1964] = lex_mode_external(214, 55);
v->a[1965] = lex_mode_external(214, 55);
v->a[1966] = lex_mode_external(214, 55);
v->a[1967] = lex_mode_external(214, 55);
v->a[1968] = lex_mode_external(67, 49);
v->a[1969] = lex_mode_external(214, 55);
v->a[1970] = lex_mode_external(214, 55);
v->a[1971] = lex_mode_external(211, 56);
v->a[1972] = lex_mode_external(211, 56);
v->a[1973] = lex_mode_external(214, 55);
v->a[1974] = lex_mode_external(67, 49);
v->a[1975] = lex_mode_external(67, 49);
v->a[1976] = lex_mode_external(67, 49);
v->a[1977] = lex_mode_external(67, 49);
v->a[1978] = lex_mode_external(67, 49);
v->a[1979] = lex_mode_external(67, 49);
lex_modes_99(v);
}
void lex_modes_99(t_lex_modes_array *v)
{
v->a[1980] = lex_mode_normal(214);
v->a[1981] = lex_mode_normal(214);
v->a[1982] = lex_mode_external(203, 52);
v->a[1983] = lex_mode_external(207, 43);
v->a[1984] = lex_mode_external(203, 52);
v->a[1985] = lex_mode_normal(214);
v->a[1986] = lex_mode_normal(214);
v->a[1987] = lex_mode_normal(214);
v->a[1988] = lex_mode_external(203, 52);
v->a[1989] = lex_mode_normal(214);
v->a[1990] = lex_mode_external(207, 43);
v->a[1991] = lex_mode_external(207, 43);
v->a[1992] = lex_mode_normal(214);
v->a[1993] = lex_mode_normal(214);
v->a[1994] = lex_mode_normal(214);
v->a[1995] = lex_mode_external(203, 52);
v->a[1996] = lex_mode_normal(214);
v->a[1997] = lex_mode_external(203, 52);
v->a[1998] = lex_mode_normal(214);
v->a[1999] = lex_mode_normal(214);
v->a[1981] = lex_mode_external(67, 49);
v->a[1982] = lex_mode_external(67, 49);
v->a[1983] = lex_mode_normal(214);
v->a[1984] = lex_mode_external(67, 49);
v->a[1985] = lex_mode_external(67, 49);
v->a[1986] = lex_mode_external(67, 49);
v->a[1987] = lex_mode_external(67, 49);
v->a[1988] = lex_mode_external(67, 49);
v->a[1989] = lex_mode_external(67, 49);
v->a[1990] = lex_mode_external(67, 45);
v->a[1991] = lex_mode_normal(254);
v->a[1992] = lex_mode_external(217, 55);
v->a[1993] = lex_mode_external(67, 45);
v->a[1994] = lex_mode_external(254, 54);
v->a[1995] = lex_mode_external(217, 55);
v->a[1996] = lex_mode_external(67, 45);
v->a[1997] = lex_mode_normal(254);
v->a[1998] = lex_mode_external(217, 55);
v->a[1999] = lex_mode_external(67, 45);
lex_modes_100(v);
}

194
parser/static/lex_modes/lex_modes_2.c
View file

@ -14,126 +14,126 @@
void lex_modes_10(t_lex_modes_array *v)
{
v->a[200] = lex_mode_external(246, 12);
v->a[201] = lex_mode_external(246, 12);
v->a[202] = lex_mode_external(122, 6);
v->a[203] = lex_mode_external(246, 7);
v->a[204] = lex_mode_external(246, 7);
v->a[205] = lex_mode_external(105, 11);
v->a[206] = lex_mode_external(246, 7);
v->a[207] = lex_mode_external(105, 8);
v->a[208] = lex_mode_external(105, 8);
v->a[209] = lex_mode_external(246, 12);
v->a[210] = lex_mode_external(105, 8);
v->a[211] = lex_mode_external(105, 11);
v->a[212] = lex_mode_external(246, 14);
v->a[213] = lex_mode_external(246, 7);
v->a[214] = lex_mode_external(246, 12);
v->a[215] = lex_mode_external(122, 7);
v->a[216] = lex_mode_external(105, 15);
v->a[217] = lex_mode_external(246, 7);
v->a[218] = lex_mode_external(246, 7);
v->a[219] = lex_mode_external(246, 12);
v->a[200] = lex_mode_external(106, 12);
v->a[201] = lex_mode_external(106, 12);
v->a[202] = lex_mode_external(245, 11);
v->a[203] = lex_mode_external(245, 7);
v->a[204] = lex_mode_external(123, 6);
v->a[205] = lex_mode_external(106, 8);
v->a[206] = lex_mode_external(245, 11);
v->a[207] = lex_mode_external(106, 8);
v->a[208] = lex_mode_external(245, 7);
v->a[209] = lex_mode_external(188, 13);
v->a[210] = lex_mode_external(245, 11);
v->a[211] = lex_mode_external(106, 8);
v->a[212] = lex_mode_external(245, 7);
v->a[213] = lex_mode_external(106, 14);
v->a[214] = lex_mode_external(245, 15);
v->a[215] = lex_mode_external(245, 7);
v->a[216] = lex_mode_external(245, 15);
v->a[217] = lex_mode_external(245, 15);
v->a[218] = lex_mode_external(245, 11);
v->a[219] = lex_mode_external(245, 11);
lex_modes_11(v);
}
void lex_modes_11(t_lex_modes_array *v)
{
v->a[220] = lex_mode_external(122, 7);
v->a[221] = lex_mode_external(246, 7);
v->a[222] = lex_mode_external(105, 8);
v->a[223] = lex_mode_external(105, 8);
v->a[224] = lex_mode_external(246, 12);
v->a[225] = lex_mode_external(246, 7);
v->a[226] = lex_mode_external(246, 14);
v->a[227] = lex_mode_external(189, 16);
v->a[228] = lex_mode_external(246, 12);
v->a[229] = lex_mode_external(246, 7);
v->a[230] = lex_mode_external(246, 12);
v->a[231] = lex_mode_external(246, 7);
v->a[232] = lex_mode_external(246, 14);
v->a[233] = lex_mode_external(246, 14);
v->a[234] = lex_mode_external(246, 14);
v->a[235] = lex_mode_external(105, 15);
v->a[236] = lex_mode_external(246, 14);
v->a[237] = lex_mode_external(105, 15);
v->a[238] = lex_mode_external(246, 7);
v->a[239] = lex_mode_external(189, 17);
v->a[220] = lex_mode_external(245, 15);
v->a[221] = lex_mode_external(245, 7);
v->a[222] = lex_mode_external(106, 8);
v->a[223] = lex_mode_external(106, 8);
v->a[224] = lex_mode_external(245, 7);
v->a[225] = lex_mode_external(245, 15);
v->a[226] = lex_mode_external(106, 8);
v->a[227] = lex_mode_external(245, 15);
v->a[228] = lex_mode_external(245, 7);
v->a[229] = lex_mode_external(106, 8);
v->a[230] = lex_mode_external(106, 14);
v->a[231] = lex_mode_external(189, 16);
v->a[232] = lex_mode_external(123, 7);
v->a[233] = lex_mode_external(245, 7);
v->a[234] = lex_mode_external(106, 14);
v->a[235] = lex_mode_external(245, 7);
v->a[236] = lex_mode_external(245, 7);
v->a[237] = lex_mode_external(123, 7);
v->a[238] = lex_mode_external(245, 7);
v->a[239] = lex_mode_external(245, 11);
lex_modes_12(v);
}
void lex_modes_12(t_lex_modes_array *v)
{
v->a[240] = lex_mode_external(246, 14);
v->a[241] = lex_mode_external(246, 14);
v->a[242] = lex_mode_external(246, 10);
v->a[243] = lex_mode_external(105, 8);
v->a[244] = lex_mode_external(246, 14);
v->a[245] = lex_mode_external(246, 7);
v->a[246] = lex_mode_external(111, 18);
v->a[247] = lex_mode_external(111, 18);
v->a[248] = lex_mode_external(105, 8);
v->a[249] = lex_mode_external(189, 17);
v->a[250] = lex_mode_external(105, 15);
v->a[251] = lex_mode_external(105, 15);
v->a[252] = lex_mode_external(111, 18);
v->a[253] = lex_mode_external(111, 18);
v->a[254] = lex_mode_external(246, 10);
v->a[255] = lex_mode_external(246, 7);
v->a[256] = lex_mode_external(246, 7);
v->a[257] = lex_mode_external(246, 7);
v->a[258] = lex_mode_external(246, 14);
v->a[259] = lex_mode_external(246, 7);
v->a[240] = lex_mode_external(245, 7);
v->a[241] = lex_mode_external(245, 7);
v->a[242] = lex_mode_external(245, 11);
v->a[243] = lex_mode_external(245, 11);
v->a[244] = lex_mode_external(245, 7);
v->a[245] = lex_mode_external(110, 17);
v->a[246] = lex_mode_external(245, 15);
v->a[247] = lex_mode_external(245, 15);
v->a[248] = lex_mode_external(106, 8);
v->a[249] = lex_mode_external(106, 14);
v->a[250] = lex_mode_external(245, 15);
v->a[251] = lex_mode_external(245, 9);
v->a[252] = lex_mode_external(245, 7);
v->a[253] = lex_mode_external(245, 7);
v->a[254] = lex_mode_external(245, 7);
v->a[255] = lex_mode_external(245, 7);
v->a[256] = lex_mode_external(245, 7);
v->a[257] = lex_mode_external(245, 7);
v->a[258] = lex_mode_external(245, 15);
v->a[259] = lex_mode_external(245, 9);
lex_modes_13(v);
}
void lex_modes_13(t_lex_modes_array *v)
{
v->a[260] = lex_mode_external(246, 14);
v->a[261] = lex_mode_external(246, 14);
v->a[262] = lex_mode_external(246, 14);
v->a[263] = lex_mode_external(246, 14);
v->a[264] = lex_mode_external(246, 14);
v->a[265] = lex_mode_external(111, 18);
v->a[266] = lex_mode_external(246, 7);
v->a[267] = lex_mode_external(105, 8);
v->a[268] = lex_mode_external(246, 7);
v->a[269] = lex_mode_external(111, 18);
v->a[270] = lex_mode_external(246, 7);
v->a[271] = lex_mode_external(105, 8);
v->a[272] = lex_mode_external(246, 7);
v->a[273] = lex_mode_external(246, 14);
v->a[274] = lex_mode_external(246, 7);
v->a[275] = lex_mode_external(246, 7);
v->a[276] = lex_mode_external(246, 14);
v->a[277] = lex_mode_external(247, 19);
v->a[278] = lex_mode_external(110, 20);
v->a[279] = lex_mode_external(246, 7);
v->a[260] = lex_mode_external(245, 15);
v->a[261] = lex_mode_external(245, 15);
v->a[262] = lex_mode_external(245, 7);
v->a[263] = lex_mode_external(245, 15);
v->a[264] = lex_mode_external(245, 7);
v->a[265] = lex_mode_external(189, 18);
v->a[266] = lex_mode_external(245, 7);
v->a[267] = lex_mode_external(106, 8);
v->a[268] = lex_mode_external(245, 15);
v->a[269] = lex_mode_external(110, 17);
v->a[270] = lex_mode_external(189, 18);
v->a[271] = lex_mode_external(245, 7);
v->a[272] = lex_mode_external(245, 15);
v->a[273] = lex_mode_external(110, 17);
v->a[274] = lex_mode_external(110, 17);
v->a[275] = lex_mode_external(110, 17);
v->a[276] = lex_mode_external(245, 7);
v->a[277] = lex_mode_external(245, 7);
v->a[278] = lex_mode_external(110, 17);
v->a[279] = lex_mode_external(245, 7);
lex_modes_14(v);
}
void lex_modes_14(t_lex_modes_array *v)
{
v->a[280] = lex_mode_external(247, 19);
v->a[281] = lex_mode_external(246, 7);
v->a[282] = lex_mode_external(110, 20);
v->a[283] = lex_mode_external(110, 20);
v->a[284] = lex_mode_external(205, 21);
v->a[285] = lex_mode_external(247, 19);
v->a[286] = lex_mode_external(246, 7);
v->a[287] = lex_mode_external(246, 14);
v->a[288] = lex_mode_external(246, 7);
v->a[289] = lex_mode_external(246, 7);
v->a[290] = lex_mode_external(246, 7);
v->a[280] = lex_mode_external(245, 7);
v->a[281] = lex_mode_external(245, 7);
v->a[282] = lex_mode_external(106, 14);
v->a[283] = lex_mode_external(247, 19);
v->a[284] = lex_mode_external(245, 15);
v->a[285] = lex_mode_external(205, 20);
v->a[286] = lex_mode_external(111, 21);
v->a[287] = lex_mode_external(205, 20);
v->a[288] = lex_mode_external(111, 21);
v->a[289] = lex_mode_external(111, 21);
v->a[290] = lex_mode_external(245, 15);
v->a[291] = lex_mode_external(247, 19);
v->a[292] = lex_mode_external(246, 14);
v->a[292] = lex_mode_external(247, 19);
v->a[293] = lex_mode_external(247, 19);
v->a[294] = lex_mode_external(247, 19);
v->a[295] = lex_mode_external(246, 7);
v->a[296] = lex_mode_external(247, 19);
v->a[297] = lex_mode_external(246, 7);
v->a[298] = lex_mode_external(205, 21);
v->a[299] = lex_mode_external(110, 20);
v->a[295] = lex_mode_external(245, 7);
v->a[296] = lex_mode_external(245, 7);
v->a[297] = lex_mode_external(111, 21);
v->a[298] = lex_mode_external(245, 7);
v->a[299] = lex_mode_external(247, 19);
lex_modes_15(v);
}

200
parser/static/lex_modes/lex_modes_20.c
View file

@ -14,126 +14,126 @@
void lex_modes_100(t_lex_modes_array *v)
{
v->a[2000] = lex_mode_external(203, 52);
v->a[2001] = lex_mode_normal(214);
v->a[2002] = lex_mode_external(207, 43);
v->a[2003] = lex_mode_normal(214);
v->a[2004] = lex_mode_external(207, 43);
v->a[2005] = lex_mode_external(207, 43);
v->a[2006] = lex_mode_external(203, 52);
v->a[2007] = lex_mode_normal(214);
v->a[2008] = lex_mode_normal(214);
v->a[2009] = lex_mode_external(198, 53);
v->a[2010] = lex_mode_external(203, 52);
v->a[2011] = lex_mode_external(203, 52);
v->a[2012] = lex_mode_normal(214);
v->a[2013] = lex_mode_external(203, 52);
v->a[2014] = lex_mode_external(207, 43);
v->a[2015] = lex_mode_normal(214);
v->a[2016] = lex_mode_external(207, 43);
v->a[2017] = lex_mode_normal(214);
v->a[2018] = lex_mode_external(203, 52);
v->a[2019] = lex_mode_normal(214);
v->a[2000] = lex_mode_external(254, 54);
v->a[2001] = lex_mode_external(254, 54);
v->a[2002] = lex_mode_external(211, 56);
v->a[2003] = lex_mode_normal(254);
v->a[2004] = lex_mode_external(217, 55);
v->a[2005] = lex_mode_external(254, 54);
v->a[2006] = lex_mode_external(254, 54);
v->a[2007] = lex_mode_external(211, 56);
v->a[2008] = lex_mode_external(211, 56);
v->a[2009] = lex_mode_external(67, 45);
v->a[2010] = lex_mode_external(211, 56);
v->a[2011] = lex_mode_external(254, 54);
v->a[2012] = lex_mode_external(67, 45);
v->a[2013] = lex_mode_normal(254);
v->a[2014] = lex_mode_normal(254);
v->a[2015] = lex_mode_normal(254);
v->a[2016] = lex_mode_external(254, 54);
v->a[2017] = lex_mode_external(211, 56);
v->a[2018] = lex_mode_external(254, 57);
v->a[2019] = lex_mode_external(254, 57);
lex_modes_101(v);
}
void lex_modes_101(t_lex_modes_array *v)
{
v->a[2020] = lex_mode_external(207, 43);
v->a[2021] = lex_mode_normal(214);
v->a[2022] = lex_mode_normal(214);
v->a[2023] = lex_mode_normal(214);
v->a[2024] = lex_mode_external(203, 52);
v->a[2025] = lex_mode_normal(214);
v->a[2026] = lex_mode_normal(214);
v->a[2027] = lex_mode_normal(214);
v->a[2028] = lex_mode_normal(214);
v->a[2029] = lex_mode_normal(214);
v->a[2030] = lex_mode_external(198, 53);
v->a[2031] = lex_mode_external(203, 52);
v->a[2032] = lex_mode_external(203, 52);
v->a[2033] = lex_mode_external(203, 52);
v->a[2034] = lex_mode_external(198, 53);
v->a[2035] = lex_mode_normal(214);
v->a[2036] = lex_mode_normal(214);
v->a[2037] = lex_mode_external(203, 52);
v->a[2038] = lex_mode_normal(214);
v->a[2039] = lex_mode_external(203, 52);
v->a[2020] = lex_mode_external(217, 55);
v->a[2021] = lex_mode_external(217, 55);
v->a[2022] = lex_mode_external(217, 55);
v->a[2023] = lex_mode_external(217, 55);
v->a[2024] = lex_mode_external(254, 57);
v->a[2025] = lex_mode_external(254, 57);
v->a[2026] = lex_mode_external(254, 57);
v->a[2027] = lex_mode_external(254, 57);
v->a[2028] = lex_mode_external(254, 57);
v->a[2029] = lex_mode_external(254, 57);
v->a[2030] = lex_mode_external(254, 57);
v->a[2031] = lex_mode_external(217, 55);
v->a[2032] = lex_mode_external(254, 57);
v->a[2033] = lex_mode_external(254, 57);
v->a[2034] = lex_mode_external(254, 57);
v->a[2035] = lex_mode_external(254, 57);
v->a[2036] = lex_mode_external(254, 57);
v->a[2037] = lex_mode_external(217, 55);
v->a[2038] = lex_mode_external(254, 57);
v->a[2039] = lex_mode_external(254, 57);
lex_modes_102(v);
}
void lex_modes_102(t_lex_modes_array *v)
{
v->a[2040] = lex_mode_external(203, 52);
v->a[2041] = lex_mode_normal(214);
v->a[2042] = lex_mode_normal(214);
v->a[2043] = lex_mode_normal(214);
v->a[2044] = lex_mode_normal(214);
v->a[2045] = lex_mode_external(203, 52);
v->a[2046] = lex_mode_normal(214);
v->a[2047] = lex_mode_normal(214);
v->a[2048] = lex_mode_external(198, 53);
v->a[2049] = lex_mode_normal(214);
v->a[2050] = lex_mode_external(203, 52);
v->a[2051] = lex_mode_normal(214);
v->a[2052] = lex_mode_normal(214);
v->a[2053] = lex_mode_normal(214);
v->a[2054] = lex_mode_external(198, 53);
v->a[2055] = lex_mode_normal(214);
v->a[2056] = lex_mode_external(207, 43);
v->a[2057] = lex_mode_normal(214);
v->a[2058] = lex_mode_normal(214);
v->a[2059] = lex_mode_external(203, 52);
v->a[2040] = lex_mode_external(254, 57);
v->a[2041] = lex_mode_external(254, 57);
v->a[2042] = lex_mode_external(254, 57);
v->a[2043] = lex_mode_external(254, 57);
v->a[2044] = lex_mode_external(254, 57);
v->a[2045] = lex_mode_external(254, 57);
v->a[2046] = lex_mode_external(254, 57);
v->a[2047] = lex_mode_external(254, 57);
v->a[2048] = lex_mode_external(254, 57);
v->a[2049] = lex_mode_external(254, 57);
v->a[2050] = lex_mode_external(254, 57);
v->a[2051] = lex_mode_external(217, 55);
v->a[2052] = lex_mode_external(217, 55);
v->a[2053] = lex_mode_external(217, 55);
v->a[2054] = lex_mode_external(217, 55);
v->a[2055] = lex_mode_external(254, 57);
v->a[2056] = lex_mode_external(254, 57);
v->a[2057] = lex_mode_external(254, 57);
v->a[2058] = lex_mode_external(254, 57);
v->a[2059] = lex_mode_external(217, 55);
lex_modes_103(v);
}
void lex_modes_103(t_lex_modes_array *v)
{
v->a[2060] = lex_mode_external(203, 52);
v->a[2061] = lex_mode_normal(214);
v->a[2062] = lex_mode_normal(214);
v->a[2063] = lex_mode_external(203, 52);
v->a[2064] = lex_mode_normal(214);
v->a[2065] = lex_mode_normal(214);
v->a[2066] = lex_mode_normal(214);
v->a[2067] = lex_mode_external(207, 43);
v->a[2068] = lex_mode_external(205, 44);
v->a[2069] = lex_mode_external(205, 44);
v->a[2070] = lex_mode_external(205, 44);
v->a[2071] = lex_mode_external(205, 44);
v->a[2072] = lex_mode_external(205, 44);
v->a[2073] = lex_mode_external(205, 44);
v->a[2074] = lex_mode_external(205, 44);
v->a[2075] = lex_mode_external(205, 44);
v->a[2076] = lex_mode_external(205, 44);
v->a[2077] = lex_mode_external(205, 44);
v->a[2078] = lex_mode_external(205, 44);
v->a[2079] = lex_mode_external(205, 44);
v->a[2060] = lex_mode_external(254, 57);
v->a[2061] = lex_mode_external(254, 57);
v->a[2062] = lex_mode_external(254, 57);
v->a[2063] = lex_mode_external(254, 57);
v->a[2064] = lex_mode_external(217, 55);
v->a[2065] = lex_mode_normal(254);
v->a[2066] = lex_mode_external(217, 55);
v->a[2067] = lex_mode_external(217, 55);
v->a[2068] = lex_mode_external(254, 57);
v->a[2069] = lex_mode_external(217, 55);
v->a[2070] = lex_mode_external(217, 55);
v->a[2071] = lex_mode_external(196, 55);
v->a[2072] = lex_mode_external(196, 55);
v->a[2073] = lex_mode_external(196, 55);
v->a[2074] = lex_mode_external(217, 55);
v->a[2075] = lex_mode_normal(217);
v->a[2076] = lex_mode_external(217, 48);
v->a[2077] = lex_mode_external(196, 55);
v->a[2078] = lex_mode_normal(217);
v->a[2079] = lex_mode_external(217, 48);
lex_modes_104(v);
}
void lex_modes_104(t_lex_modes_array *v)
{
v->a[2080] = lex_mode_external(205, 44);
v->a[2081] = lex_mode_normal(198);
v->a[2082] = lex_mode_normal(198);
v->a[2083] = lex_mode_normal(198);
v->a[2084] = lex_mode_normal(198);
v->a[2085] = lex_mode_normal(198);
v->a[2086] = lex_mode_normal(198);
v->a[2087] = lex_mode_normal(198);
v->a[2088] = lex_mode_normal(198);
v->a[2089] = lex_mode_normal(198);
v->a[2090] = lex_mode_normal(198);
v->a[2091] = lex_mode_external(254, 54);
v->a[2092] = lex_mode_normal(198);
v->a[2093] = lex_mode_external(254, 54);
v->a[2094] = lex_mode_normal(198);
v->a[2095] = lex_mode_external(254, 54);
v->a[2096] = lex_mode_normal(198);
v->a[2097] = lex_mode_normal(198);
v->a[2098] = lex_mode_external(246, 45);
v->a[2099] = lex_mode_normal(198);
v->a[2080] = lex_mode_external(217, 48);
v->a[2081] = lex_mode_external(217, 48);
v->a[2082] = lex_mode_external(217, 48);
v->a[2083] = lex_mode_normal(217);
v->a[2084] = lex_mode_external(217, 48);
v->a[2085] = lex_mode_normal(217);
v->a[2086] = lex_mode_external(217, 48);
v->a[2087] = lex_mode_normal(217);
v->a[2088] = lex_mode_normal(217);
v->a[2089] = lex_mode_external(217, 48);
v->a[2090] = lex_mode_external(196, 55);
v->a[2091] = lex_mode_external(217, 48);
v->a[2092] = lex_mode_normal(217);
v->a[2093] = lex_mode_normal(217);
v->a[2094] = lex_mode_normal(217);
v->a[2095] = lex_mode_normal(217);
v->a[2096] = lex_mode_external(217, 48);
v->a[2097] = lex_mode_normal(217);
v->a[2098] = lex_mode_normal(217);
v->a[2099] = lex_mode_normal(217);
lex_modes_105(v);
}

196
parser/static/lex_modes/lex_modes_21.c
View file

@ -14,126 +14,126 @@
void lex_modes_105(t_lex_modes_array *v)
{
v->a[2100] = lex_mode_normal(208);
v->a[2101] = lex_mode_external(214, 55);
v->a[2102] = lex_mode_external(214, 55);
v->a[2103] = lex_mode_external(214, 55);
v->a[2104] = lex_mode_external(211, 56);
v->a[2105] = lex_mode_external(214, 55);
v->a[2106] = lex_mode_external(214, 55);
v->a[2107] = lex_mode_external(214, 55);
v->a[2108] = lex_mode_external(66, 49);
v->a[2109] = lex_mode_external(214, 55);
v->a[2110] = lex_mode_external(211, 56);
v->a[2111] = lex_mode_external(214, 55);
v->a[2112] = lex_mode_external(66, 49);
v->a[2113] = lex_mode_external(214, 55);
v->a[2114] = lex_mode_external(214, 55);
v->a[2115] = lex_mode_external(66, 49);
v->a[2116] = lex_mode_external(66, 49);
v->a[2117] = lex_mode_external(214, 55);
v->a[2118] = lex_mode_external(211, 56);
v->a[2119] = lex_mode_external(66, 49);
v->a[2100] = lex_mode_external(254, 58);
v->a[2101] = lex_mode_normal(198);
v->a[2102] = lex_mode_normal(217);
v->a[2103] = lex_mode_normal(217);
v->a[2104] = lex_mode_external(254, 58);
v->a[2105] = lex_mode_normal(254);
v->a[2106] = lex_mode_normal(254);
v->a[2107] = lex_mode_external(254, 58);
v->a[2108] = lex_mode_external(254, 58);
v->a[2109] = lex_mode_external(254, 58);
v->a[2110] = lex_mode_external(254, 58);
v->a[2111] = lex_mode_normal(254);
v->a[2112] = lex_mode_external(254, 58);
v->a[2113] = lex_mode_external(254, 58);
v->a[2114] = lex_mode_normal(254);
v->a[2115] = lex_mode_normal(198);
v->a[2116] = lex_mode_normal(198);
v->a[2117] = lex_mode_normal(198);
v->a[2118] = lex_mode_external(254, 58);
v->a[2119] = lex_mode_normal(254);
lex_modes_106(v);
}
void lex_modes_106(t_lex_modes_array *v)
{
v->a[2120] = lex_mode_external(66, 49);
v->a[2121] = lex_mode_normal(214);
v->a[2122] = lex_mode_external(66, 49);
v->a[2123] = lex_mode_external(66, 49);
v->a[2124] = lex_mode_external(66, 49);
v->a[2125] = lex_mode_external(66, 49);
v->a[2126] = lex_mode_external(66, 49);
v->a[2127] = lex_mode_external(66, 49);
v->a[2128] = lex_mode_external(66, 49);
v->a[2129] = lex_mode_external(66, 49);
v->a[2130] = lex_mode_external(66, 49);
v->a[2131] = lex_mode_external(66, 49);
v->a[2132] = lex_mode_external(66, 49);
v->a[2133] = lex_mode_external(66, 49);
v->a[2134] = lex_mode_normal(214);
v->a[2135] = lex_mode_external(66, 49);
v->a[2136] = lex_mode_external(211, 56);
v->a[2137] = lex_mode_external(211, 56);
v->a[2138] = lex_mode_external(254, 54);
v->a[2139] = lex_mode_external(254, 54);
v->a[2120] = lex_mode_external(254, 58);
v->a[2121] = lex_mode_normal(254);
v->a[2122] = lex_mode_normal(198);
v->a[2123] = lex_mode_normal(198);
v->a[2124] = lex_mode_normal(254);
v->a[2125] = lex_mode_normal(198);
v->a[2126] = lex_mode_external(254, 58);
v->a[2127] = lex_mode_external(254, 58);
v->a[2128] = lex_mode_external(241, 45);
v->a[2129] = lex_mode_normal(254);
v->a[2130] = lex_mode_external(241, 45);
v->a[2131] = lex_mode_normal(254);
v->a[2132] = lex_mode_normal(254);
v->a[2133] = lex_mode_normal(198);
v->a[2134] = lex_mode_external(254, 58);
v->a[2135] = lex_mode_external(254, 58);
v->a[2136] = lex_mode_external(254, 59);
v->a[2137] = lex_mode_external(254, 59);
v->a[2138] = lex_mode_normal(198);
v->a[2139] = lex_mode_external(254, 58);
lex_modes_107(v);
}
void lex_modes_107(t_lex_modes_array *v)
{
v->a[2140] = lex_mode_external(254, 54);
v->a[2141] = lex_mode_external(254, 54);
v->a[2142] = lex_mode_external(217, 55);
v->a[2143] = lex_mode_normal(254);
v->a[2144] = lex_mode_normal(254);
v->a[2145] = lex_mode_external(254, 54);
v->a[2146] = lex_mode_external(211, 56);
v->a[2147] = lex_mode_external(211, 56);
v->a[2148] = lex_mode_normal(254);
v->a[2149] = lex_mode_external(217, 55);
v->a[2140] = lex_mode_normal(196);
v->a[2141] = lex_mode_external(254, 58);
v->a[2142] = lex_mode_external(241, 45);
v->a[2143] = lex_mode_normal(198);
v->a[2144] = lex_mode_external(254, 58);
v->a[2145] = lex_mode_external(254, 58);
v->a[2146] = lex_mode_normal(198);
v->a[2147] = lex_mode_external(241, 45);
v->a[2148] = lex_mode_normal(198);
v->a[2149] = lex_mode_normal(198);
v->a[2150] = lex_mode_normal(254);
v->a[2151] = lex_mode_normal(254);
v->a[2152] = lex_mode_external(254, 54);
v->a[2153] = lex_mode_external(217, 55);
v->a[2154] = lex_mode_external(254, 54);
v->a[2155] = lex_mode_normal(254);
v->a[2156] = lex_mode_external(211, 56);
v->a[2157] = lex_mode_external(217, 55);
v->a[2158] = lex_mode_external(254, 57);
v->a[2159] = lex_mode_external(254, 57);
v->a[2151] = lex_mode_external(241, 45);
v->a[2152] = lex_mode_normal(254);
v->a[2153] = lex_mode_external(254, 58);
v->a[2154] = lex_mode_normal(254);
v->a[2155] = lex_mode_external(241, 45);
v->a[2156] = lex_mode_external(241, 45);
v->a[2157] = lex_mode_normal(254);
v->a[2158] = lex_mode_normal(254);
v->a[2159] = lex_mode_normal(254);
lex_modes_108(v);
}
void lex_modes_108(t_lex_modes_array *v)
{
v->a[2160] = lex_mode_external(217, 55);
v->a[2161] = lex_mode_external(217, 55);
v->a[2162] = lex_mode_external(254, 57);
v->a[2163] = lex_mode_external(254, 57);
v->a[2164] = lex_mode_external(254, 57);
v->a[2165] = lex_mode_external(217, 55);
v->a[2166] = lex_mode_external(254, 57);
v->a[2167] = lex_mode_external(254, 57);
v->a[2168] = lex_mode_external(254, 57);
v->a[2169] = lex_mode_external(254, 57);
v->a[2170] = lex_mode_external(217, 55);
v->a[2171] = lex_mode_external(217, 55);
v->a[2160] = lex_mode_normal(254);
v->a[2161] = lex_mode_external(241, 45);
v->a[2162] = lex_mode_normal(254);
v->a[2163] = lex_mode_normal(254);
v->a[2164] = lex_mode_normal(254);
v->a[2165] = lex_mode_external(254, 59);
v->a[2166] = lex_mode_external(241, 45);
v->a[2167] = lex_mode_external(254, 59);
v->a[2168] = lex_mode_normal(254);
v->a[2169] = lex_mode_normal(254);
v->a[2170] = lex_mode_normal(254);
v->a[2171] = lex_mode_external(254, 58);
v->a[2172] = lex_mode_normal(254);
v->a[2173] = lex_mode_external(254, 57);
v->a[2174] = lex_mode_external(254, 57);
v->a[2175] = lex_mode_external(254, 57);
v->a[2176] = lex_mode_external(254, 57);
v->a[2177] = lex_mode_external(254, 57);
v->a[2178] = lex_mode_external(254, 57);
v->a[2179] = lex_mode_external(66, 45);
v->a[2173] = lex_mode_external(254, 58);
v->a[2174] = lex_mode_external(254, 58);
v->a[2175] = lex_mode_external(254, 58);
v->a[2176] = lex_mode_normal(254);
v->a[2177] = lex_mode_external(254, 58);
v->a[2178] = lex_mode_external(241, 45);
v->a[2179] = lex_mode_external(241, 45);
lex_modes_109(v);
}
void lex_modes_109(t_lex_modes_array *v)
{
v->a[2180] = lex_mode_external(254, 57);
v->a[2181] = lex_mode_external(254, 57);
v->a[2182] = lex_mode_external(254, 57);
v->a[2183] = lex_mode_external(217, 55);
v->a[2184] = lex_mode_external(254, 57);
v->a[2185] = lex_mode_external(254, 57);
v->a[2186] = lex_mode_external(254, 57);
v->a[2187] = lex_mode_external(66, 45);
v->a[2188] = lex_mode_external(254, 57);
v->a[2189] = lex_mode_external(217, 55);
v->a[2190] = lex_mode_external(254, 57);
v->a[2191] = lex_mode_external(254, 57);
v->a[2192] = lex_mode_external(254, 57);
v->a[2193] = lex_mode_external(254, 57);
v->a[2194] = lex_mode_external(254, 57);
v->a[2195] = lex_mode_external(254, 57);
v->a[2196] = lex_mode_external(217, 55);
v->a[2197] = lex_mode_external(254, 57);
v->a[2198] = lex_mode_external(217, 55);
v->a[2199] = lex_mode_external(66, 45);
v->a[2180] = lex_mode_normal(254);
v->a[2181] = lex_mode_external(254, 58);
v->a[2182] = lex_mode_normal(254);
v->a[2183] = lex_mode_normal(254);
v->a[2184] = lex_mode_external(241, 45);
v->a[2185] = lex_mode_normal(254);
v->a[2186] = lex_mode_normal(198);
v->a[2187] = lex_mode_normal(254);
v->a[2188] = lex_mode_normal(196);
v->a[2189] = lex_mode_normal(254);
v->a[2190] = lex_mode_normal(254);
v->a[2191] = lex_mode_normal(254);
v->a[2192] = lex_mode_normal(196);
v->a[2193] = lex_mode_normal(254);
v->a[2194] = lex_mode_external(254, 58);
v->a[2195] = lex_mode_external(254, 58);
v->a[2196] = lex_mode_normal(254);
v->a[2197] = lex_mode_normal(196);
v->a[2198] = lex_mode_normal(254);
v->a[2199] = lex_mode_normal(254);
lex_modes_110(v);
}

176
parser/static/lex_modes/lex_modes_22.c
View file

@ -14,74 +14,74 @@
void lex_modes_110(t_lex_modes_array *v)
{
v->a[2200] = lex_mode_external(254, 57);
v->a[2201] = lex_mode_external(254, 57);
v->a[2202] = lex_mode_external(254, 57);
v->a[2203] = lex_mode_external(254, 57);
v->a[2204] = lex_mode_external(66, 45);
v->a[2205] = lex_mode_external(66, 45);
v->a[2206] = lex_mode_external(217, 55);
v->a[2207] = lex_mode_external(217, 55);
v->a[2208] = lex_mode_external(66, 45);
v->a[2209] = lex_mode_external(217, 55);
v->a[2210] = lex_mode_external(217, 55);
v->a[2211] = lex_mode_external(254, 57);
v->a[2212] = lex_mode_external(217, 55);
v->a[2213] = lex_mode_external(254, 57);
v->a[2214] = lex_mode_external(254, 57);
v->a[2215] = lex_mode_external(196, 55);
v->a[2216] = lex_mode_external(217, 55);
v->a[2217] = lex_mode_external(196, 55);
v->a[2218] = lex_mode_external(196, 55);
v->a[2219] = lex_mode_external(217, 55);
v->a[2200] = lex_mode_normal(254);
v->a[2201] = lex_mode_normal(254);
v->a[2202] = lex_mode_normal(196);
v->a[2203] = lex_mode_normal(196);
v->a[2204] = lex_mode_normal(254);
v->a[2205] = lex_mode_external(254, 60);
v->a[2206] = lex_mode_normal(254);
v->a[2207] = lex_mode_external(254, 60);
v->a[2208] = lex_mode_normal(196);
v->a[2209] = lex_mode_normal(254);
v->a[2210] = lex_mode_normal(196);
v->a[2211] = lex_mode_external(241, 45);
v->a[2212] = lex_mode_normal(254);
v->a[2213] = lex_mode_normal(254);
v->a[2214] = lex_mode_normal(196);
v->a[2215] = lex_mode_normal(254);
v->a[2216] = lex_mode_normal(254);
v->a[2217] = lex_mode_normal(196);
v->a[2218] = lex_mode_external(254, 58);
v->a[2219] = lex_mode_external(254, 58);
lex_modes_111(v);
}
void lex_modes_111(t_lex_modes_array *v)
{
v->a[2220] = lex_mode_external(217, 55);
v->a[2221] = lex_mode_normal(217);
v->a[2222] = lex_mode_normal(217);
v->a[2223] = lex_mode_external(217, 48);
v->a[2224] = lex_mode_normal(217);
v->a[2225] = lex_mode_normal(217);
v->a[2226] = lex_mode_normal(217);
v->a[2227] = lex_mode_external(196, 55);
v->a[2228] = lex_mode_normal(217);
v->a[2229] = lex_mode_external(217, 48);
v->a[2230] = lex_mode_external(217, 48);
v->a[2231] = lex_mode_normal(217);
v->a[2232] = lex_mode_normal(217);
v->a[2233] = lex_mode_normal(217);
v->a[2234] = lex_mode_normal(217);
v->a[2235] = lex_mode_normal(217);
v->a[2236] = lex_mode_external(217, 48);
v->a[2237] = lex_mode_normal(217);
v->a[2238] = lex_mode_external(217, 48);
v->a[2239] = lex_mode_external(217, 48);
v->a[2220] = lex_mode_normal(254);
v->a[2221] = lex_mode_normal(196);
v->a[2222] = lex_mode_external(254, 58);
v->a[2223] = lex_mode_normal(254);
v->a[2224] = lex_mode_normal(254);
v->a[2225] = lex_mode_normal(196);
v->a[2226] = lex_mode_normal(196);
v->a[2227] = lex_mode_normal(254);
v->a[2228] = lex_mode_normal(254);
v->a[2229] = lex_mode_normal(254);
v->a[2230] = lex_mode_normal(254);
v->a[2231] = lex_mode_external(241, 45);
v->a[2232] = lex_mode_normal(254);
v->a[2233] = lex_mode_normal(196);
v->a[2234] = lex_mode_normal(254);
v->a[2235] = lex_mode_normal(254);
v->a[2236] = lex_mode_normal(196);
v->a[2237] = lex_mode_normal(254);
v->a[2238] = lex_mode_normal(254);
v->a[2239] = lex_mode_external(254, 59);
lex_modes_112(v);
}
void lex_modes_112(t_lex_modes_array *v)
{
v->a[2240] = lex_mode_normal(217);
v->a[2241] = lex_mode_external(196, 55);
v->a[2242] = lex_mode_external(217, 48);
v->a[2243] = lex_mode_external(217, 48);
v->a[2244] = lex_mode_external(217, 48);
v->a[2245] = lex_mode_external(217, 48);
v->a[2246] = lex_mode_normal(198);
v->a[2247] = lex_mode_normal(254);
v->a[2240] = lex_mode_normal(196);
v->a[2241] = lex_mode_normal(196);
v->a[2242] = lex_mode_normal(254);
v->a[2243] = lex_mode_external(254, 59);
v->a[2244] = lex_mode_external(241, 45);
v->a[2245] = lex_mode_external(241, 45);
v->a[2246] = lex_mode_normal(196);
v->a[2247] = lex_mode_normal(196);
v->a[2248] = lex_mode_normal(254);
v->a[2249] = lex_mode_normal(254);
v->a[2250] = lex_mode_normal(217);
v->a[2251] = lex_mode_external(254, 58);
v->a[2252] = lex_mode_normal(198);
v->a[2253] = lex_mode_normal(254);
v->a[2254] = lex_mode_normal(198);
v->a[2255] = lex_mode_external(254, 58);
v->a[2250] = lex_mode_normal(198);
v->a[2251] = lex_mode_normal(198);
v->a[2252] = lex_mode_normal(196);
v->a[2253] = lex_mode_normal(196);
v->a[2254] = lex_mode_external(254, 58);
v->a[2255] = lex_mode_external(254, 60);
v->a[2256] = lex_mode_normal(254);
v->a[2257] = lex_mode_normal(198);
v->a[2257] = lex_mode_external(254, 60);
v->a[2258] = lex_mode_external(254, 58);
v->a[2259] = lex_mode_external(254, 58);
lex_modes_113(v);
@ -90,49 +90,49 @@ void lex_modes_112(t_lex_modes_array *v)
void lex_modes_113(t_lex_modes_array *v)
{
v->a[2260] = lex_mode_external(254, 58);
v->a[2261] = lex_mode_external(254, 58);
v->a[2261] = lex_mode_normal(196);
v->a[2262] = lex_mode_normal(254);
v->a[2263] = lex_mode_normal(198);
v->a[2264] = lex_mode_external(254, 58);
v->a[2265] = lex_mode_external(254, 58);
v->a[2266] = lex_mode_normal(217);
v->a[2267] = lex_mode_external(254, 58);
v->a[2268] = lex_mode_external(254, 58);
v->a[2269] = lex_mode_normal(198);
v->a[2270] = lex_mode_external(254, 58);
v->a[2271] = lex_mode_normal(198);
v->a[2272] = lex_mode_external(254, 58);
v->a[2273] = lex_mode_normal(196);
v->a[2274] = lex_mode_normal(196);
v->a[2263] = lex_mode_normal(254);
v->a[2264] = lex_mode_normal(196);
v->a[2265] = lex_mode_normal(196);
v->a[2266] = lex_mode_normal(254);
v->a[2267] = lex_mode_normal(196);
v->a[2268] = lex_mode_normal(254);
v->a[2269] = lex_mode_normal(254);
v->a[2270] = lex_mode_normal(196);
v->a[2271] = lex_mode_normal(254);
v->a[2272] = lex_mode_external(241, 45);
v->a[2273] = lex_mode_external(241, 45);
v->a[2274] = lex_mode_normal(254);
v->a[2275] = lex_mode_normal(254);
v->a[2276] = lex_mode_normal(254);
v->a[2277] = lex_mode_normal(254);
v->a[2278] = lex_mode_normal(198);
v->a[2279] = lex_mode_external(254, 59);
v->a[2277] = lex_mode_normal(196);
v->a[2278] = lex_mode_normal(254);
v->a[2279] = lex_mode_normal(254);
lex_modes_114(v);
}
void lex_modes_114(t_lex_modes_array *v)
{
v->a[2280] = lex_mode_normal(254);
v->a[2281] = lex_mode_external(254, 59);
v->a[2280] = lex_mode_normal(196);
v->a[2281] = lex_mode_external(254, 58);
v->a[2282] = lex_mode_normal(254);
v->a[2283] = lex_mode_normal(198);
v->a[2284] = lex_mode_external(254, 58);
v->a[2285] = lex_mode_normal(196);
v->a[2286] = lex_mode_normal(198);
v->a[2287] = lex_mode_normal(254);
v->a[2288] = lex_mode_normal(198);
v->a[2289] = lex_mode_external(243, 45);
v->a[2290] = lex_mode_external(254, 58);
v->a[2291] = lex_mode_normal(198);
v->a[2292] = lex_mode_external(243, 45);
v->a[2293] = lex_mode_external(254, 58);
v->a[2294] = lex_mode_normal(198);
v->a[2295] = lex_mode_external(243, 45);
v->a[2296] = lex_mode_external(243, 45);
v->a[2283] = lex_mode_normal(196);
v->a[2284] = lex_mode_normal(254);
v->a[2285] = lex_mode_normal(254);
v->a[2286] = lex_mode_normal(254);
v->a[2287] = lex_mode_external(254, 58);
v->a[2288] = lex_mode_normal(254);
v->a[2289] = lex_mode_normal(196);
v->a[2290] = lex_mode_normal(196);
v->a[2291] = lex_mode_normal(254);
v->a[2292] = lex_mode_normal(254);
v->a[2293] = lex_mode_normal(254);
v->a[2294] = lex_mode_normal(254);
v->a[2295] = lex_mode_external(254, 60);
v->a[2296] = lex_mode_normal(254);
v->a[2297] = lex_mode_normal(254);
v->a[2298] = lex_mode_external(254, 58);
v->a[2298] = lex_mode_normal(196);
v->a[2299] = lex_mode_normal(254);
lex_modes_115(v);
}

138
parser/static/lex_modes/lex_modes_23.c
View file

@ -14,127 +14,51 @@
void lex_modes_115(t_lex_modes_array *v)
{
v->a[2300] = lex_mode_external(254, 58);
v->a[2301] = lex_mode_normal(254);
v->a[2302] = lex_mode_normal(254);
v->a[2303] = lex_mode_normal(196);
v->a[2304] = lex_mode_external(243, 45);
v->a[2305] = lex_mode_external(243, 45);
v->a[2306] = lex_mode_normal(254);
v->a[2307] = lex_mode_normal(196);
v->a[2308] = lex_mode_external(243, 45);
v->a[2309] = lex_mode_normal(196);
v->a[2300] = lex_mode_normal(198);
v->a[2301] = lex_mode_normal(198);
v->a[2302] = lex_mode_normal(196);
v->a[2303] = lex_mode_normal(254);
v->a[2304] = lex_mode_normal(254);
v->a[2305] = lex_mode_normal(196);
v->a[2306] = lex_mode_normal(198);
v->a[2307] = lex_mode_normal(254);
v->a[2308] = lex_mode_normal(254);
v->a[2309] = lex_mode_normal(254);
v->a[2310] = lex_mode_normal(254);
v->a[2311] = lex_mode_normal(254);
v->a[2312] = lex_mode_external(254, 58);
v->a[2313] = lex_mode_external(243, 45);
v->a[2314] = lex_mode_external(254, 58);
v->a[2315] = lex_mode_external(254, 58);
v->a[2316] = lex_mode_normal(254);
v->a[2311] = lex_mode_normal(198);
v->a[2312] = lex_mode_external(254, 60);
v->a[2313] = lex_mode_normal(196);
v->a[2314] = lex_mode_normal(196);
v->a[2315] = lex_mode_normal(254);
v->a[2316] = lex_mode_normal(196);
v->a[2317] = lex_mode_normal(254);
v->a[2318] = lex_mode_external(254, 58);
v->a[2318] = lex_mode_normal(196);
v->a[2319] = lex_mode_normal(254);
lex_modes_116(v);
}
void lex_modes_116(t_lex_modes_array *v)
{
v->a[2320] = lex_mode_normal(254);
v->a[2321] = lex_mode_external(243, 45);
v->a[2322] = lex_mode_external(254, 58);
v->a[2323] = lex_mode_external(243, 45);
v->a[2320] = lex_mode_normal(196);
v->a[2321] = lex_mode_normal(254);
v->a[2322] = lex_mode_normal(254);
v->a[2323] = lex_mode_normal(196);
v->a[2324] = lex_mode_normal(196);
v->a[2325] = lex_mode_normal(254);
v->a[2326] = lex_mode_normal(196);
v->a[2327] = lex_mode_external(243, 45);
v->a[2328] = lex_mode_external(243, 45);
v->a[2329] = lex_mode_external(254, 58);
v->a[2325] = lex_mode_normal(196);
v->a[2326] = lex_mode_normal(254);
v->a[2327] = lex_mode_normal(254);
v->a[2328] = lex_mode_normal(196);
v->a[2329] = lex_mode_normal(254);
v->a[2330] = lex_mode_normal(254);
v->a[2331] = lex_mode_external(254, 60);
v->a[2332] = lex_mode_external(243, 45);
v->a[2331] = lex_mode_normal(254);
v->a[2332] = lex_mode_normal(254);
v->a[2333] = lex_mode_normal(254);
v->a[2334] = lex_mode_normal(196);
v->a[2335] = lex_mode_normal(254);
v->a[2336] = lex_mode_normal(254);
v->a[2337] = lex_mode_normal(254);
v->a[2338] = lex_mode_external(243, 45);
v->a[2339] = lex_mode_normal(196);
lex_modes_117(v);
}
void lex_modes_117(t_lex_modes_array *v)
{
v->a[2340] = lex_mode_normal(254);
v->a[2341] = lex_mode_normal(254);
v->a[2342] = lex_mode_external(243, 45);
v->a[2343] = lex_mode_external(243, 45);
v->a[2344] = lex_mode_normal(254);
v->a[2345] = lex_mode_normal(254);
v->a[2346] = lex_mode_normal(254);
v->a[2347] = lex_mode_normal(196);
v->a[2348] = lex_mode_normal(254);
v->a[2349] = lex_mode_normal(254);
v->a[2350] = lex_mode_external(254, 60);
v->a[2351] = lex_mode_normal(254);
v->a[2352] = lex_mode_external(254, 60);
v->a[2353] = lex_mode_normal(198);
v->a[2354] = lex_mode_normal(196);
v->a[2355] = lex_mode_normal(254);
v->a[2356] = lex_mode_normal(196);
v->a[2357] = lex_mode_normal(254);
v->a[2358] = lex_mode_normal(196);
v->a[2359] = lex_mode_normal(254);
lex_modes_118(v);
}
void lex_modes_118(t_lex_modes_array *v)
{
v->a[2360] = lex_mode_normal(254);
v->a[2361] = lex_mode_normal(196);
v->a[2362] = lex_mode_normal(254);
v->a[2363] = lex_mode_normal(254);
v->a[2364] = lex_mode_external(254, 59);
v->a[2365] = lex_mode_normal(196);
v->a[2366] = lex_mode_normal(254);
v->a[2367] = lex_mode_normal(254);
v->a[2368] = lex_mode_normal(254);
v->a[2369] = lex_mode_normal(196);
v->a[2370] = lex_mode_normal(254);
v->a[2371] = lex_mode_normal(254);
v->a[2372] = lex_mode_normal(254);
v->a[2373] = lex_mode_normal(254);
v->a[2374] = lex_mode_normal(254);
v->a[2375] = lex_mode_normal(254);
v->a[2376] = lex_mode_normal(254);
v->a[2377] = lex_mode_normal(196);
v->a[2378] = lex_mode_external(254, 58);
v->a[2379] = lex_mode_external(254, 60);
lex_modes_119(v);
}
void lex_modes_119(t_lex_modes_array *v)
{
v->a[2380] = lex_mode_normal(254);
v->a[2381] = lex_mode_normal(254);
v->a[2382] = lex_mode_normal(254);
v->a[2383] = lex_mode_external(254, 58);
v->a[2384] = lex_mode_normal(254);
v->a[2385] = lex_mode_normal(196);
v->a[2386] = lex_mode_normal(254);
v->a[2387] = lex_mode_normal(196);
v->a[2388] = lex_mode_normal(254);
v->a[2389] = lex_mode_normal(254);
v->a[2390] = lex_mode_external(254, 59);
v->a[2391] = lex_mode_normal(196);
v->a[2392] = lex_mode_normal(254);
v->a[2393] = lex_mode_normal(196);
v->a[2394] = lex_mode_normal(254);
v->a[2395] = lex_mode_normal(198);
v->a[2396] = lex_mode_normal(198);
v->a[2397] = lex_mode_normal(196);
v->a[2398] = lex_mode_normal(254);
v->a[2399] = lex_mode_normal(196);
lex_modes_120(v);
v->a[2337] = lex_mode_normal(196);
v->a[2338] = lex_mode_normal(196);
v->a[2339] = lex_mode_normal(198);
}
/* EOF lex_modes_23.c */

124
parser/static/lex_modes/lex_modes_24.c
View file

@ -1,124 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lex_modes_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_modes.h"
void lex_modes_120(t_lex_modes_array *v)
{
v->a[2400] = lex_mode_external(254, 60);
v->a[2401] = lex_mode_external(254, 58);
v->a[2402] = lex_mode_external(254, 60);
v->a[2403] = lex_mode_normal(254);
v->a[2404] = lex_mode_normal(196);
v->a[2405] = lex_mode_normal(254);
v->a[2406] = lex_mode_normal(196);
v->a[2407] = lex_mode_normal(254);
v->a[2408] = lex_mode_normal(254);
v->a[2409] = lex_mode_normal(254);
v->a[2410] = lex_mode_normal(196);
v->a[2411] = lex_mode_normal(254);
v->a[2412] = lex_mode_external(243, 45);
v->a[2413] = lex_mode_normal(254);
v->a[2414] = lex_mode_normal(196);
v->a[2415] = lex_mode_normal(254);
v->a[2416] = lex_mode_normal(254);
v->a[2417] = lex_mode_normal(254);
v->a[2418] = lex_mode_normal(196);
v->a[2419] = lex_mode_external(243, 45);
lex_modes_121(v);
}
void lex_modes_121(t_lex_modes_array *v)
{
v->a[2420] = lex_mode_normal(196);
v->a[2421] = lex_mode_normal(254);
v->a[2422] = lex_mode_normal(196);
v->a[2423] = lex_mode_normal(254);
v->a[2424] = lex_mode_normal(254);
v->a[2425] = lex_mode_normal(196);
v->a[2426] = lex_mode_normal(254);
v->a[2427] = lex_mode_external(254, 58);
v->a[2428] = lex_mode_normal(254);
v->a[2429] = lex_mode_external(254, 58);
v->a[2430] = lex_mode_external(254, 58);
v->a[2431] = lex_mode_normal(196);
v->a[2432] = lex_mode_normal(254);
v->a[2433] = lex_mode_normal(254);
v->a[2434] = lex_mode_external(254, 58);
v->a[2435] = lex_mode_normal(196);
v->a[2436] = lex_mode_normal(196);
v->a[2437] = lex_mode_normal(254);
v->a[2438] = lex_mode_normal(254);
v->a[2439] = lex_mode_external(254, 59);
lex_modes_122(v);
}
void lex_modes_122(t_lex_modes_array *v)
{
v->a[2440] = lex_mode_external(254, 59);
v->a[2441] = lex_mode_normal(254);
v->a[2442] = lex_mode_normal(196);
v->a[2443] = lex_mode_normal(254);
v->a[2444] = lex_mode_normal(254);
v->a[2445] = lex_mode_normal(198);
v->a[2446] = lex_mode_normal(198);
v->a[2447] = lex_mode_external(254, 58);
v->a[2448] = lex_mode_external(254, 58);
v->a[2449] = lex_mode_external(254, 58);
v->a[2450] = lex_mode_normal(254);
v->a[2451] = lex_mode_normal(198);
v->a[2452] = lex_mode_external(254, 58);
v->a[2453] = lex_mode_normal(254);
v->a[2454] = lex_mode_normal(196);
v->a[2455] = lex_mode_normal(254);
v->a[2456] = lex_mode_normal(198);
v->a[2457] = lex_mode_normal(254);
v->a[2458] = lex_mode_normal(196);
v->a[2459] = lex_mode_normal(196);
lex_modes_123(v);
}
void lex_modes_123(t_lex_modes_array *v)
{
v->a[2460] = lex_mode_normal(254);
v->a[2461] = lex_mode_external(254, 58);
v->a[2462] = lex_mode_normal(254);
v->a[2463] = lex_mode_normal(254);
v->a[2464] = lex_mode_normal(254);
v->a[2465] = lex_mode_normal(254);
v->a[2466] = lex_mode_normal(254);
v->a[2467] = lex_mode_normal(196);
v->a[2468] = lex_mode_normal(254);
v->a[2469] = lex_mode_normal(254);
v->a[2470] = lex_mode_normal(196);
v->a[2471] = lex_mode_normal(254);
v->a[2472] = lex_mode_normal(254);
v->a[2473] = lex_mode_normal(196);
v->a[2474] = lex_mode_normal(254);
v->a[2475] = lex_mode_normal(196);
v->a[2476] = lex_mode_normal(196);
v->a[2477] = lex_mode_normal(198);
v->a[2478] = lex_mode_external(254, 58);
v->a[2479] = lex_mode_normal(254);
lex_modes_124(v);
}
void lex_modes_124(t_lex_modes_array *v)
{
v->a[2480] = lex_mode_normal(196);
v->a[2481] = lex_mode_normal(254);
v->a[2482] = lex_mode_normal(254);
v->a[2483] = lex_mode_normal(254);
v->a[2484] = lex_mode_normal(196);
}
/* EOF lex_modes_24.c */

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