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

Started working on ast

Browse source
This commit is contained in:
Maieul BOYER 2024-06-11 16:08:12 +02:00
parent 9aee1f2272
commit 1d4dc219db
No known key found for this signature in database
1344 changed files with 118659 additions and 107610 deletions
Download patch file Download diff file Expand all files Collapse all files

108
ast/include/ast.h Normal file
View file

@ -0,0 +1,108 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ast.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/06/11 14:23:40 by maiboyer #+# #+# */
/* Updated: 2024/06/11 14:24:38 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef AST_H
#define AST_H
#include "ast/ast_forward_def.h"
#include "me/types.h"
/*
ast_statement:
case_statement
command
compound_statement
for_statement
function_definition
if_statement
list
negated_command
pipeline
redirected_statement
subshell
variable_assignment
variable_assignments
while_statement
ast_statement_not_pipeline == ast_statement-pipeline
ast_statement_not_subshell == ast_statement-subshell
*/
enum e_ast_node_kind
{
AST_EMPTY,
AST_COMMAND,
};
enum e_ast_word_kind
{
AST_WORD_NO_QUOTE,
AST_WORD_SINGLE_STRING,
AST_WORD_DOUBLE_QUOTED,
AST_WORD_BACK_QUOTED,
};
struct s_ast_empty
{
};
struct s_ast_raw_string
{
t_str str;
t_usize len;
};
/// @brief A string that is double quoted
/// @param parts this can be multiple things:
/// - a "raw" string (no processing needed)
/// - a expension (variable, command substitution, artihmetic expansion, etc.)
/// @param parts_len the number of parts in the string
struct s_ast_built_string
{
t_ast_node *parts;
t_usize parts_len;
};
struct s_ast_pipeline
{
t_ast_node *statements;
t_usize statements_len;
};
struct s_ast_word
{
t_ast_word_kind kind;
t_ast_node *inner;
};
struct s_ast_command
{
t_ast_node *prefixes;
t_ast_node *cmd_word;
t_ast_node *suffixes;
t_usize prefixes_len;
t_usize cmd_word_len;
t_usize suffixes_len;
};
union u_ast_node_data {
t_ast_empty empty;
t_ast_command command;
};
struct s_ast_node
{
t_ast_node_kind kind;
t_ast_node_data data;
};
#endif /* AST_H */

30
ast/include/ast/ast_forward_def.h Normal file
View file

@ -0,0 +1,30 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ast_forward_def.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/06/11 14:24:24 by maiboyer #+# #+# */
/* Updated: 2024/06/11 14:24:25 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef AST_FORWARD_DEF_H
#define AST_FORWARD_DEF_H
typedef enum e_ast_node_kind t_ast_node_kind;
typedef enum e_ast_word_kind t_ast_word_kind;
typedef union u_ast_node_data t_ast_node_data;
typedef struct s_ast_node t_ast_node;
typedef struct s_ast_empty t_ast_empty;
typedef struct s_ast_command t_ast_command;
typedef struct s_ast_word t_ast_word;
typedef struct s_ast_pipeline t_ast_pipeline;
typedef struct s_ast_raw_string t_ast_raw_string;
typedef struct s_ast_built_string t_ast_built_string;
#endif /* AST_FORWARD_DEF_H */

78
parser/Filelist.mk
View file

@ -24,6 +24,7 @@ external_scanner_states/external_scanner_states_2 \
external_scanner_symbol_map/external_scanner_symbol_map_0 \ external_scanner_symbol_map/external_scanner_symbol_map_0 \
field_map_entries/field_map_entries_0 \ field_map_entries/field_map_entries_0 \
field_map_entries/field_map_entries_1 \ field_map_entries/field_map_entries_1 \
field_map_entries/field_map_entries_2 \
field_map_slices/field_map_slices_0 \ field_map_slices/field_map_slices_0 \
field_names/field_names_0 \ field_names/field_names_0 \
lex_funcs/lex_keywords/create_table/lex_keywords_array_0 \ lex_funcs/lex_keywords/create_table/lex_keywords_array_0 \
@ -149,8 +150,6 @@ lex_funcs/lex_normal/state_103 \
lex_funcs/lex_normal/state_104 \ lex_funcs/lex_normal/state_104 \
lex_funcs/lex_normal/state_105 \ lex_funcs/lex_normal/state_105 \
lex_funcs/lex_normal/state_106 \ lex_funcs/lex_normal/state_106 \
lex_funcs/lex_normal/state_107 \
lex_funcs/lex_normal/state_additional \
lex_modes/lex_modes_0 \ lex_modes/lex_modes_0 \
lex_modes/lex_modes_1 \ lex_modes/lex_modes_1 \
lex_modes/lex_modes_2 \ lex_modes/lex_modes_2 \
@ -174,6 +173,8 @@ lex_modes/lex_modes_19 \
lex_modes/lex_modes_20 \ lex_modes/lex_modes_20 \
lex_modes/lex_modes_21 \ lex_modes/lex_modes_21 \
lex_modes/lex_modes_22 \ lex_modes/lex_modes_22 \
lex_modes/lex_modes_23 \
lex_modes/lex_modes_24 \
non_terminal_alias_map/non_terminal_alias_map_0 \ non_terminal_alias_map/non_terminal_alias_map_0 \
parse_actions_entries/parse_actions_entries_0 \ parse_actions_entries/parse_actions_entries_0 \
parse_actions_entries/parse_actions_entries_1 \ parse_actions_entries/parse_actions_entries_1 \
@ -225,6 +226,7 @@ parse_actions_entries/parse_actions_entries_46 \
parse_actions_entries/parse_actions_entries_47 \ parse_actions_entries/parse_actions_entries_47 \
parse_actions_entries/parse_actions_entries_48 \ parse_actions_entries/parse_actions_entries_48 \
parse_actions_entries/parse_actions_entries_49 \ parse_actions_entries/parse_actions_entries_49 \
parse_actions_entries/parse_actions_entries_50 \
parse_table/parse_table_0 \ parse_table/parse_table_0 \
parse_table/parse_table_1 \ parse_table/parse_table_1 \
primary_state_ids/primary_state_ids_0 \ primary_state_ids/primary_state_ids_0 \
@ -250,6 +252,8 @@ primary_state_ids/primary_state_ids_19 \
primary_state_ids/primary_state_ids_20 \ primary_state_ids/primary_state_ids_20 \
primary_state_ids/primary_state_ids_21 \ primary_state_ids/primary_state_ids_21 \
primary_state_ids/primary_state_ids_22 \ 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_0 \
small_parse_table/small_parse_table_1 \ small_parse_table/small_parse_table_1 \
small_parse_table/small_parse_table_2 \ small_parse_table/small_parse_table_2 \
@ -1207,6 +1211,74 @@ small_parse_table/small_parse_table_953 \
small_parse_table/small_parse_table_954 \ small_parse_table/small_parse_table_954 \
small_parse_table/small_parse_table_955 \ small_parse_table/small_parse_table_955 \
small_parse_table/small_parse_table_956 \ small_parse_table/small_parse_table_956 \
small_parse_table/small_parse_table_957 \
small_parse_table/small_parse_table_958 \
small_parse_table/small_parse_table_959 \
small_parse_table/small_parse_table_960 \
small_parse_table/small_parse_table_961 \
small_parse_table/small_parse_table_962 \
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_0 \
small_parse_table_map/small_parse_table_map_1 \ small_parse_table_map/small_parse_table_map_1 \
small_parse_table_map/small_parse_table_map_2 \ small_parse_table_map/small_parse_table_map_2 \
@ -1230,6 +1302,8 @@ small_parse_table_map/small_parse_table_map_19 \
small_parse_table_map/small_parse_table_map_20 \ small_parse_table_map/small_parse_table_map_20 \
small_parse_table_map/small_parse_table_map_21 \ 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_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_0 \
symbols_metadata/symbols_metadata_1 \ symbols_metadata/symbols_metadata_1 \
symbols_names/symbols_names_0 \ symbols_names/symbols_names_0 \

4
parser/Parser.mk
View file

@ -6,7 +6,7 @@
# By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ # # By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ #
# +#+#+#+#+#+ +#+ # # +#+#+#+#+#+ +#+ #
# Created: 2023/11/03 13:20:01 by maiboyer #+# #+# # # Created: 2023/11/03 13:20:01 by maiboyer #+# #+# #
# Updated: 2024/05/30 19:41:06 by maiboyer ### ########.fr # # Updated: 2024/06/11 15:46:54 by maiboyer ### ########.fr #
# # # #
# **************************************************************************** # # **************************************************************************** #
@ -21,7 +21,7 @@ NAME = lib$(ANAME).a
LIB_NAME ?= LIB_NAME ?=
TARGET = $(BUILD_DIR)/$(NAME) TARGET = $(BUILD_DIR)/$(NAME)
CC ?= cc CC ?= cc
CFLAGS = -Wall -Wextra -Werror -MMD -I./includes -I../includes -I../output/include CFLAGS = -Wall -Wextra -Werror -MMD -I./includes -I../includes -I../output/include -g3
#CFLAGS += -fsanitize=address -fno-omit-frame-pointer -fsanitize-address-use-after-return=runtime -fno-common -fsanitize-address-use-after-scope #CFLAGS += -fsanitize=address -fno-omit-frame-pointer -fsanitize-address-use-after-return=runtime -fno-common -fsanitize-address-use-after-scope
SRC_FILES = combined scanner funcs create_language SRC_FILES = combined scanner funcs create_language

4
parser/src/scanner.c
View file

@ -5,6 +5,8 @@
#include <string.h> #include <string.h>
#include <wctype.h> #include <wctype.h>
typedef t_lexer_data TSLexer;
enum TokenType enum TokenType
{ {
HEREDOC_START, HEREDOC_START,
@ -59,7 +61,6 @@ enum TokenType
// ESAC, // ESAC,
// ERROR_RECOVERY, // ERROR_RECOVERY,
// }; // };
typedef struct s_lexer_data TSLexer;
typedef Array(char) String; typedef Array(char) String;
@ -727,6 +728,7 @@ static bool scan(Scanner *scanner, TSLexer *lexer, const bool *valid_symbols)
return true; return true;
} }
//regex:
if ((valid_symbols[REGEX]) && !in_error_recovery(valid_symbols)) if ((valid_symbols[REGEX]) && !in_error_recovery(valid_symbols))
{ {
if (valid_symbols[REGEX]) if (valid_symbols[REGEX])

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

@ -21,5 +21,6 @@
# include "../headers/constants.h" # include "../headers/constants.h"
void alias_sequences_0(t_alias_sequences_array *v); void alias_sequences_0(t_alias_sequences_array *v);
void alias_sequences_1(t_alias_sequences_array *v);
#endif // ALIAS_SEQUENCES_H #endif // ALIAS_SEQUENCES_H

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

@ -14,12 +14,44 @@
void alias_sequences_0(t_alias_sequences_array *v) void alias_sequences_0(t_alias_sequences_array *v)
{ {
v->a[6][1] = anon_sym_POUND; v->a[8][1] = anon_sym_POUND;
v->a[7][0] = anon_sym_POUND; v->a[9][0] = anon_sym_POUND;
v->a[16][0] = sym__immediate_double_hash; v->a[10][1] = alias_sym_terminator;
v->a[19][0] = anon_sym_POUND; v->a[12][0] = anon_sym_DOLLAR;
v->a[29][1] = sym__immediate_double_hash; v->a[23][0] = sym__immediate_double_hash;
v->a[30][0] = sym_regex; 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;
v->a[40][3] = sym_word;
v->a[41][0] = sym_regex;
v->a[43][1] = alias_sym_statements;
v->a[44][1] = alias_sym_statements;
v->a[44][3] = alias_sym_statements;
v->a[45][1] = alias_sym_statements;
v->a[46][1] = alias_sym_statements;
v->a[51][1] = alias_sym_statements;
v->a[51][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[62][1] = alias_sym_statements;
v->a[62][3] = alias_sym_statements;
v->a[63][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;
v->a[77][5] = alias_sym_statements;
} }
/* EOF alias_sequences_0.c */ /* EOF alias_sequences_0.c */

2
parser/static/create/create_alias_sequences.c
View file

@ -16,7 +16,7 @@
t_alias_sequences_array *create_alias_sequences(void) t_alias_sequences_array *create_alias_sequences(void)
{ {
static t_alias_sequences_array table = {}; static t_alias_sequences_array table = {};
static bool init = false; static bool init = false;
if (!init) if (!init)
{ {

2
parser/static/create/create_external_scanner_states.c
View file

@ -16,7 +16,7 @@
t_external_scanner_states_array *create_external_scanner_states(void) t_external_scanner_states_array *create_external_scanner_states(void)
{ {
static t_external_scanner_states_array table = {}; static t_external_scanner_states_array table = {};
static bool init = false; static bool init = false;
if (!init) if (!init)
{ {

2
parser/static/create/create_external_scanner_symbol_map.c
View file

@ -16,7 +16,7 @@
t_external_scanner_symbol_map_array *create_external_scanner_symbol_map(void) t_external_scanner_symbol_map_array *create_external_scanner_symbol_map(void)
{ {
static t_external_scanner_symbol_map_array table = {}; static t_external_scanner_symbol_map_array table = {};
static bool init = false; static bool init = false;
if (!init) if (!init)
{ {

2
parser/static/create/create_field_map_entries.c
View file

@ -16,7 +16,7 @@
t_field_map_entries_array *create_field_map_entries(void) t_field_map_entries_array *create_field_map_entries(void)
{ {
static t_field_map_entries_array table = {}; static t_field_map_entries_array table = {};
static bool init = false; static bool init = false;
if (!init) if (!init)
{ {

2
parser/static/create/create_field_map_slices.c
View file

@ -16,7 +16,7 @@
t_field_map_slices_array *create_field_map_slices(void) t_field_map_slices_array *create_field_map_slices(void)
{ {
static t_field_map_slices_array table = {}; static t_field_map_slices_array table = {};
static bool init = false; static bool init = false;
if (!init) if (!init)
{ {

2
parser/static/create/create_field_names.c
View file

@ -16,7 +16,7 @@
t_field_names_array *create_field_names(void) t_field_names_array *create_field_names(void)
{ {
static t_field_names_array table = {}; static t_field_names_array table = {};
static bool init = false; static bool init = false;
if (!init) if (!init)
{ {

2
parser/static/create/create_lex_keywords.c
View file

@ -16,7 +16,7 @@
t_lex_keywords_array *create_lex_keywords(void) t_lex_keywords_array *create_lex_keywords(void)
{ {
static t_lex_keywords_array table = {}; static t_lex_keywords_array table = {};
static bool init = false; static bool init = false;
if (!init) if (!init)
{ {

2
parser/static/create/create_lex_modes.c
View file

@ -16,7 +16,7 @@
t_lex_modes_array *create_lex_modes(void) t_lex_modes_array *create_lex_modes(void)
{ {
static t_lex_modes_array table = {}; static t_lex_modes_array table = {};
static bool init = false; static bool init = false;
if (!init) if (!init)
{ {

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

@ -16,7 +16,7 @@
t_lex_normal_array *create_lex_normal(void) t_lex_normal_array *create_lex_normal(void)
{ {
static t_lex_normal_array table = {}; static t_lex_normal_array table = {};
static bool init = false; static bool init = false;
if (!init) if (!init)
{ {

2
parser/static/create/create_non_terminal_alias_map.c
View file

@ -16,7 +16,7 @@
t_non_terminal_alias_map_array *create_non_terminal_alias_map(void) t_non_terminal_alias_map_array *create_non_terminal_alias_map(void)
{ {
static t_non_terminal_alias_map_array table = {}; static t_non_terminal_alias_map_array table = {};
static bool init = false; static bool init = false;
if (!init) if (!init)
{ {

2
parser/static/create/create_parse_actions_entries.c
View file

@ -17,7 +17,7 @@
t_parse_actions_entries_array *create_parse_actions_entries(void) t_parse_actions_entries_array *create_parse_actions_entries(void)
{ {
static t_parse_actions_entries_array table = {}; static t_parse_actions_entries_array table = {};
static bool init = false; static bool init = false;
if (!init) if (!init)
{ {

2
parser/static/create/create_parse_table.c
View file

@ -16,7 +16,7 @@
t_parse_table_array *create_parse_table(void) t_parse_table_array *create_parse_table(void)
{ {
static t_parse_table_array table = {}; static t_parse_table_array table = {};
static bool init = false; static bool init = false;
if (!init) if (!init)
{ {

2
parser/static/create/create_primary_state_ids.c
View file

@ -16,7 +16,7 @@
t_primary_state_ids_array *create_primary_state_ids(void) t_primary_state_ids_array *create_primary_state_ids(void)
{ {
static t_primary_state_ids_array table = {}; static t_primary_state_ids_array table = {};
static bool init = false; static bool init = false;
if (!init) if (!init)
{ {

2
parser/static/create/create_small_parse_table.c
View file

@ -16,7 +16,7 @@
t_small_parse_table_array *create_small_parse_table(void) t_small_parse_table_array *create_small_parse_table(void)
{ {
static t_small_parse_table_array table = {}; static t_small_parse_table_array table = {};
static bool init = false; static bool init = false;
if (!init) if (!init)
{ {

2
parser/static/create/create_small_parse_table_map.c
View file

@ -16,7 +16,7 @@
t_small_parse_table_map_array *create_small_parse_table_map(void) t_small_parse_table_map_array *create_small_parse_table_map(void)
{ {
static t_small_parse_table_map_array table = {}; static t_small_parse_table_map_array table = {};
static bool init = false; static bool init = false;
if (!init) if (!init)
{ {

2
parser/static/create/create_symbols_metadata.c
View file

@ -16,7 +16,7 @@
t_symbols_metadata_array *create_symbols_metadata(void) t_symbols_metadata_array *create_symbols_metadata(void)
{ {
static t_symbols_metadata_array table = {}; static t_symbols_metadata_array table = {};
static bool init = false; static bool init = false;
if (!init) if (!init)
{ {

2
parser/static/create/create_symbols_names.c
View file

@ -16,7 +16,7 @@
t_symbols_names_array *create_symbols_names(void) t_symbols_names_array *create_symbols_names(void)
{ {
static t_symbols_names_array table = {}; static t_symbols_names_array table = {};
static bool init = false; static bool init = false;
if (!init) if (!init)
{ {

2
parser/static/create/create_unique_symbols_map.c
View file

@ -16,7 +16,7 @@
t_unique_symbols_map_array *create_unique_symbols_map(void) t_unique_symbols_map_array *create_unique_symbols_map(void)
{ {
static t_unique_symbols_map_array table = {}; static t_unique_symbols_map_array table = {};
static bool init = false; static bool init = false;
if (!init) if (!init)
{ {

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

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

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

@ -15,86 +15,88 @@
void external_scanner_states_5(t_external_scanner_states_array *v) void external_scanner_states_5(t_external_scanner_states_array *v)
{ {
v->a[16][ts_external_token_file_descriptor] = true; v->a[16][ts_external_token_file_descriptor] = true;
v->a[16][ts_external_token_heredoc_redirect_token1] = true; v->a[16][ts_external_token_variable_name] = true;
v->a[16][ts_external_token__bare_dollar] = true;
v->a[16][ts_external_token_LT_LT] = true;
v->a[16][ts_external_token_LT_LT_DASH] = true;
v->a[17][ts_external_token_file_descriptor] = true; v->a[17][ts_external_token_file_descriptor] = true;
v->a[17][ts_external_token_variable_name] = true; v->a[17][ts_external_token_variable_name] = true;
v->a[17][ts_external_token__bare_dollar] = true;
v->a[17][ts_external_token_LT_LT] = true; v->a[17][ts_external_token_LT_LT] = true;
v->a[17][ts_external_token_LT_LT_DASH] = true; v->a[17][ts_external_token_LT_LT_DASH] = true;
v->a[18][ts_external_token_file_descriptor] = true; v->a[18][ts_external_token_file_descriptor] = true;
v->a[18][ts_external_token__bare_dollar] = true; v->a[18][ts_external_token_heredoc_redirect_token1] = true;
v->a[18][ts_external_token_LT_LT] = true;
v->a[18][ts_external_token_LT_LT_DASH] = true;
v->a[18][ts_external_token_LPAREN] = true;
v->a[19][ts_external_token_file_descriptor] = true; v->a[19][ts_external_token_file_descriptor] = true;
v->a[19][ts_external_token_variable_name] = true; v->a[19][ts_external_token__concat] = true;
v->a[19][ts_external_token__bare_dollar] = true;
v->a[19][ts_external_token_LT_LT] = true; v->a[19][ts_external_token_LT_LT] = true;
v->a[19][ts_external_token_LT_LT_DASH] = true; v->a[19][ts_external_token_LT_LT_DASH] = true;
v->a[19][ts_external_token_heredoc_redirect_token1] = true;
v->a[19][ts_external_token_LPAREN] = true;
v->a[20][ts_external_token_file_descriptor] = true; v->a[20][ts_external_token_file_descriptor] = true;
v->a[20][ts_external_token__concat] = true; v->a[20][ts_external_token__concat] = true;
v->a[20][ts_external_token__bare_dollar] = true;
v->a[20][ts_external_token_LT_LT] = true;
external_scanner_states_6(v); external_scanner_states_6(v);
} }
void external_scanner_states_6(t_external_scanner_states_array *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_LT_LT_DASH] = true;
v->a[20][ts_external_token_heredoc_redirect_token1] = 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_LPAREN] = true;
v->a[20][ts_external_token_esac] = true; v->a[20][ts_external_token_esac] = true;
v->a[21][ts_external_token_file_descriptor] = 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__bare_dollar] = true;
v->a[21][ts_external_token_LT_LT] = 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_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_LPAREN] = true;
v->a[22][ts_external_token_file_descriptor] = true;
v->a[22][ts_external_token__concat] = true;
v->a[22][ts_external_token_variable_name] = true;
v->a[22][ts_external_token_LT_LT] = true; v->a[22][ts_external_token_LT_LT] = true;
v->a[22][ts_external_token_LT_LT_DASH] = true;
v->a[22][ts_external_token_heredoc_redirect_token1] = true;
v->a[22][ts_external_token_esac] = true;
v->a[23][ts_external_token_file_descriptor] = true; v->a[23][ts_external_token_file_descriptor] = true;
v->a[23][ts_external_token__concat] = true; v->a[23][ts_external_token__concat] = true;
external_scanner_states_7(v);
}
void external_scanner_states_7(t_external_scanner_states_array *v)
{
v->a[23][ts_external_token_variable_name] = 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] = true;
v->a[23][ts_external_token_LT_LT_DASH] = true; v->a[23][ts_external_token_LT_LT_DASH] = true;
v->a[23][ts_external_token_heredoc_redirect_token1] = true; v->a[23][ts_external_token_heredoc_redirect_token1] = true;
v->a[24][ts_external_token_file_descriptor] = true; v->a[24][ts_external_token_file_descriptor] = true;
v->a[24][ts_external_token_variable_name] = true; 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[24][ts_external_token_LT_LT] = true;
v->a[24][ts_external_token_LT_LT_DASH] = true;
v->a[24][ts_external_token_heredoc_redirect_token1] = true; v->a[24][ts_external_token_heredoc_redirect_token1] = true;
v->a[25][ts_external_token_file_descriptor] = true; v->a[25][ts_external_token_file_descriptor] = true;
v->a[25][ts_external_token__concat] = true; v->a[25][ts_external_token_variable_name] = true;
v->a[25][ts_external_token__bare_dollar] = true;
v->a[25][ts_external_token_LT_LT] = true;
v->a[25][ts_external_token_LT_LT_DASH] = true;
v->a[25][ts_external_token_heredoc_redirect_token1] = true; v->a[25][ts_external_token_heredoc_redirect_token1] = true;
v->a[26][ts_external_token_file_descriptor] = true; v->a[26][ts_external_token_file_descriptor] = true;
v->a[26][ts_external_token__concat] = true;
v->a[26][ts_external_token__bare_dollar] = true; v->a[26][ts_external_token__bare_dollar] = true;
v->a[26][ts_external_token_LT_LT] = true; v->a[26][ts_external_token_LT_LT] = true;
v->a[26][ts_external_token_LT_LT_DASH] = true; v->a[26][ts_external_token_LT_LT_DASH] = true;
v->a[26][ts_external_token_heredoc_redirect_token1] = true;
v->a[26][ts_external_token_esac] = true;
v->a[27][ts_external_token_file_descriptor] = true; v->a[27][ts_external_token_file_descriptor] = true;
v->a[27][ts_external_token__concat] = true; v->a[27][ts_external_token__concat] = true;
v->a[27][ts_external_token__bare_dollar] = 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); external_scanner_states_8(v);
} }
void external_scanner_states_8(t_external_scanner_states_array *v) void external_scanner_states_8(t_external_scanner_states_array *v)
{ {
v->a[27][ts_external_token_LT_LT] = true;
v->a[27][ts_external_token_LT_LT_DASH] = true;
v->a[27][ts_external_token_heredoc_redirect_token1] = true;
v->a[27][ts_external_token_esac] = true; v->a[27][ts_external_token_esac] = true;
v->a[28][ts_external_token_file_descriptor] = true;
v->a[28][ts_external_token__concat] = true;
v->a[28][ts_external_token_LT_LT] = true; v->a[28][ts_external_token_LT_LT] = true;
v->a[28][ts_external_token_LT_LT_DASH] = true;
v->a[28][ts_external_token_heredoc_redirect_token1] = true;
v->a[29][ts_external_token_file_descriptor] = true; v->a[29][ts_external_token_file_descriptor] = true;
v->a[29][ts_external_token__bare_dollar] = true;
v->a[29][ts_external_token_LT_LT] = true; v->a[29][ts_external_token_LT_LT] = true;
v->a[29][ts_external_token_LT_LT_DASH] = true; v->a[29][ts_external_token_LT_LT_DASH] = true;
v->a[30][ts_external_token_file_descriptor] = true; v->a[30][ts_external_token_file_descriptor] = true;
@ -104,10 +106,8 @@ void external_scanner_states_8(t_external_scanner_states_array *v)
v->a[30][ts_external_token_heredoc_redirect_token1] = true; v->a[30][ts_external_token_heredoc_redirect_token1] = true;
v->a[30][ts_external_token_esac] = true; v->a[30][ts_external_token_esac] = true;
v->a[31][ts_external_token_file_descriptor] = true; v->a[31][ts_external_token_file_descriptor] = true;
v->a[31][ts_external_token__concat] = true;
v->a[31][ts_external_token_LT_LT] = true; v->a[31][ts_external_token_LT_LT] = true;
v->a[31][ts_external_token_LT_LT_DASH] = true; v->a[31][ts_external_token_LT_LT_DASH] = true;
v->a[31][ts_external_token_heredoc_redirect_token1] = true;
v->a[32][ts_external_token_file_descriptor] = true; v->a[32][ts_external_token_file_descriptor] = true;
external_scanner_states_9(v); external_scanner_states_9(v);
} }

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

@ -15,19 +15,19 @@
void external_scanner_states_10(t_external_scanner_states_array *v) void external_scanner_states_10(t_external_scanner_states_array *v)
{ {
v->a[36][ts_external_token_LT_LT_DASH] = true; v->a[36][ts_external_token_LT_LT_DASH] = true;
v->a[37][ts_external_token_variable_name] = true; v->a[37][ts_external_token_file_descriptor] = true;
v->a[37][ts_external_token_LPAREN] = true; v->a[37][ts_external_token__concat] = true;
v->a[38][ts_external_token_file_descriptor] = true; v->a[37][ts_external_token_LT_LT] = true;
v->a[38][ts_external_token__concat] = true; v->a[37][ts_external_token_LT_LT_DASH] = true;
v->a[38][ts_external_token_LT_LT] = true; v->a[38][ts_external_token_variable_name] = true;
v->a[38][ts_external_token_LT_LT_DASH] = true; v->a[38][ts_external_token_LPAREN] = true;
v->a[39][ts_external_token_extglob_pattern] = true; v->a[39][ts_external_token_file_descriptor] = true;
v->a[39][ts_external_token__concat] = true;
v->a[39][ts_external_token_heredoc_redirect_token1] = true; v->a[39][ts_external_token_heredoc_redirect_token1] = true;
v->a[39][ts_external_token_LPAREN] = true; v->a[40][ts_external_token_extglob_pattern] = 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_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_file_descriptor] = true;
v->a[41][ts_external_token__concat] = true; v->a[41][ts_external_token__concat] = true;
v->a[41][ts_external_token_variable_name] = true; v->a[41][ts_external_token_variable_name] = true;
@ -44,21 +44,21 @@ void external_scanner_states_11(t_external_scanner_states_array *v)
v->a[44][ts_external_token_extglob_pattern] = true; v->a[44][ts_external_token_extglob_pattern] = true;
v->a[44][ts_external_token_LPAREN] = true; v->a[44][ts_external_token_LPAREN] = true;
v->a[45][ts_external_token_heredoc_redirect_token1] = true; v->a[45][ts_external_token_heredoc_redirect_token1] = true;
v->a[46][ts_external_token__empty_value] = true; v->a[46][ts_external_token__bare_dollar] = true;
v->a[47][ts_external_token_extglob_pattern] = true; v->a[47][ts_external_token__empty_value] = true;
v->a[48][ts_external_token__bare_dollar] = true; v->a[48][ts_external_token_extglob_pattern] = true;
v->a[49][ts_external_token__concat] = true; v->a[49][ts_external_token__concat] = true;
v->a[49][ts_external_token_heredoc_redirect_token1] = true; v->a[49][ts_external_token_heredoc_redirect_token1] = true;
v->a[50][ts_external_token__immediate_double_hash] = true; v->a[50][ts_external_token_variable_name] = true;
v->a[51][ts_external_token_variable_name] = true; v->a[50][ts_external_token__expansion_word] = true;
v->a[51][ts_external_token__expansion_word] = true; v->a[51][ts_external_token__immediate_double_hash] = true;
v->a[52][ts_external_token_variable_name] = true; v->a[52][ts_external_token_variable_name] = true;
v->a[53][ts_external_token_LT_LT] = true; v->a[53][ts_external_token_LT_LT] = true;
v->a[53][ts_external_token_LT_LT_DASH] = true; v->a[53][ts_external_token_LT_LT_DASH] = true;
v->a[54][ts_external_token_heredoc_content] = true; v->a[54][ts_external_token_heredoc_content] = true;
v->a[54][ts_external_token_heredoc_end] = true; v->a[54][ts_external_token_heredoc_end] = true;
v->a[55][ts_external_token_regex] = true; v->a[55][ts_external_token__concat] = true;
v->a[56][ts_external_token__concat] = true; v->a[56][ts_external_token_regex] = true;
external_scanner_states_12(v); external_scanner_states_12(v);
} }

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

@ -27,5 +27,9 @@ void field_map_entries_3(t_field_map_entries_array *v);
void field_map_entries_4(t_field_map_entries_array *v); void field_map_entries_4(t_field_map_entries_array *v);
void field_map_entries_5(t_field_map_entries_array *v); void field_map_entries_5(t_field_map_entries_array *v);
void field_map_entries_6(t_field_map_entries_array *v); void field_map_entries_6(t_field_map_entries_array *v);
void field_map_entries_7(t_field_map_entries_array *v);
void field_map_entries_8(t_field_map_entries_array *v);
void field_map_entries_9(t_field_map_entries_array *v);
void field_map_entries_10(t_field_map_entries_array *v);
#endif // FIELD_MAP_ENTRIES_H #endif // FIELD_MAP_ENTRIES_H

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

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

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

@ -14,43 +14,127 @@
void field_map_entries_5(t_field_map_entries_array *v) void field_map_entries_5(t_field_map_entries_array *v)
{ {
v->a[100] = fmap_entry(field_right, 3, true); v->a[100] = fmap_entry(field_stmt, 1, true);
v->a[101] = fmap_entry(field_arg, 3, true); v->a[101] = fmap_entry(field_stmt, 3, true);
v->a[102] = fmap_entry(field_fd, 0, false); v->a[102] = fmap_entry(field_terminator, 1, true);
v->a[103] = fmap_entry(field_op, 1, false); v->a[103] = fmap_entry(field_terminator, 3, true);
v->a[104] = fmap_entry(field_fd, 0, false); v->a[104] = fmap_entry(field_body, 3, false);
v->a[105] = fmap_entry(field_op, 1, false); v->a[105] = fmap_entry(field_condition, 1, false);
v->a[106] = fmap_entry(field_redirect, 3, false); v->a[106] = fmap_entry(field_elif, 4, false);
v->a[107] = fmap_entry(field_op, 0, false); v->a[107] = fmap_entry(field_stmt, 1, true);
v->a[108] = fmap_entry(field_op, 3, true); v->a[108] = fmap_entry(field_stmt, 3, true);
v->a[109] = fmap_entry(field_redirect, 2, false); v->a[109] = fmap_entry(field_terminator, 1, true);
v->a[110] = fmap_entry(field_right, 3, true); v->a[110] = fmap_entry(field_terminator, 3, true);
v->a[111] = fmap_entry(field_cmds, 4, false); v->a[111] = fmap_entry(field_condition, 1, false);
v->a[112] = fmap_entry(field_value, 1, false); v->a[112] = fmap_entry(field_elif, 3, false);
v->a[113] = fmap_entry(field_cmds, 4, false); v->a[113] = fmap_entry(field_else, 4, false);
v->a[114] = fmap_entry(field_value, 1, false); v->a[114] = fmap_entry(field_stmt, 1, true);
v->a[115] = fmap_entry(field_value, 2, true); v->a[115] = fmap_entry(field_terminator, 1, true);
v->a[116] = fmap_entry(field_cmds, 4, false); v->a[116] = fmap_entry(field_body, 4, true);
v->a[117] = fmap_entry(field_value, 0, false); v->a[117] = fmap_entry(field_cases, 4, false);
v->a[118] = fmap_entry(field_value, 1, true); v->a[118] = fmap_entry(field_value, 1, false);
v->a[119] = fmap_entry(field_cases, 5, true); v->a[119] = fmap_entry(field_value, 4, true);
field_map_entries_6(v); field_map_entries_6(v);
} }
void field_map_entries_6(t_field_map_entries_array *v) void field_map_entries_6(t_field_map_entries_array *v)
{ {
v->a[120] = fmap_entry(field_cases, 6, false); v->a[120] = fmap_entry(field_body, 2, false);
v->a[121] = fmap_entry(field_cmds, 6, true); v->a[121] = fmap_entry(field_stmt, 2, true);
v->a[122] = fmap_entry(field_value, 1, false); v->a[122] = fmap_entry(field_terminator, 2, true);
v->a[123] = fmap_entry(field_value, 6, true); v->a[123] = fmap_entry(field_value, 0, false);
v->a[124] = fmap_entry(field_fd, 0, false); v->a[124] = fmap_entry(field_value, 0, true);
v->a[125] = fmap_entry(field_op, 1, false); v->a[125] = fmap_entry(field_value, 1, true);
v->a[126] = fmap_entry(field_op, 4, true); v->a[126] = fmap_entry(field_body, 4, true);
v->a[127] = fmap_entry(field_redirect, 3, false); v->a[127] = fmap_entry(field_cases, 3, true);
v->a[128] = fmap_entry(field_right, 4, true); v->a[128] = fmap_entry(field_cases, 4, false);
v->a[129] = fmap_entry(field_cmds, 5, false); v->a[129] = fmap_entry(field_value, 1, false);
v->a[130] = fmap_entry(field_value, 1, false); v->a[130] = fmap_entry(field_value, 4, true);
v->a[131] = fmap_entry(field_value, 2, true); v->a[131] = fmap_entry(field_alternative, 4, false);
v->a[132] = fmap_entry(field_condition, 0, false);
v->a[133] = fmap_entry(field_consequence, 2, false);
v->a[134] = fmap_entry(field_op, 0, false);
v->a[135] = fmap_entry(field_op, 2, true);
v->a[136] = fmap_entry(field_right, 2, true);
v->a[137] = fmap_entry(field_arg, 2, true);
v->a[138] = fmap_entry(field_op, 0, false);
v->a[139] = fmap_entry(field_op, 0, false);
field_map_entries_7(v);
}
void field_map_entries_7(t_field_map_entries_array *v)
{
v->a[140] = fmap_entry(field_redirect, 2, false);
v->a[141] = fmap_entry(field_body, 3, false);
v->a[142] = fmap_entry(field_condition, 1, false);
v->a[143] = fmap_entry(field_elif, 4, false);
v->a[144] = fmap_entry(field_else, 5, false);
v->a[145] = fmap_entry(field_stmt, 1, true);
v->a[146] = fmap_entry(field_stmt, 3, true);
v->a[147] = fmap_entry(field_terminator, 1, true);
v->a[148] = fmap_entry(field_terminator, 3, true);
v->a[149] = fmap_entry(field_body, 3, false);
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);
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[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);
v->a[170] = fmap_entry(field_value, 5, true);
v->a[171] = fmap_entry(field_fd, 0, false);
v->a[172] = fmap_entry(field_op, 1, false);
v->a[173] = fmap_entry(field_op, 3, true);
v->a[174] = fmap_entry(field_right, 3, true);
v->a[175] = fmap_entry(field_arg, 3, true);
v->a[176] = fmap_entry(field_fd, 0, false);
v->a[177] = fmap_entry(field_op, 1, false);
v->a[178] = fmap_entry(field_fd, 0, false);
v->a[179] = fmap_entry(field_op, 1, false);
field_map_entries_9(v);
}
void field_map_entries_9(t_field_map_entries_array *v)
{
v->a[180] = fmap_entry(field_redirect, 3, false);
v->a[181] = fmap_entry(field_op, 0, false);
v->a[182] = fmap_entry(field_op, 3, true);
v->a[183] = fmap_entry(field_redirect, 2, false);
v->a[184] = fmap_entry(field_right, 3, true);
v->a[185] = fmap_entry(field_body, 4, false);
v->a[186] = fmap_entry(field_stmt, 4, true);
v->a[187] = fmap_entry(field_terminator, 4, true);
v->a[188] = fmap_entry(field_value, 1, false);
v->a[189] = fmap_entry(field_body, 4, false);
v->a[190] = fmap_entry(field_stmt, 4, true);
v->a[191] = fmap_entry(field_terminator, 4, true);
v->a[192] = fmap_entry(field_value, 1, false);
v->a[193] = fmap_entry(field_value, 2, true);
v->a[194] = fmap_entry(field_body, 4, false);
v->a[195] = fmap_entry(field_stmt, 4, true);
v->a[196] = fmap_entry(field_terminator, 4, true);
v->a[197] = fmap_entry(field_value, 0, false);
v->a[198] = fmap_entry(field_value, 1, true);
v->a[199] = fmap_entry(field_body, 6, true);
field_map_entries_10(v);
} }
/* EOF field_map_entries_1.c */ /* EOF field_map_entries_1.c */

33
parser/static/field_map_entries/field_map_entries_2.c Normal file
View file

@ -0,0 +1,33 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* field_map_entries_2.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#include "./field_map_entries.h"
void field_map_entries_10(t_field_map_entries_array *v)
{
v->a[200] = fmap_entry(field_cases, 5, true);
v->a[201] = fmap_entry(field_cases, 6, false);
v->a[202] = fmap_entry(field_value, 1, false);
v->a[203] = fmap_entry(field_value, 6, true);
v->a[204] = fmap_entry(field_fd, 0, false);
v->a[205] = fmap_entry(field_op, 1, false);
v->a[206] = fmap_entry(field_op, 4, true);
v->a[207] = fmap_entry(field_redirect, 3, false);
v->a[208] = fmap_entry(field_right, 4, true);
v->a[209] = fmap_entry(field_body, 5, false);
v->a[210] = fmap_entry(field_stmt, 5, true);
v->a[211] = fmap_entry(field_terminator, 5, true);
v->a[212] = fmap_entry(field_value, 1, false);
v->a[213] = fmap_entry(field_value, 2, true);
}
/* EOF field_map_entries_2.c */

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

@ -23,5 +23,6 @@
void field_map_slices_0(t_field_map_slices_array *v); void field_map_slices_0(t_field_map_slices_array *v);
void field_map_slices_1(t_field_map_slices_array *v); void field_map_slices_1(t_field_map_slices_array *v);
void field_map_slices_2(t_field_map_slices_array *v); void field_map_slices_2(t_field_map_slices_array *v);
void field_map_slices_3(t_field_map_slices_array *v);
#endif // FIELD_MAP_SLICES_H #endif // FIELD_MAP_SLICES_H

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

@ -15,71 +15,92 @@
void field_map_slices_0(t_field_map_slices_array *v) void field_map_slices_0(t_field_map_slices_array *v)
{ {
v->a[1] = fmap_slice(0, 1); v->a[1] = fmap_slice(0, 1);
v->a[2] = fmap_slice(1, 1); v->a[2] = fmap_slice(1, 2);
v->a[3] = fmap_slice(2, 1); v->a[3] = fmap_slice(3, 1);
v->a[4] = fmap_slice(3, 2); v->a[4] = fmap_slice(4, 1);
v->a[5] = fmap_slice(5, 2); v->a[5] = fmap_slice(5, 1);
v->a[7] = fmap_slice(1, 1); v->a[6] = fmap_slice(6, 2);
v->a[8] = fmap_slice(7, 2); v->a[7] = fmap_slice(8, 2);
v->a[9] = fmap_slice(9, 1); v->a[9] = fmap_slice(4, 1);
v->a[10] = fmap_slice(10, 2); v->a[10] = fmap_slice(10, 2);
v->a[11] = fmap_slice(12, 2); v->a[11] = fmap_slice(12, 2);
v->a[12] = fmap_slice(14, 2); v->a[12] = fmap_slice(14, 1);
v->a[13] = fmap_slice(16, 3); v->a[13] = fmap_slice(14, 1);
v->a[14] = fmap_slice(19, 2); v->a[14] = fmap_slice(15, 2);
v->a[15] = fmap_slice(21, 2); v->a[15] = fmap_slice(17, 3);
v->a[16] = fmap_slice(0, 1); v->a[16] = fmap_slice(20, 4);
v->a[17] = fmap_slice(23, 1); v->a[17] = fmap_slice(24, 2);
v->a[18] = fmap_slice(24, 2); v->a[18] = fmap_slice(26, 2);
v->a[19] = fmap_slice(24, 2); v->a[19] = fmap_slice(28, 3);
v->a[20] = fmap_slice(26, 2); v->a[20] = fmap_slice(31, 2);
v->a[21] = fmap_slice(28, 1); v->a[21] = fmap_slice(33, 4);
field_map_slices_1(v); field_map_slices_1(v);
} }
void field_map_slices_1(t_field_map_slices_array *v) void field_map_slices_1(t_field_map_slices_array *v)
{ {
v->a[22] = fmap_slice(29, 3); v->a[22] = fmap_slice(37, 2);
v->a[23] = fmap_slice(32, 2); v->a[23] = fmap_slice(0, 1);
v->a[24] = fmap_slice(34, 3); v->a[24] = fmap_slice(39, 1);
v->a[25] = fmap_slice(37, 2); v->a[26] = fmap_slice(40, 2);
v->a[26] = fmap_slice(39, 1); v->a[27] = fmap_slice(40, 2);
v->a[27] = fmap_slice(40, 1); v->a[28] = fmap_slice(42, 2);
v->a[28] = fmap_slice(41, 1); v->a[29] = fmap_slice(44, 1);
v->a[29] = fmap_slice(42, 3); v->a[30] = fmap_slice(45, 3);
v->a[31] = fmap_slice(45, 2); v->a[31] = fmap_slice(48, 2);
v->a[32] = fmap_slice(47, 4); v->a[32] = fmap_slice(50, 4);
v->a[33] = fmap_slice(51, 2); v->a[33] = fmap_slice(54, 3);
v->a[34] = fmap_slice(53, 2); v->a[34] = fmap_slice(57, 2);
v->a[35] = fmap_slice(55, 3); v->a[35] = fmap_slice(59, 3);
v->a[36] = fmap_slice(58, 4); v->a[36] = fmap_slice(62, 1);
v->a[37] = fmap_slice(62, 2); v->a[37] = fmap_slice(63, 1);
v->a[38] = fmap_slice(64, 2); v->a[38] = fmap_slice(64, 3);
v->a[39] = fmap_slice(66, 5); v->a[42] = fmap_slice(67, 2);
v->a[40] = fmap_slice(71, 3); v->a[43] = fmap_slice(69, 3);
v->a[41] = fmap_slice(74, 3); v->a[44] = fmap_slice(72, 6);
v->a[42] = fmap_slice(77, 2); v->a[45] = fmap_slice(78, 4);
field_map_slices_2(v); field_map_slices_2(v);
} }
void field_map_slices_2(t_field_map_slices_array *v) void field_map_slices_2(t_field_map_slices_array *v)
{ {
v->a[43] = fmap_slice(79, 2); v->a[46] = fmap_slice(82, 4);
v->a[44] = fmap_slice(81, 2); v->a[47] = fmap_slice(86, 4);
v->a[45] = fmap_slice(83, 5); v->a[48] = fmap_slice(90, 2);
v->a[46] = fmap_slice(88, 2); v->a[49] = fmap_slice(92, 2);
v->a[47] = fmap_slice(90, 3); v->a[50] = fmap_slice(94, 3);
v->a[48] = fmap_slice(93, 4); v->a[51] = fmap_slice(97, 7);
v->a[49] = fmap_slice(97, 4); v->a[52] = fmap_slice(104, 7);
v->a[50] = fmap_slice(101, 3); v->a[53] = fmap_slice(111, 5);
v->a[51] = fmap_slice(104, 3); v->a[54] = fmap_slice(116, 4);
v->a[52] = fmap_slice(107, 4); v->a[55] = fmap_slice(120, 4);
v->a[53] = fmap_slice(111, 2); v->a[56] = fmap_slice(124, 2);
v->a[54] = fmap_slice(113, 3); v->a[57] = fmap_slice(126, 5);
v->a[55] = fmap_slice(116, 3); v->a[58] = fmap_slice(131, 3);
v->a[56] = fmap_slice(119, 5); v->a[59] = fmap_slice(134, 3);
v->a[57] = fmap_slice(124, 5); v->a[60] = fmap_slice(137, 2);
v->a[58] = fmap_slice(129, 3); 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);
field_map_slices_3(v);
}
void field_map_slices_3(t_field_map_slices_array *v)
{
v->a[66] = fmap_slice(162, 5);
v->a[67] = fmap_slice(167, 4);
v->a[68] = fmap_slice(171, 4);
v->a[69] = fmap_slice(175, 3);
v->a[70] = fmap_slice(178, 3);
v->a[71] = fmap_slice(181, 4);
v->a[72] = fmap_slice(185, 4);
v->a[73] = fmap_slice(189, 5);
v->a[74] = fmap_slice(194, 5);
v->a[75] = fmap_slice(199, 5);
v->a[76] = fmap_slice(204, 5);
v->a[77] = fmap_slice(209, 5);
} }
/* EOF field_map_slices_0.c */ /* EOF field_map_slices_0.c */

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

@ -19,16 +19,19 @@ void field_names_0(t_field_names_array *v)
v->a[field_body] = "body"; v->a[field_body] = "body";
v->a[field_cases] = "cases"; v->a[field_cases] = "cases";
v->a[field_cmd] = "cmd"; v->a[field_cmd] = "cmd";
v->a[field_cmds] = "cmds";
v->a[field_condition] = "condition"; v->a[field_condition] = "condition";
v->a[field_consequence] = "consequence"; v->a[field_consequence] = "consequence";
v->a[field_dest] = "dest"; v->a[field_dest] = "dest";
v->a[field_elif] = "elif";
v->a[field_else] = "else";
v->a[field_fd] = "fd"; v->a[field_fd] = "fd";
v->a[field_left] = "left"; v->a[field_left] = "left";
v->a[field_name] = "name"; v->a[field_name] = "name";
v->a[field_op] = "op"; v->a[field_op] = "op";
v->a[field_redirect] = "redirect"; v->a[field_redirect] = "redirect";
v->a[field_right] = "right"; v->a[field_right] = "right";
v->a[field_stmt] = "stmt";
v->a[field_terminator] = "terminator";
v->a[field_value] = "value"; v->a[field_value] = "value";
v->a[field_variable] = "variable"; v->a[field_variable] = "variable";
} }

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

@ -14,14 +14,14 @@
# define CONSTANTS_H # define CONSTANTS_H
# define LANGUAGE_VERSION 14 # define LANGUAGE_VERSION 14
# define STATE_COUNT 2263 # define STATE_COUNT 2485
# define LARGE_STATE_COUNT 2 # define LARGE_STATE_COUNT 2
# define SYMBOL_COUNT 184 # define SYMBOL_COUNT 182
# define ALIAS_COUNT 0 # define ALIAS_COUNT 2
# define TOKEN_COUNT 116 # define TOKEN_COUNT 115
# define EXTERNAL_TOKEN_COUNT 20 # define EXTERNAL_TOKEN_COUNT 20
# define FIELD_COUNT 17 # define FIELD_COUNT 20
# define MAX_ALIAS_SEQUENCE_LENGTH 8 # define MAX_ALIAS_SEQUENCE_LENGTH 8
# define PRODUCTION_ID_COUNT 59 # define PRODUCTION_ID_COUNT 78
#endif // CONSTANTS_H #endif // CONSTANTS_H

3
parser/static/headers/external_scanner_symbol_identifiers.h
View file

@ -13,8 +13,7 @@
#ifndef EXTERNAL_SCANNER_SYMBOL_IDENTIFIERS_H #ifndef EXTERNAL_SCANNER_SYMBOL_IDENTIFIERS_H
# define EXTERNAL_SCANNER_SYMBOL_IDENTIFIERS_H # define EXTERNAL_SCANNER_SYMBOL_IDENTIFIERS_H
enum e_external_scanner_symbol_identifiers enum e_external_scanner_symbol_identifiers {
{
ts_external_token_heredoc_start = 0, ts_external_token_heredoc_start = 0,
ts_external_token_simple_heredoc_body = 1, ts_external_token_simple_heredoc_body = 1,
ts_external_token__heredoc_body_beginning = 2, ts_external_token__heredoc_body_beginning = 2,

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

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

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

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

5
parser/static/lex_funcs/lex_normal/create_table/lex_normal_array_5.c
View file

@ -55,10 +55,5 @@ void lex_normal_array_26(t_lex_normal_array *v)
v->a[528] = lex_normal_s528; v->a[528] = lex_normal_s528;
v->a[529] = lex_normal_s529; v->a[529] = lex_normal_s529;
v->a[530] = lex_normal_s530; v->a[530] = lex_normal_s530;
v->a[531] = lex_normal_s531;
v->a[532] = lex_normal_s532;
v->a[533] = lex_normal_s533;
v->a[534] = lex_normal_s534;
v->a[535] = lex_normal_s535;
} }
/* EOF lex_normal_array_5.c */ /* EOF lex_normal_array_5.c */

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

@ -38,6 +38,5 @@
# include "./inline/inline_impl17.h" # include "./inline/inline_impl17.h"
# include "./inline/inline_impl18.h" # include "./inline/inline_impl18.h"
# include "./inline/inline_impl19.h" # include "./inline/inline_impl19.h"
# include "./inline/inline_impl20.h"
#endif // INLINE_H #endif // INLINE_H

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

@ -22,13 +22,13 @@
static inline bool lex_normal_map0(t_lexer *lexer, \ static inline bool lex_normal_map0(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'!', 282, '"', 391, '#', 412, \ static uint32_t map[] = {'!', 286, '"', 395, '#', 410, \
'$', 389, '%', 370, '&', 354, '\'', 215, '(', 267, ')', \ '$', 393, '%', 374, '&', 358, '\'', 219, '(', 271, ')', \
273, '*', 365, '+', 382, '-', 380, '/', 368, '0', 478, \ 277, '*', 369, '+', 386, '-', 384, '/', 372, '0', 473, \
':', 376, ';', 535, '<', 287, '=', 420, '>', 290, '?', \ ':', 380, ';', 530, '<', 291, '=', 418, '>', 294, '?', \
424, '@', 476, '\\', 128, '^', 350, '_', 480, '`', 433, \ 422, '@', 472, '\\', 129, '^', 354, '_', 476, '`', 431, \
'd', 530, 'e', 527, 'f', 525, 'i', 529, '{', 276, '|', \ 'd', 526, 'e', 523, 'f', 521, 'i', 525, '{', 280, '|', \
269, '}', 278, '~', 384}; 273, '}', 282, '~', 388};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
@ -37,10 +37,9 @@ static inline bool lex_normal_map0(t_lexer *lexer, \
static inline bool lex_normal_map5(t_lexer *lexer, \ static inline bool lex_normal_map5(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 274, '!', 282, '"', 391, \ static uint32_t map[] = {'\n', 278, '!', 286, '"', 395, \
'#', 437, '$', 389, '&', 221, '\'', 215, '(', 267, '-', \ '#', 435, '$', 393, '&', 225, '\'', 219, '(', 271, '<', \
520, '0', 403, '<', 286, '>', 291, '\\', 136, '`', 432, \ 290, '>', 295, '\\', 137, '`', 430, '{', 280};
'{', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
@ -49,11 +48,11 @@ static inline bool lex_normal_map5(t_lexer *lexer, \
static inline bool lex_normal_map10(t_lexer *lexer, \ static inline bool lex_normal_map10(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 306, '!', 282, '"', 391, \ static uint32_t map[] = {'\n', 310, '!', 286, '"', 395, \
'#', 412, '$', 389, '&', 355, '\'', 215, '(', 267, '*', \ '#', 410, '$', 393, '&', 359, '\'', 219, '(', 271, '*', \
367, '-', 363, '0', 477, ';', 535, '<', 288, '>', 291, \ 371, '-', 367, '0', 474, ';', 530, '<', 292, '>', 295, \
'?', 374, '@', 476, '\\', 13, '_', 481, '`', 432, 'e', \ '?', 378, '@', 472, '\\', 13, '_', 477, '`', 430, '|', \
441, '|', 272}; 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
@ -62,10 +61,10 @@ static inline bool lex_normal_map10(t_lexer *lexer, \
static inline bool lex_normal_map49(t_lexer *lexer, \ static inline bool lex_normal_map49(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 307, '!', 281, '#', 412, \ static uint32_t map[] = {'\n', 311, '!', 285, '#', 410, \
'$', 388, '&', 355, '*', 364, '-', 361, '0', 479, ';', \ '$', 392, '&', 359, '*', 368, '-', 365, '0', 475, ';', \
535, '<', 288, '>', 291, '?', 373, '@', 475, '\\', 51, \ 530, '<', 292, '>', 295, '?', 377, '@', 471, '\\', 51, \
'_', 482, 'e', 447, '|', 272}; '_', 478, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
@ -74,11 +73,11 @@ static inline bool lex_normal_map49(t_lexer *lexer, \
static inline bool lex_normal_map94(t_lexer *lexer, \ static inline bool lex_normal_map94(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 309, '!', 282, '"', 391, \ static uint32_t map[] = {'\n', 313, '!', 286, '"', 395, \
'#', 412, '$', 389, '&', 355, '\'', 215, '(', 267, ')', \ '#', 410, '$', 393, '&', 359, '\'', 219, '(', 271, '*', \
273, '*', 367, '-', 363, '0', 477, ';', 535, '<', 288, \ 371, '-', 367, '0', 474, ';', 530, '<', 292, '>', 295, \
'>', 291, '?', 374, '@', 476, '\\', 19, '_', 481, '`', \ '?', 378, '@', 472, '\\', 22, '_', 477, '`', 430, 'e', \
432, '|', 272}; 439, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));

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

@ -19,25 +19,12 @@
# include "../../../headers/constants.h" # include "../../../headers/constants.h"
# include "../../../../parse_types.h" # include "../../../../parse_types.h"
static inline bool lex_normal_map104(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 310, '"', 391, '#', 437, \
'$', 389, '&', 355, '\'', 215, '(', 267, '-', 520, '0', \
403, ';', 535, '<', 288, '>', 291, '\\', 146, '`', 432, \
'e', 531, '|', 272};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map105(t_lexer *lexer, \ static inline bool lex_normal_map105(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 311, '"', 391, '#', 437, \ static uint32_t map[] = {'\n', 314, '"', 395, '#', 435, \
'$', 389, '&', 355, '\'', 215, '(', 267, ')', 273, '-', \ '$', 393, '&', 359, '\'', 219, '(', 271, ';', 530, '<', \
520, '0', 403, ';', 535, '<', 288, '>', 291, '\\', 148, \ 292, '>', 295, '\\', 147, '`', 430, 'e', 527, '|', 276};
'`', 432, '|', 272};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
@ -46,11 +33,9 @@ static inline bool lex_normal_map105(t_lexer *lexer, \
static inline bool lex_normal_map106(t_lexer *lexer, \ static inline bool lex_normal_map106(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 312, '!', 282, '"', 391, \ static uint32_t map[] = {'\n', 315, '"', 395, '#', 435, \
'#', 412, '$', 389, '&', 355, '\'', 215, '*', 367, '-', \ '$', 393, '&', 359, '\'', 219, '(', 271, ')', 277, ';', \
363, '0', 477, ';', 535, '<', 288, '>', 291, '?', 374, \ 530, '<', 292, '>', 295, '\\', 149, '`', 430, '|', 276};
'@', 476, '\\', 31, '_', 481, '`', 432, 'e', 441, '|', \
272};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
@ -59,10 +44,11 @@ static inline bool lex_normal_map106(t_lexer *lexer, \
static inline bool lex_normal_map107(t_lexer *lexer, \ static inline bool lex_normal_map107(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 313, '!', 281, '#', 412, \ static uint32_t map[] = {'\n', 316, '!', 286, '"', 395, \
'$', 388, '&', 355, '*', 364, '-', 361, '0', 479, ';', \ '#', 410, '$', 393, '&', 359, '\'', 219, '(', 271, ')', \
535, '<', 288, '>', 291, '?', 373, '@', 475, '\\', 53, \ 277, '*', 371, '-', 367, '0', 474, ';', 530, '<', 292, \
'_', 482, '`', 432, '|', 272}; '>', 295, '?', 378, '@', 472, '\\', 19, '_', 477, '`', \
430, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
@ -71,11 +57,23 @@ static inline bool lex_normal_map107(t_lexer *lexer, \
static inline bool lex_normal_map108(t_lexer *lexer, \ static inline bool lex_normal_map108(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 314, '!', 282, '"', 391, \ static uint32_t map[] = {'\n', 317, '!', 285, '#', 410, \
'#', 412, '$', 389, '&', 355, '\'', 215, '(', 267, '*', \ '$', 392, '&', 359, '*', 368, '-', 365, '0', 475, ';', \
367, '-', 363, '0', 477, ';', 535, '<', 288, '>', 291, \ 530, '<', 292, '>', 295, '?', 377, '@', 471, '\\', 53, \
'?', 374, '@', 476, '\\', 22, '_', 481, '`', 432, '|', \ '_', 478, 'e', 444, '|', 276};
272};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map109(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 318, '!', 286, '"', 395, \
'#', 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), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));

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

@ -19,23 +19,14 @@
# include "../../../headers/constants.h" # include "../../../headers/constants.h"
# include "../../../../parse_types.h" # include "../../../../parse_types.h"
static inline bool lex_normal_map209(t_lexer *lexer, \ static inline bool lex_normal_map239(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'"', 391, '#', 438, '$', 389, \ static uint32_t map[] = {'\n', 310, '!', 286, '"', 395, \
'\'', 215, '-', 520, '0', 403, '\\', 171, '`', 432}; '#', 410, '$', 393, '&', 359, '\'', 219, '(', 271, '*', \
371, '-', 367, '0', 474, ';', 530, '<', 292, '>', 295, \
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ '?', 378, '@', 472, '\\', 13, '_', 477, '`', 430, '|', \
lexer, s)); 276};
}
static inline bool lex_normal_map240(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 311, '"', 391, '#', 437, \
'$', 389, '&', 355, '\'', 215, '(', 267, ')', 273, '-', \
520, '0', 403, ';', 535, '<', 288, '>', 291, '\\', 148, \
'`', 432, '|', 272};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
@ -44,35 +35,44 @@ static inline bool lex_normal_map240(t_lexer *lexer, \
static inline bool lex_normal_map241(t_lexer *lexer, \ static inline bool lex_normal_map241(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 314, '!', 282, '"', 391, \ static uint32_t map[] = {'\n', 311, '!', 285, '#', 410, \
'#', 412, '$', 389, '&', 355, '\'', 215, '(', 267, '*', \ '$', 392, '&', 359, '*', 368, '-', 365, '0', 475, ';', \
367, '-', 363, '0', 477, ';', 535, '<', 288, '>', 291, \ 530, '<', 292, '>', 295, '?', 377, '@', 471, '\\', 51, \
'?', 374, '@', 476, '\\', 22, '_', 481, '`', 432, '|', \ '_', 478, '|', 276};
272};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
} }
static inline bool lex_normal_map242(t_lexer *lexer, \ static inline bool lex_normal_map246(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 320, '"', 391, '#', 437, \ static uint32_t map[] = {'\n', 315, '"', 395, '#', 435, \
'$', 389, '&', 355, '\'', 215, '(', 267, ')', 273, '-', \ '$', 393, '&', 359, '\'', 219, '(', 271, ')', 277, ';', \
520, '0', 403, ';', 535, '<', 288, '>', 291, '\\', 156, \ 530, '<', 292, '>', 295, '\\', 149, '`', 430, '|', 276};
'`', 433, '|', 272};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
} }
static inline bool lex_normal_map243(t_lexer *lexer, \ static inline bool lex_normal_map247(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 321, '!', 281, '#', 412, \ static uint32_t map[] = {'\n', 324, '"', 395, '#', 435, \
'$', 388, '&', 355, '*', 364, '-', 361, '0', 479, ';', \ '$', 393, '&', 359, '\'', 219, '(', 271, ')', 277, ';', \
535, '<', 288, '>', 291, '?', 373, '@', 475, '\\', 57, \ 530, '<', 292, '>', 295, '\\', 153, '`', 431, '|', 276};
'_', 482, '|', 272};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map248(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};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));

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

@ -19,63 +19,61 @@
# include "../../../headers/constants.h" # include "../../../headers/constants.h"
# include "../../../../parse_types.h" # include "../../../../parse_types.h"
static inline bool lex_normal_map244(t_lexer *lexer, \ static inline bool lex_normal_map252(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 322, '!', 282, '"', 391, \ static uint32_t map[] = {'!', 286, '"', 395, '#', 410, \
'#', 412, '$', 389, '&', 355, '\'', 215, '*', 367, '-', \ '$', 393, '%', 374, '&', 358, '\'', 219, '(', 271, ')', \
363, '0', 477, ';', 535, '<', 288, '>', 291, '?', 374, \ 277, '*', 369, '+', 386, '-', 384, '/', 372, '0', 473, \
'@', 476, '\\', 28, '_', 481, '`', 432, '|', 272}; ':', 381, ';', 530, '<', 291, '=', 289, '>', 294, '?', \
378, '@', 472, '\\', 129, '^', 354, '_', 476, '`', 431, \
'd', 526, 'e', 523, 'f', 521, 'i', 525, '{', 280, '|', \
273, '}', 282, '~', 388};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
} }
static inline bool lex_normal_map248(t_lexer *lexer, \ static inline bool lex_normal_map253(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'!', 282, '"', 391, '#', 412, \ static uint32_t map[] = {'!', 286, '"', 395, '#', 435, \
'$', 389, '%', 370, '&', 354, '\'', 215, '(', 267, ')', \ '$', 393, '&', 225, '\'', 219, '(', 271, ')', 277, ';', \
273, '*', 365, '+', 382, '-', 380, '/', 368, '0', 478, \ 223, '<', 290, '>', 295, '\\', 132, '`', 430, '{', 280};
':', 377, ';', 535, '<', 287, '=', 285, '>', 290, '?', \
374, '@', 476, '\\', 128, '^', 350, '_', 480, '`', 433, \
'd', 530, 'e', 527, 'f', 525, 'i', 529, '{', 276, '|', \
269, '}', 278, '~', 384};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
} }
static inline bool lex_normal_map249(t_lexer *lexer, \ static inline bool lex_normal_map254(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'!', 282, '"', 391, '#', 437, \ static uint32_t map[] = {'!', 224, '#', 435, '$', 394, \
'$', 389, '&', 221, '\'', 215, '(', 267, ')', 273, '-', \ '%', 376, '&', 357, ')', 221, '*', 370, '+', 364, '-', \
520, '0', 403, ';', 219, '<', 286, '>', 291, '\\', 131, \ 366, '/', 373, ':', 379, ';', 223, '<', 293, '=', 288, \
'`', 432, '{', 276}; '>', 296, '?', 377};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
} }
static inline bool lex_normal_map250(t_lexer *lexer, \ static inline bool lex_normal_map400(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'!', 220, '#', 437, '$', 390, \ static uint32_t map[] = {'!', 285, '"', 395, '#', 410, \
'%', 372, '&', 353, ')', 217, '*', 366, '+', 360, '-', \ '$', 392, '*', 368, '-', 365, '0', 475, '?', 377, '@', \
362, '/', 369, ':', 375, ';', 219, '<', 289, '=', 284, \ 471, '\\', 83, '_', 478};
'>', 292, '?', 373};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
} }
static inline bool lex_normal_map396(t_lexer *lexer, \ static inline bool lex_normal_map401(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'!', 281, '"', 391, '#', 412, \ static uint32_t map[] = {'!', 285, '#', 410, '$', 392, \
'$', 388, '*', 364, '-', 361, '0', 479, '?', 373, '@', \ '*', 368, '-', 365, '0', 475, '?', 377, '@', 471, '\\', \
475, '\\', 83, '_', 482}; 88, '_', 478};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));

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

@ -19,12 +19,52 @@
# include "../../../headers/constants.h" # include "../../../headers/constants.h"
# include "../../../../parse_types.h" # include "../../../../parse_types.h"
static inline bool lex_normal_map397(t_lexer *lexer, \ static inline bool lex_normal_map446(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'!', 281, '#', 412, '$', 388, \ static uint32_t map[] = {'\n', 310, '!', 286, '"', 395, \
'*', 364, '-', 361, '0', 479, '?', 373, '@', 475, '\\', \ '#', 410, '$', 393, '&', 359, '\'', 219, '(', 271, '*', \
88, '_', 482}; 371, '-', 367, '0', 474, ';', 530, '<', 292, '>', 295, \
'?', 378, '@', 472, '\\', 13, '_', 477, '`', 430, '|', \
276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
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};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map448(t_lexer *lexer, \
t_lexer_state *s)
{
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};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map449(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 316, '!', 286, '"', 395, \
'#', 410, '$', 393, '&', 359, '\'', 219, '(', 271, ')', \
277, '*', 371, '-', 367, '0', 474, ';', 530, '<', 292, \
'>', 295, '?', 378, '@', 472, '\\', 19, '_', 477, '`', \
430, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
@ -33,49 +73,10 @@ static inline bool lex_normal_map397(t_lexer *lexer, \
static inline bool lex_normal_map450(t_lexer *lexer, \ static inline bool lex_normal_map450(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 306, '!', 282, '"', 391, \ static uint32_t map[] = {'\n', 317, '!', 285, '#', 410, \
'#', 412, '$', 389, '&', 355, '\'', 215, '(', 267, '*', \ '$', 392, '&', 359, '*', 368, '-', 365, '0', 475, ';', \
367, '-', 363, '0', 477, ';', 535, '<', 288, '>', 291, \ 530, '<', 292, '>', 295, '?', 377, '@', 471, '\\', 53, \
'?', 374, '@', 476, '\\', 13, '_', 481, '`', 432, 'e', \ '_', 478, 'e', 444, '|', 276};
441, '|', 272};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map451(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 307, '!', 281, '#', 412, \
'$', 388, '&', 355, '*', 364, '-', 361, '0', 479, ';', \
535, '<', 288, '>', 291, '?', 373, '@', 475, '\\', 51, \
'_', 482, 'e', 447, '|', 272};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map452(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 309, '!', 282, '"', 391, \
'#', 412, '$', 389, '&', 355, '\'', 215, '(', 267, ')', \
273, '*', 367, '-', 363, '0', 477, ';', 535, '<', 288, \
'>', 291, '?', 374, '@', 476, '\\', 19, '_', 481, '`', \
432, '|', 272};
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', 312, '!', 282, '"', 391, \
'#', 412, '$', 389, '&', 355, '\'', 215, '*', 367, '-', \
363, '0', 477, ';', 535, '<', 288, '>', 291, '?', 374, \
'@', 476, '\\', 31, '_', 481, '`', 432, 'e', 441, '|', \
272};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));

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

@ -19,13 +19,51 @@
# include "../../../headers/constants.h" # include "../../../headers/constants.h"
# include "../../../../parse_types.h" # include "../../../../parse_types.h"
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};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map452(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 321, '!', 286, '"', 395, \
'#', 410, '$', 393, '&', 359, '\'', 219, ')', 277, '*', \
371, '-', 367, '0', 474, ';', 530, '<', 292, '>', 295, \
'?', 378, '@', 472, '\\', 28, '_', 477, '`', 430, '|', \
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, '!', 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, \ static inline bool lex_normal_map454(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 313, '!', 281, '#', 412, \ static uint32_t map[] = {'\n', 325, '!', 286, '"', 395, \
'$', 388, '&', 355, '*', 364, '-', 361, '0', 479, ';', \ '#', 410, '$', 393, '&', 359, '\'', 219, '*', 371, '-', \
535, '<', 288, '>', 291, '?', 373, '@', 475, '\\', 53, \ 367, '0', 474, ';', 530, '<', 292, '>', 295, '?', 378, \
'_', 482, '`', 432, '|', 272}; '@', 472, '\\', 31, '_', 477, '`', 430, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
@ -34,48 +72,10 @@ static inline bool lex_normal_map454(t_lexer *lexer, \
static inline bool lex_normal_map455(t_lexer *lexer, \ static inline bool lex_normal_map455(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 314, '!', 282, '"', 391, \ static uint32_t map[] = {'\n', 326, '!', 285, '#', 410, \
'#', 412, '$', 389, '&', 355, '\'', 215, '(', 267, '*', \ '$', 392, '&', 359, ')', 277, '*', 368, '-', 365, '0', \
367, '-', 363, '0', 477, ';', 535, '<', 288, '>', 291, \ 475, ';', 530, '<', 292, '>', 295, '?', 377, '@', 471, \
'?', 374, '@', 476, '\\', 22, '_', 481, '`', 432, '|', \ '\\', 57, '_', 478, '|', 276};
272};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map456(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 317, '!', 281, '#', 412, \
'$', 388, '&', 355, ')', 273, '*', 364, '-', 361, '0', \
479, ';', 535, '<', 288, '>', 291, '?', 373, '@', 475, \
'\\', 55, '_', 482, '|', 272};
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', 318, '!', 282, '"', 391, \
'#', 412, '$', 389, '&', 355, '\'', 215, ')', 273, '*', \
367, '-', 363, '0', 477, ';', 535, '<', 288, '>', 291, \
'?', 374, '@', 476, '\\', 25, '_', 481, '`', 432, '|', \
272};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map458(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 321, '!', 281, '#', 412, \
'$', 388, '&', 355, '*', 364, '-', 361, '0', 479, ';', \
535, '<', 288, '>', 291, '?', 373, '@', 475, '\\', 57, \
'_', 482, '|', 272};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));

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

@ -19,13 +19,49 @@
# include "../../../headers/constants.h" # include "../../../headers/constants.h"
# include "../../../../parse_types.h" # include "../../../../parse_types.h"
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, \
'$', 392, '&', 218, '*', 368, '-', 365, '0', 475, '<', \
292, '>', 295, '?', 377, '@', 471, '\\', 63, '_', 478, \
'|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map458(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 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_map459(t_lexer *lexer, \ static inline bool lex_normal_map459(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 322, '!', 282, '"', 391, \ static uint32_t map[] = {'\n', 332, '!', 285, '#', 410, \
'#', 412, '$', 389, '&', 355, '\'', 215, '*', 367, '-', \ '$', 392, '&', 218, '*', 368, '-', 365, '0', 475, '<', \
363, '0', 477, ';', 535, '<', 288, '>', 291, '?', 374, \ 290, '>', 295, '?', 377, '@', 471, '\\', 102, '_', 478, \
'@', 476, '\\', 28, '_', 481, '`', 432, '|', 272}; '|', 237};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
@ -34,46 +70,10 @@ static inline bool lex_normal_map459(t_lexer *lexer, \
static inline bool lex_normal_map460(t_lexer *lexer, \ static inline bool lex_normal_map460(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 324, '!', 281, '#', 412, \ static uint32_t map[] = {'\n', 333, '!', 286, '"', 395, \
'$', 388, '&', 214, '*', 364, '-', 361, '0', 479, '<', \ '#', 410, '$', 393, '&', 218, '\'', 219, '*', 371, '-', \
288, '>', 291, '?', 373, '@', 475, '\\', 64, '_', 482, \ 367, '0', 474, '<', 290, '>', 295, '?', 378, '@', 472, \
'|', 272}; '\\', 99, '_', 477, '`', 430, '|', 237};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map461(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 325, '!', 282, '"', 391, \
'#', 412, '$', 389, '&', 214, '\'', 215, '(', 267, '*', \
367, '-', 363, '0', 477, '<', 288, '>', 291, '?', 374, \
'@', 476, '\\', 36, '_', 481, '`', 432, '|', 272};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map462(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 327, '!', 281, '#', 412, \
'$', 388, '&', 214, '*', 364, '-', 361, '0', 479, '<', \
286, '>', 291, '?', 373, '@', 475, '\\', 102, '_', 482, \
'|', 233};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map463(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 328, '!', 282, '"', 391, \
'#', 412, '$', 389, '&', 214, '\'', 215, '*', 367, '-', \
363, '0', 477, '<', 288, '>', 291, '?', 374, '@', 476, \
'\\', 39, '_', 481, '`', 432, '|', 272};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));

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

@ -19,12 +19,47 @@
# include "../../../headers/constants.h" # include "../../../headers/constants.h"
# include "../../../../parse_types.h" # include "../../../../parse_types.h"
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};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map462(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 335, '!', 286, '"', 395, \
'#', 410, '$', 393, '&', 356, '\'', 219, '*', 371, '-', \
367, '0', 474, ';', 530, '?', 378, '@', 472, '\\', 71, \
'_', 477, '`', 430};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map463(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 336, '!', 286, '"', 395, \
'#', 410, '$', 393, '\'', 219, '*', 371, '-', 367, '0', \
474, '?', 378, '@', 472, '\\', 75, '_', 477, '`', 430};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map464(t_lexer *lexer, \ static inline bool lex_normal_map464(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 329, '!', 281, '#', 412, \ static uint32_t map[] = {'!', 286, '"', 395, '#', 410, \
'$', 388, '&', 352, '*', 364, '-', 361, '0', 479, ';', \ '$', 393, '&', 225, '\'', 219, '*', 371, '-', 367, '0', \
535, '?', 373, '@', 475, '\\', 80, '_', 482, 'i', 446}; 474, '<', 290, '>', 295, '?', 378, '@', 472, '\\', 61, \
'_', 477, '`', 430};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
@ -33,45 +68,10 @@ static inline bool lex_normal_map464(t_lexer *lexer, \
static inline bool lex_normal_map465(t_lexer *lexer, \ static inline bool lex_normal_map465(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 330, '!', 282, '"', 391, \ static uint32_t map[] = {'!', 286, '"', 395, '#', 410, \
'#', 412, '$', 389, '&', 214, '\'', 215, '*', 367, '-', \ '$', 393, '&', 218, '\'', 219, '(', 271, '*', 371, '-', \
363, '0', 477, '<', 286, '>', 291, '?', 374, '@', 476, \ 367, '0', 474, '<', 292, '>', 295, '?', 378, '@', 472, \
'\\', 99, '_', 481, '`', 432, '|', 233}; '\\', 39, '_', 477, '`', 430, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map466(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 331, '!', 282, '"', 391, \
'#', 412, '$', 389, '&', 352, '\'', 215, '*', 367, '-', \
363, '0', 477, ';', 535, '?', 374, '@', 476, '\\', 71, \
'_', 481, '`', 432};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map467(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 332, '!', 282, '"', 391, \
'#', 412, '$', 389, '\'', 215, '*', 367, '-', 363, '0', \
477, '?', 374, '@', 476, '\\', 76, '_', 481, '`', 432};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map468(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 282, '"', 391, '#', 412, \
'$', 389, '&', 221, '\'', 215, '*', 367, '-', 363, '0', \
477, '<', 286, '>', 291, '?', 374, '@', 476, '\\', 60, \
'_', 481, '`', 432};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));

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

@ -19,58 +19,57 @@
# include "../../../headers/constants.h" # include "../../../headers/constants.h"
# include "../../../../parse_types.h" # include "../../../../parse_types.h"
static inline bool lex_normal_map466(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 286, '"', 395, '#', 410, \
'$', 393, '&', 218, '\'', 219, '*', 371, '-', 367, '0', \
474, '<', 292, '>', 295, '?', 378, '@', 472, '\\', 45, \
'_', 477, '`', 430, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map467(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 285, '#', 410, '$', 392, \
'&', 218, '*', 368, '-', 365, '0', 475, '<', 292, '>', \
295, '?', 377, '@', 471, '\\', 65, '_', 478, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map468(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 285, '#', 410, '$', 392, \
')', 277, '*', 368, '-', 365, '0', 475, '?', 377, '@', \
471, '\\', 85, '_', 478, '|', 272};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map469(t_lexer *lexer, \ static inline bool lex_normal_map469(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'!', 282, '"', 391, '#', 412, \ static uint32_t map[] = {'!', 285, '#', 410, '$', 392, \
'$', 389, '&', 214, '\'', 215, '(', 267, '*', 367, '-', \ '*', 368, '-', 365, '0', 475, '?', 377, '@', 471, '\\', \
363, '0', 477, '<', 288, '>', 291, '?', 374, '@', 476, \ 90, '_', 478};
'\\', 42, '_', 481, '`', 432, '|', 272};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
} }
static inline bool lex_normal_map470(t_lexer *lexer, \ static inline bool lex_normal_map480(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'!', 282, '"', 391, '#', 412, \ static uint32_t map[] = {'\n', 310, '!', 286, '#', 411, \
'$', 389, '&', 214, '\'', 215, '*', 367, '-', 363, '0', \ '*', 371, '-', 367, '0', 474, '?', 378, '@', 472, '\\', \
477, '<', 288, '>', 291, '?', 374, '@', 476, '\\', 46, \ 12, '_', 477};
'_', 481, '`', 432, '|', 272};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map471(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 281, '#', 412, '$', 388, \
'&', 214, '*', 364, '-', 361, '0', 479, '<', 288, '>', \
291, '?', 373, '@', 475, '\\', 66, '_', 482, '|', 272};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map472(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 281, '#', 412, '$', 388, \
')', 273, '*', 364, '-', 361, '0', 479, '?', 373, '@', \
475, '\\', 85, '_', 482, '|', 268};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map473(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 281, '#', 412, '$', 388, \
'*', 364, '-', 361, '0', 479, '?', 373, '@', 475, '\\', \
90, '_', 482};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));

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

@ -19,12 +19,23 @@
# include "../../../headers/constants.h" # include "../../../headers/constants.h"
# include "../../../../parse_types.h" # include "../../../../parse_types.h"
static inline bool lex_normal_map481(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 313, '!', 286, '#', 411, \
'*', 371, '-', 367, '0', 474, '?', 378, '@', 472, '\\', \
21, '_', 477, 'e', 439};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map484(t_lexer *lexer, \ static inline bool lex_normal_map484(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 306, '!', 282, '#', 413, \ static uint32_t map[] = {'\n', 316, '!', 286, '#', 411, \
'*', 367, '-', 363, '0', 477, '?', 374, '@', 476, '\\', \ '*', 371, '-', 367, '0', 474, '?', 378, '@', 472, '\\', \
12, '_', 481, 'e', 441}; 18, '_', 477};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
@ -33,9 +44,9 @@ static inline bool lex_normal_map484(t_lexer *lexer, \
static inline bool lex_normal_map485(t_lexer *lexer, \ static inline bool lex_normal_map485(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 309, '!', 282, '#', 413, \ static uint32_t map[] = {'\n', 318, '!', 286, '#', 411, \
'*', 367, '-', 363, '0', 477, '?', 374, '@', 476, '\\', \ '*', 371, '-', 367, '0', 474, '?', 378, '@', 472, '\\', \
18, '_', 481}; 24, '_', 477, 'e', 439};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
@ -44,31 +55,20 @@ static inline bool lex_normal_map485(t_lexer *lexer, \
static inline bool lex_normal_map488(t_lexer *lexer, \ static inline bool lex_normal_map488(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 312, '!', 282, '#', 413, \ static uint32_t map[] = {'\n', 321, '!', 286, '#', 411, \
'*', 367, '-', 363, '0', 477, '?', 374, '@', 476, '\\', \ '*', 371, '-', 367, '0', 474, '?', 378, '@', 472, '\\', \
30, '_', 481, 'e', 441}; 27, '_', 477};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
} }
static inline bool lex_normal_map489(t_lexer *lexer, \ static inline bool lex_normal_map491(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 314, '!', 282, '#', 413, \ static uint32_t map[] = {'\n', 325, '!', 286, '#', 411, \
'*', 367, '-', 363, '0', 477, '?', 374, '@', 476, '\\', \ '*', 371, '-', 367, '0', 474, '?', 378, '@', 472, '\\', \
21, '_', 481}; 30, '_', 477};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map492(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 318, '!', 282, '#', 413, \
'*', 367, '-', 363, '0', 477, '?', 374, '@', 476, '\\', \
24, '_', 481};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));

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

@ -19,12 +19,34 @@
# include "../../../headers/constants.h" # include "../../../headers/constants.h"
# include "../../../../parse_types.h" # include "../../../../parse_types.h"
static inline bool lex_normal_map493(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 328, '!', 286, '#', 411, \
'*', 371, '-', 367, '0', 474, '?', 378, '@', 472, '\\', \
35, '_', 477};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map495(t_lexer *lexer, \ static inline bool lex_normal_map495(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 322, '!', 282, '#', 413, \ static uint32_t map[] = {'\n', 331, '!', 286, '#', 411, \
'*', 367, '-', 363, '0', 477, '?', 374, '@', 476, '\\', \ '*', 371, '-', 367, '0', 474, '?', 378, '@', 472, '\\', \
27, '_', 481}; 41, '_', 477};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map496(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 333, '!', 286, '#', 411, \
'*', 371, '-', 367, '0', 474, '?', 378, '@', 472, '\\', \
98, '_', 477};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
@ -33,42 +55,20 @@ static inline bool lex_normal_map495(t_lexer *lexer, \
static inline bool lex_normal_map497(t_lexer *lexer, \ static inline bool lex_normal_map497(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 325, '!', 282, '#', 413, \ static uint32_t map[] = {'\n', 335, '!', 286, '#', 411, \
'*', 367, '-', 363, '0', 477, '?', 374, '@', 476, '\\', \ '*', 371, '-', 367, '0', 474, '?', 378, '@', 472, '\\', \
35, '_', 481}; 70, '_', 477};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
} }
static inline bool lex_normal_map499(t_lexer *lexer, \ static inline bool lex_normal_map498(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 328, '!', 282, '#', 413, \ static uint32_t map[] = {'\n', 336, '!', 286, '#', 411, \
'*', 367, '-', 363, '0', 477, '?', 374, '@', 476, '\\', \ '*', 371, '-', 367, '0', 474, '?', 378, '@', 472, '\\', \
38, '_', 481}; 74, '_', 477};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map500(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 330, '!', 282, '#', 413, \
'*', 367, '-', 363, '0', 477, '?', 374, '@', 476, '\\', \
98, '_', 481};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map501(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 331, '!', 282, '#', 413, \
'*', 367, '-', 363, '0', 477, '?', 374, '@', 476, '\\', \
70, '_', 481};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));

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

@ -19,58 +19,47 @@
# include "../../../headers/constants.h" # include "../../../headers/constants.h"
# include "../../../../parse_types.h" # include "../../../../parse_types.h"
static inline bool lex_normal_map499(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 286, '#', 411, '%', 374, \
'*', 369, '+', 386, '-', 384, '/', 372, '0', 473, ':', \
381, '=', 289, '?', 378, '@', 472, '\\', 128, '^', 354, \
'_', 476, 'd', 526, 'e', 523, 'f', 521, 'i', 525, '{', \
280, '}', 282, '~', 388};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
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, '_', \
477};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map501(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 286, '#', 411, '*', 371, \
'-', 367, '0', 474, '?', 378, '@', 472, '\\', 44, '_', \
477};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map502(t_lexer *lexer, \ static inline bool lex_normal_map502(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 332, '!', 282, '#', 413, \ static uint32_t map[] = {'!', 286, '#', 411, '*', 371, \
'*', 367, '-', 363, '0', 477, '?', 374, '@', 476, '\\', \ '-', 367, '0', 474, '?', 378, '@', 472, '\\', 60, '_', \
75, '_', 481}; 477};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map503(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 282, '#', 413, '%', 370, \
'*', 365, '+', 382, '-', 380, '/', 368, '0', 478, ':', \
377, '=', 285, '?', 374, '@', 476, '\\', 127, '^', 350, \
'_', 480, 'd', 530, 'e', 527, 'f', 525, 'i', 529, '{', \
276, '}', 278, '~', 384};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map504(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 282, '#', 413, '*', 367, \
'-', 363, '0', 477, '?', 374, '@', 476, '\\', 41, '_', \
481};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map505(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 282, '#', 413, '*', 367, \
'-', 363, '0', 477, '?', 374, '@', 476, '\\', 45, '_', \
481};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map506(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 282, '#', 413, '*', 367, \
'-', 363, '0', 477, '?', 374, '@', 476, '\\', 59, '_', \
481};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));

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

@ -19,24 +19,12 @@
# include "../../../headers/constants.h" # include "../../../headers/constants.h"
# include "../../../../parse_types.h" # include "../../../../parse_types.h"
static inline bool lex_normal_map109(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 315, '"', 391, '#', 437, \
'$', 389, '&', 355, '\'', 215, '(', 267, '-', 520, '0', \
403, ';', 535, '<', 288, '>', 291, '\\', 154, '`', 433, \
'e', 531, '|', 272};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map110(t_lexer *lexer, \ static inline bool lex_normal_map110(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 316, '"', 391, '#', 437, \ static uint32_t map[] = {'\n', 319, '"', 395, '#', 435, \
'$', 389, '&', 214, '\'', 215, '-', 520, '0', 403, '<', \ '$', 393, '&', 359, '\'', 219, '(', 271, ';', 530, '<', \
286, '>', 291, '\\', 150, '`', 432, '|', 270}; 292, '>', 295, '\\', 155, '`', 431, 'e', 527, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
@ -45,10 +33,9 @@ static inline bool lex_normal_map110(t_lexer *lexer, \
static inline bool lex_normal_map111(t_lexer *lexer, \ static inline bool lex_normal_map111(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 317, '!', 281, '#', 412, \ static uint32_t map[] = {'\n', 320, '"', 395, '#', 435, \
'$', 388, '&', 355, ')', 273, '*', 364, '-', 361, '0', \ '$', 393, '&', 218, '\'', 219, '<', 290, '>', 295, '\\', \
479, ';', 535, '<', 288, '>', 291, '?', 373, '@', 475, \ 151, '`', 430, '|', 274};
'\\', 55, '_', 482, '|', 272};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
@ -57,11 +44,11 @@ static inline bool lex_normal_map111(t_lexer *lexer, \
static inline bool lex_normal_map112(t_lexer *lexer, \ static inline bool lex_normal_map112(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 318, '!', 282, '"', 391, \ static uint32_t map[] = {'\n', 321, '!', 286, '"', 395, \
'#', 412, '$', 389, '&', 355, '\'', 215, ')', 273, '*', \ '#', 410, '$', 393, '&', 359, '\'', 219, ')', 277, '*', \
367, '-', 363, '0', 477, ';', 535, '<', 288, '>', 291, \ 371, '-', 367, '0', 474, ';', 530, '<', 292, '>', 295, \
'?', 374, '@', 476, '\\', 25, '_', 481, '`', 432, '|', \ '?', 378, '@', 472, '\\', 28, '_', 477, '`', 430, '|', \
272}; 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
@ -70,9 +57,21 @@ static inline bool lex_normal_map112(t_lexer *lexer, \
static inline bool lex_normal_map113(t_lexer *lexer, \ static inline bool lex_normal_map113(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 319, '"', 391, '#', 437, \ static uint32_t map[] = {'\n', 322, '!', 285, '#', 410, \
'$', 389, '&', 352, '\'', 215, '(', 267, '-', 520, '0', \ '$', 392, '&', 359, '*', 368, '-', 365, '0', 475, ';', \
403, ';', 535, '\\', 164, '`', 432, 'e', 531}; 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};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));

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

@ -19,25 +19,12 @@
# include "../../../headers/constants.h" # include "../../../headers/constants.h"
# include "../../../../parse_types.h" # include "../../../../parse_types.h"
static inline bool lex_normal_map114(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 320, '"', 391, '#', 437, \
'$', 389, '&', 355, '\'', 215, '(', 267, ')', 273, '-', \
520, '0', 403, ';', 535, '<', 288, '>', 291, '\\', 156, \
'`', 433, '|', 272};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map115(t_lexer *lexer, \ static inline bool lex_normal_map115(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 321, '!', 281, '#', 412, \ static uint32_t map[] = {'\n', 324, '"', 395, '#', 435, \
'$', 388, '&', 355, '*', 364, '-', 361, '0', 479, ';', \ '$', 393, '&', 359, '\'', 219, '(', 271, ')', 277, ';', \
535, '<', 288, '>', 291, '?', 373, '@', 475, '\\', 57, \ 530, '<', 292, '>', 295, '\\', 153, '`', 431, '|', 276};
'_', 482, '|', 272};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
@ -46,10 +33,10 @@ static inline bool lex_normal_map115(t_lexer *lexer, \
static inline bool lex_normal_map116(t_lexer *lexer, \ static inline bool lex_normal_map116(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 322, '!', 282, '"', 391, \ static uint32_t map[] = {'\n', 325, '!', 286, '"', 395, \
'#', 412, '$', 389, '&', 355, '\'', 215, '*', 367, '-', \ '#', 410, '$', 393, '&', 359, '\'', 219, '*', 371, '-', \
363, '0', 477, ';', 535, '<', 288, '>', 291, '?', 374, \ 367, '0', 474, ';', 530, '<', 292, '>', 295, '?', 378, \
'@', 476, '\\', 28, '_', 481, '`', 432, '|', 272}; '@', 472, '\\', 31, '_', 477, '`', 430, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
@ -58,9 +45,10 @@ static inline bool lex_normal_map116(t_lexer *lexer, \
static inline bool lex_normal_map117(t_lexer *lexer, \ static inline bool lex_normal_map117(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 323, '"', 391, '#', 437, \ static uint32_t map[] = {'\n', 326, '!', 285, '#', 410, \
'$', 389, '&', 352, '\'', 215, '-', 520, '0', 403, ';', \ '$', 392, '&', 359, ')', 277, '*', 368, '-', 365, '0', \
535, '\\', 168, '`', 432}; 475, ';', 530, '<', 292, '>', 295, '?', 377, '@', 471, \
'\\', 57, '_', 478, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
@ -69,10 +57,21 @@ static inline bool lex_normal_map117(t_lexer *lexer, \
static inline bool lex_normal_map118(t_lexer *lexer, \ static inline bool lex_normal_map118(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 324, '!', 281, '#', 412, \ static uint32_t map[] = {'\n', 327, '"', 395, '#', 435, \
'$', 388, '&', 214, '*', 364, '-', 361, '0', 479, '<', \ '$', 393, '&', 356, '\'', 219, ';', 530, '\\', 169, '`', \
288, '>', 291, '?', 373, '@', 475, '\\', 64, '_', 482, \ 430};
'|', 272};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
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};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));

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

@ -19,24 +19,13 @@
# include "../../../headers/constants.h" # include "../../../headers/constants.h"
# include "../../../../parse_types.h" # include "../../../../parse_types.h"
static inline bool lex_normal_map119(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 325, '!', 282, '"', 391, \
'#', 412, '$', 389, '&', 214, '\'', 215, '(', 267, '*', \
367, '-', 363, '0', 477, '<', 288, '>', 291, '?', 374, \
'@', 476, '\\', 36, '_', 481, '`', 432, '|', 272};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map120(t_lexer *lexer, \ static inline bool lex_normal_map120(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 326, '"', 391, '#', 437, \ static uint32_t map[] = {'\n', 329, '!', 285, '#', 410, \
'$', 389, '&', 352, '\'', 215, '-', 520, '0', 403, ';', \ '$', 392, '&', 218, '*', 368, '-', 365, '0', 475, '<', \
535, '\\', 173, '`', 433}; 292, '>', 295, '?', 377, '@', 471, '\\', 63, '_', 478, \
'|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
@ -45,10 +34,9 @@ static inline bool lex_normal_map120(t_lexer *lexer, \
static inline bool lex_normal_map121(t_lexer *lexer, \ static inline bool lex_normal_map121(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 327, '!', 281, '#', 412, \ static uint32_t map[] = {'\n', 330, '"', 395, '#', 435, \
'$', 388, '&', 214, '*', 364, '-', 361, '0', 479, '<', \ '$', 393, '&', 356, '\'', 219, ';', 530, '\\', 176, '`', \
286, '>', 291, '?', 373, '@', 475, '\\', 102, '_', 482, \ 431};
'|', 233};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
@ -57,10 +45,10 @@ static inline bool lex_normal_map121(t_lexer *lexer, \
static inline bool lex_normal_map122(t_lexer *lexer, \ static inline bool lex_normal_map122(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 328, '!', 282, '"', 391, \ static uint32_t map[] = {'\n', 331, '!', 286, '"', 395, \
'#', 412, '$', 389, '&', 214, '\'', 215, '*', 367, '-', \ '#', 410, '$', 393, '&', 218, '\'', 219, '*', 371, '-', \
363, '0', 477, '<', 288, '>', 291, '?', 374, '@', 476, \ 367, '0', 474, '<', 292, '>', 295, '?', 378, '@', 472, \
'\\', 39, '_', 481, '`', 432, '|', 272}; '\\', 42, '_', 477, '`', 430, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
@ -69,9 +57,22 @@ static inline bool lex_normal_map122(t_lexer *lexer, \
static inline bool lex_normal_map123(t_lexer *lexer, \ static inline bool lex_normal_map123(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 329, '!', 281, '#', 412, \ static uint32_t map[] = {'\n', 332, '!', 285, '#', 410, \
'$', 388, '&', 352, '*', 364, '-', 361, '0', 479, ';', \ '$', 392, '&', 218, '*', 368, '-', 365, '0', 475, '<', \
535, '?', 373, '@', 475, '\\', 80, '_', 482, 'i', 446}; 290, '>', 295, '?', 377, '@', 471, '\\', 102, '_', 478, \
'|', 237};
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};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));

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

@ -19,25 +19,12 @@
# include "../../../headers/constants.h" # include "../../../headers/constants.h"
# include "../../../../parse_types.h" # include "../../../../parse_types.h"
static inline bool lex_normal_map124(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 330, '!', 282, '"', 391, \
'#', 412, '$', 389, '&', 214, '\'', 215, '*', 367, '-', \
363, '0', 477, '<', 286, '>', 291, '?', 374, '@', 476, \
'\\', 99, '_', 481, '`', 432, '|', 233};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map125(t_lexer *lexer, \ static inline bool lex_normal_map125(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 331, '!', 282, '"', 391, \ static uint32_t map[] = {'\n', 334, '!', 285, '#', 410, \
'#', 412, '$', 389, '&', 352, '\'', 215, '*', 367, '-', \ '$', 392, '&', 356, '*', 368, '-', 365, '0', 475, ';', \
363, '0', 477, ';', 535, '?', 374, '@', 476, '\\', 71, \ 530, '?', 377, '@', 471, '\\', 80, '_', 478, 'i', 443};
'_', 481, '`', 432};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
@ -46,36 +33,48 @@ static inline bool lex_normal_map125(t_lexer *lexer, \
static inline bool lex_normal_map126(t_lexer *lexer, \ static inline bool lex_normal_map126(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'\n', 332, '!', 282, '"', 391, \ static uint32_t map[] = {'\n', 335, '!', 286, '"', 395, \
'#', 412, '$', 389, '\'', 215, '*', 367, '-', 363, '0', \ '#', 410, '$', 393, '&', 356, '\'', 219, '*', 371, '-', \
477, '?', 374, '@', 476, '\\', 76, '_', 481, '`', 432}; 367, '0', 474, ';', 530, '?', 378, '@', 472, '\\', 71, \
'_', 477, '`', 430};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
} }
static inline bool lex_normal_map183(t_lexer *lexer, \ static inline bool lex_normal_map127(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'!', 282, '"', 391, '#', 412, \ static uint32_t map[] = {'\n', 336, '!', 286, '"', 395, \
'$', 389, '%', 370, '&', 354, '\'', 215, '(', 267, ')', \ '#', 410, '$', 393, '\'', 219, '*', 371, '-', 367, '0', \
273, '*', 365, '+', 382, '-', 380, '/', 368, '0', 478, \ 474, '?', 378, '@', 472, '\\', 75, '_', 477, '`', 430};
':', 377, ';', 535, '<', 287, '=', 285, '>', 290, '?', \
374, '@', 476, '\\', 128, '^', 350, '_', 480, '`', 433, \
'd', 530, 'e', 527, 'f', 525, 'i', 529, '{', 276, '|', \
269, '}', 278, '~', 384};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
} }
static inline bool lex_normal_map184(t_lexer *lexer, \ static inline bool lex_normal_map186(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'!', 282, '"', 391, '#', 412, \ static uint32_t map[] = {'!', 286, '"', 395, '#', 410, \
'$', 389, '&', 221, '\'', 215, '*', 367, '-', 363, '0', \ '$', 393, '%', 374, '&', 358, '\'', 219, '(', 271, ')', \
477, '<', 286, '>', 291, '?', 374, '@', 476, '\\', 60, \ 277, '*', 369, '+', 386, '-', 384, '/', 372, '0', 473, \
'_', 481, '`', 432}; ':', 381, ';', 530, '<', 291, '=', 289, '>', 294, '?', \
378, '@', 472, '\\', 129, '^', 354, '_', 476, '`', 431, \
'd', 526, 'e', 523, 'f', 521, 'i', 525, '{', 280, '|', \
273, '}', 282, '~', 388};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map187(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 286, '"', 395, '#', 410, \
'$', 393, '&', 225, '\'', 219, '*', 371, '-', 367, '0', \
474, '<', 290, '>', 295, '?', 378, '@', 472, '\\', 61, \
'_', 477, '`', 430};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));

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

@ -19,49 +19,13 @@
# include "../../../headers/constants.h" # include "../../../headers/constants.h"
# include "../../../../parse_types.h" # include "../../../../parse_types.h"
static inline bool lex_normal_map185(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 282, '"', 391, '#', 412, \
'$', 389, '&', 214, '\'', 215, '(', 267, '*', 367, '-', \
363, '0', 477, '<', 288, '>', 291, '?', 374, '@', 476, \
'\\', 42, '_', 481, '`', 432, '|', 272};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map186(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 282, '"', 391, '#', 412, \
'$', 389, '&', 214, '\'', 215, '*', 367, '-', 363, '0', \
477, '<', 288, '>', 291, '?', 374, '@', 476, '\\', 46, \
'_', 481, '`', 432, '|', 272};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map187(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 282, '"', 391, '#', 437, \
'$', 389, '&', 221, '\'', 215, '(', 267, ')', 273, '-', \
520, '0', 403, ';', 219, '<', 286, '>', 291, '\\', 131, \
'`', 432, '{', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map188(t_lexer *lexer, \ static inline bool lex_normal_map188(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'!', 282, '"', 391, '#', 437, \ static uint32_t map[] = {'!', 286, '"', 395, '#', 410, \
'$', 389, '&', 221, '\'', 215, '(', 267, '-', 520, '0', \ '$', 393, '&', 218, '\'', 219, '(', 271, '*', 371, '-', \
403, ';', 219, '<', 286, '>', 291, '\\', 159, '`', 432, \ 367, '0', 474, '<', 292, '>', 295, '?', 378, '@', 472, \
'e', 531, '{', 276}; '\\', 39, '_', 477, '`', 430, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
@ -70,10 +34,43 @@ static inline bool lex_normal_map188(t_lexer *lexer, \
static inline bool lex_normal_map189(t_lexer *lexer, \ static inline bool lex_normal_map189(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'!', 282, '"', 391, '#', 437, \ static uint32_t map[] = {'!', 286, '"', 395, '#', 410, \
'$', 389, '&', 221, '\'', 215, '(', 267, '-', 520, '0', \ '$', 393, '&', 218, '\'', 219, '*', 371, '-', 367, '0', \
403, '<', 286, '>', 291, '\\', 133, '`', 432, 'e', 528, \ 474, '<', 292, '>', 295, '?', 378, '@', 472, '\\', 45, \
'f', 525, '{', 276}; '_', 477, '`', 430, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map190(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 286, '"', 395, '#', 435, \
'$', 393, '&', 225, '\'', 219, '(', 271, ')', 277, ';', \
223, '<', 290, '>', 295, '\\', 132, '`', 430, '{', 280};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map191(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 286, '"', 395, '#', 435, \
'$', 393, '&', 225, '\'', 219, '(', 271, ';', 223, '<', \
290, '>', 295, '\\', 160, '`', 430, 'e', 527, '{', 280};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map192(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 286, '"', 395, '#', 435, \
'$', 393, '&', 225, '\'', 219, '(', 271, '<', 290, '>', \
295, '\\', 134, '`', 430, 'e', 524, 'f', 521, '{', 280};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));

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

@ -19,48 +19,12 @@
# include "../../../headers/constants.h" # include "../../../headers/constants.h"
# include "../../../../parse_types.h" # include "../../../../parse_types.h"
static inline bool lex_normal_map190(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 282, '"', 391, '#', 437, \
'$', 389, '&', 221, '\'', 215, '(', 267, '-', 520, '0', \
403, '<', 286, '>', 291, '\\', 138, '`', 432, 'd', 530, \
'{', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map191(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 282, '"', 391, '#', 437, \
'$', 389, '&', 221, '\'', 215, '(', 267, '-', 520, '0', \
403, '<', 286, '>', 291, '\\', 140, '`', 432, '{', 276, \
'}', 278};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map192(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 282, '"', 391, '#', 437, \
'$', 389, '&', 221, '\'', 215, '(', 267, '-', 520, '0', \
403, '<', 286, '>', 291, '\\', 142, '`', 432, 'f', 525, \
'{', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map193(t_lexer *lexer, \ static inline bool lex_normal_map193(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'!', 220, '#', 437, '%', 372, \ static uint32_t map[] = {'!', 286, '"', 395, '#', 435, \
'&', 353, ')', 273, '*', 366, '+', 360, '-', 362, '/', \ '$', 393, '&', 225, '\'', 219, '(', 271, '<', 290, '>', \
369, '<', 289, '=', 284, '>', 292, '?', 373}; 295, '\\', 139, '`', 430, 'd', 526, '{', 280};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
@ -69,9 +33,42 @@ static inline bool lex_normal_map193(t_lexer *lexer, \
static inline bool lex_normal_map194(t_lexer *lexer, \ static inline bool lex_normal_map194(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'!', 281, '"', 391, '#', 412, \ static uint32_t map[] = {'!', 286, '"', 395, '#', 435, \
'$', 388, '*', 364, '-', 361, '0', 479, '?', 373, '@', \ '$', 393, '&', 225, '\'', 219, '(', 271, '<', 290, '>', \
475, '\\', 83, '_', 482}; 295, '\\', 141, '`', 430, '{', 280, '}', 282};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map195(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 286, '"', 395, '#', 435, \
'$', 393, '&', 225, '\'', 219, '(', 271, '<', 290, '>', \
295, '\\', 143, '`', 430, 'f', 521, '{', 280};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map196(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 224, '#', 435, '%', 376, \
'&', 357, ')', 277, '*', 370, '+', 364, '-', 366, '/', \
373, '<', 293, '=', 288, '>', 296, '?', 377};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map197(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 285, '"', 395, '#', 410, \
'$', 392, '*', 368, '-', 365, '0', 475, '?', 377, '@', \
471, '\\', 83, '_', 478};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));

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

@ -19,45 +19,12 @@
# include "../../../headers/constants.h" # include "../../../headers/constants.h"
# include "../../../../parse_types.h" # include "../../../../parse_types.h"
static inline bool lex_normal_map195(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 281, '"', 391, '#', 437, \
'$', 390, '&', 214, '(', 267, ')', 217, '+', 383, '-', \
381, '0', 406, '<', 288, '=', 283, '>', 291};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map196(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 281, '#', 412, '$', 388, \
'&', 214, '*', 364, '-', 361, '0', 479, '<', 288, '>', \
291, '?', 373, '@', 475, '\\', 66, '_', 482, '|', 272};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map197(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 281, '#', 412, '$', 388, \
')', 273, '*', 364, '-', 361, '0', 479, '?', 373, '@', \
475, '\\', 85, '_', 482, '|', 268};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map198(t_lexer *lexer, \ static inline bool lex_normal_map198(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'!', 281, '#', 412, '$', 388, \ static uint32_t map[] = {'!', 285, '"', 395, '#', 435, \
'*', 364, '-', 361, '0', 479, '?', 373, '@', 475, '\\', \ '$', 394, '&', 218, '(', 271, ')', 221, '+', 387, '-', \
88, '_', 482}; 385, '<', 292, '=', 287, '>', 295};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
@ -66,8 +33,41 @@ static inline bool lex_normal_map198(t_lexer *lexer, \
static inline bool lex_normal_map199(t_lexer *lexer, \ static inline bool lex_normal_map199(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'!', 281, '#', 412, '$', 388, \ static uint32_t map[] = {'!', 285, '#', 410, '$', 392, \
'*', 364, '-', 361, '0', 479, '?', 373, '@', 475}; '&', 218, '*', 368, '-', 365, '0', 475, '<', 292, '>', \
295, '?', 377, '@', 471, '\\', 65, '_', 478, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map200(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 285, '#', 410, '$', 392, \
')', 277, '*', 368, '-', 365, '0', 475, '?', 377, '@', \
471, '\\', 85, '_', 478, '|', 272};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map201(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 285, '#', 410, '$', 392, \
'*', 368, '-', 365, '0', 475, '?', 377, '@', 471, '\\', \
88, '_', 478};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map202(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 285, '#', 410, '$', 392, \
'*', 368, '-', 365, '0', 475, '?', 377, '@', 471};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));

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

@ -19,45 +19,12 @@
# include "../../../headers/constants.h" # include "../../../headers/constants.h"
# include "../../../../parse_types.h" # include "../../../../parse_types.h"
static inline bool lex_normal_map200(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 281, '#', 412, '$', 388, \
'*', 364, '-', 361, '0', 479, '?', 373, '@', 475, '\\', \
90, '_', 482};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map201(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'"', 391, '#', 437, '$', 389, \
'&', 221, '\'', 215, '(', 267, '-', 520, '0', 403, '<', \
286, '>', 291, '\\', 144, '`', 432, '{', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map202(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'"', 391, '#', 437, '$', 389, \
'&', 214, '\'', 215, '(', 267, '-', 520, '0', 403, '<', \
288, '>', 291, '\\', 152, '`', 432, '|', 272};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map203(t_lexer *lexer, \ static inline bool lex_normal_map203(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'"', 391, '#', 437, '$', 389, \ static uint32_t map[] = {'!', 285, '#', 410, '$', 392, \
'&', 214, '\'', 215, '(', 267, '-', 520, '0', 403, '<', \ '*', 368, '-', 365, '0', 475, '?', 377, '@', 471, '\\', \
288, '>', 291, '\\', 161, '`', 433, '|', 272}; 90, '_', 478};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));
@ -66,9 +33,41 @@ static inline bool lex_normal_map203(t_lexer *lexer, \
static inline bool lex_normal_map204(t_lexer *lexer, \ static inline bool lex_normal_map204(t_lexer *lexer, \
t_lexer_state *s) t_lexer_state *s)
{ {
static uint32_t map[] = {'"', 391, '#', 437, '$', 389, \ static uint32_t map[] = {'"', 395, '#', 435, '$', 393, \
'\'', 215, '(', 267, '-', 520, '0', 403, '\\', 166, '`', \ '&', 225, '\'', 219, '(', 271, '<', 290, '>', 295, '\\', \
432, 'e', 531}; 145, '`', 430, '{', 280};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map205(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'"', 395, '#', 435, '$', 393, \
'&', 218, '\'', 219, '(', 271, '<', 292, '>', 295, '\\', \
157, '`', 430, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map206(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'"', 395, '#', 435, '$', 393, \
'&', 218, '\'', 219, '(', 271, '<', 292, '>', 295, '\\', \
162, '`', 431, '|', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map207(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'"', 395, '#', 435, '$', 393, \
'\'', 219, '(', 271, '\\', 167, '`', 430, 'e', 527};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \ return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s)); lexer, s));

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

@ -22,10 +22,6 @@
# include "./inline.h" # include "./inline.h"
# include "../../../parse_types.h" # include "../../../parse_types.h"
bool lex_normal_s237_bis(t_lexer *lexer, t_lexer_state *s, bool *ret);
bool lex_normal_s238_bis(t_lexer *lexer, t_lexer_state *s, bool *ret);
bool lex_normal_s250_bis(t_lexer *lexer, t_lexer_state *s, bool *ret);
bool lex_normal_s0(t_lexer *lexer, t_lexer_state *s); bool lex_normal_s0(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s1(t_lexer *lexer, t_lexer_state *s); bool lex_normal_s1(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s2(t_lexer *lexer, t_lexer_state *s); bool lex_normal_s2(t_lexer *lexer, t_lexer_state *s);
@ -557,11 +553,6 @@ bool lex_normal_s527(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s528(t_lexer *lexer, t_lexer_state *s); bool lex_normal_s528(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s529(t_lexer *lexer, t_lexer_state *s); bool lex_normal_s529(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s530(t_lexer *lexer, t_lexer_state *s); bool lex_normal_s530(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s531(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s532(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s533(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s534(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s535(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_default(t_lexer *lexer, t_lexer_state *s); bool lex_normal_default(t_lexer *lexer, t_lexer_state *s);
#endif // LEX_NORMAL_FUNCS_H #endif // LEX_NORMAL_FUNCS_H

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

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

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

@ -15,37 +15,39 @@
bool lex_normal_s0(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s0(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->eof) if (s->eof)
return (lex_advance(251, lexer, s)); return (lex_advance(255, lexer, s));
if (lex_normal_map0(lexer, s)) if (lex_normal_map0(lexer, s))
return (true); return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \ if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' ')) s->lookahead == ' '))
return (lex_skip(248, lexer, s)); return (lex_skip(252, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(503, lexer, s)); return (lex_advance(499, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(407, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s1(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s1(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_skip(183, lexer, s)); return (lex_skip(186, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s2(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s2(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_skip(187, lexer, s)); return (lex_skip(190, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s3(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s3(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_skip(189, lexer, s)); return (lex_skip(192, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }

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

@ -19,40 +19,40 @@ bool lex_normal_s5(t_lexer *lexer, t_lexer_state *s)
if ((s->lookahead == '\t' || s->lookahead == ' ')) if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(5, lexer, s)); return (lex_skip(5, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(483, lexer, s)); return (lex_advance(479, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9')) if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(404, lexer, s)); return (lex_advance(407, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \ if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \ s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '{' && s->lookahead != '|')) != '<' && s->lookahead != '{' && s->lookahead != '|'))
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s6(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s6(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_skip(190, lexer, s)); return (lex_skip(193, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s7(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s7(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_skip(191, lexer, s)); return (lex_skip(194, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s8(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s8(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_skip(192, lexer, s)); return (lex_skip(195, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s9(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s9(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_skip(201, lexer, s)); return (lex_skip(204, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }

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

@ -15,14 +15,14 @@
bool lex_normal_s50(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s50(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(451, lexer, s)); return (lex_advance(447, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s51(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s51(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(451, lexer, s)); return (lex_advance(447, lexer, s));
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_advance(50, lexer, s)); return (lex_advance(50, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
@ -34,25 +34,25 @@ bool lex_normal_s51(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s52(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s52(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(454, lexer, s)); return (lex_advance(450, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s53(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s53(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(454, lexer, s)); return (lex_advance(450, lexer, s));
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_advance(52, lexer, s)); return (lex_advance(52, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' ')) s->lookahead == ' '))
return (lex_skip(107, lexer, s)); return (lex_skip(108, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s54(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s54(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(456, lexer, s)); return (lex_advance(453, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }

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

@ -20,13 +20,13 @@ bool lex_normal_s500(t_lexer *lexer, t_lexer_state *s)
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(500, lexer, s)); return (lex_advance(500, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9')) if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(405, lexer, s)); return (lex_advance(408, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \ if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z'))) (s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(443, lexer, s)); return (lex_advance(440, lexer, s));
if ((!s->eof && set_contains(sym_word_character_set_1(), \ if ((!s->eof && set_contains(sym_word_character_set_1(), \
9, s->lookahead))) 9, s->lookahead)))
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -38,13 +38,13 @@ bool lex_normal_s501(t_lexer *lexer, t_lexer_state *s)
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(501, lexer, s)); return (lex_advance(501, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9')) if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(405, lexer, s)); return (lex_advance(408, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \ if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z'))) (s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(443, lexer, s)); return (lex_advance(440, lexer, s));
if ((!s->eof && set_contains(sym_word_character_set_1(), \ if ((!s->eof && set_contains(sym_word_character_set_1(), \
9, s->lookahead))) 9, s->lookahead)))
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -56,46 +56,58 @@ bool lex_normal_s502(t_lexer *lexer, t_lexer_state *s)
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(502, lexer, s)); return (lex_advance(502, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9')) if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(405, lexer, s)); return (lex_advance(408, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \ if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z'))) (s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(443, lexer, s)); return (lex_advance(440, lexer, s));
if ((!s->eof && set_contains(sym_word_character_set_1(), \ if ((!s->eof && set_contains(sym_word_character_set_1(), \
9, s->lookahead))) 9, s->lookahead)))
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s503(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s503(t_lexer *lexer, t_lexer_state *s)
{ {
lex_accept_token(sym_word, lexer, s); lex_accept_token(sym_word, lexer, s);
if (lex_normal_map503(lexer, s)) if (s->lookahead == '!')
return (true); return (lex_advance(286, lexer, s));
if (s->lookahead == '#')
return (lex_advance(529, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(131, lexer, s));
if (s->lookahead == '{')
return (lex_advance(280, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(503, lexer, s)); return (lex_advance(503, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '\t' && \ if ((s->lookahead >= '0' && s->lookahead <= '9'))
s->lookahead < '\r') && (s->lookahead > ' ' && \ return (lex_advance(407, lexer, s));
s->lookahead < '+') && (s->lookahead > ':' && s->lookahead \ if ((!s->eof && set_contains(sym_word_character_set_1(), \
< '@') && (s->lookahead > '^' && s->lookahead < '`') && \ 9, s->lookahead)))
(s->lookahead > '{' && s->lookahead < '~'))) return (lex_advance(528, lexer, s));
return (lex_advance(533, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s504(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s504(t_lexer *lexer, t_lexer_state *s)
{ {
lex_accept_token(sym_word, lexer, s); lex_accept_token(sym_word, lexer, s);
if (lex_normal_map504(lexer, s)) if (s->lookahead == '!')
return (true); return (lex_advance(286, lexer, s));
if (s->lookahead == '#')
return (lex_advance(529, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(133, lexer, s));
if (s->lookahead == 'e')
return (lex_advance(524, lexer, s));
if (s->lookahead == 'f')
return (lex_advance(521, lexer, s));
if (s->lookahead == '{')
return (lex_advance(280, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(504, lexer, s)); return (lex_advance(504, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9')) if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(405, lexer, s)); return (lex_advance(407, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(443, lexer, s));
if ((!s->eof && set_contains(sym_word_character_set_1(), \ if ((!s->eof && set_contains(sym_word_character_set_1(), \
9, s->lookahead))) 9, s->lookahead)))
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }

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

@ -15,36 +15,46 @@
bool lex_normal_s505(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s505(t_lexer *lexer, t_lexer_state *s)
{ {
lex_accept_token(sym_word, lexer, s); lex_accept_token(sym_word, lexer, s);
if (lex_normal_map505(lexer, s)) if (s->lookahead == '!')
return (true); return (lex_advance(286, lexer, s));
if (s->lookahead == '#')
return (lex_advance(529, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(138, lexer, s));
if (s->lookahead == 'd')
return (lex_advance(526, lexer, s));
if (s->lookahead == '{')
return (lex_advance(280, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(505, lexer, s)); return (lex_advance(505, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9')) if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(405, lexer, s)); return (lex_advance(407, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(443, lexer, s));
if ((!s->eof && set_contains(sym_word_character_set_1(), \ if ((!s->eof && set_contains(sym_word_character_set_1(), \
9, s->lookahead))) 9, s->lookahead)))
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s506(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s506(t_lexer *lexer, t_lexer_state *s)
{ {
lex_accept_token(sym_word, lexer, s); lex_accept_token(sym_word, lexer, s);
if (lex_normal_map506(lexer, s)) if (s->lookahead == '!')
return (true); return (lex_advance(286, lexer, s));
if (s->lookahead == '#')
return (lex_advance(529, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(140, 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')) if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(506, lexer, s)); return (lex_advance(506, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9')) if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(405, lexer, s)); return (lex_advance(407, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(443, lexer, s));
if ((!s->eof && set_contains(sym_word_character_set_1(), \ if ((!s->eof && set_contains(sym_word_character_set_1(), \
9, s->lookahead))) 9, s->lookahead)))
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -52,65 +62,63 @@ bool lex_normal_s507(t_lexer *lexer, t_lexer_state *s)
{ {
lex_accept_token(sym_word, lexer, s); lex_accept_token(sym_word, lexer, s);
if (s->lookahead == '!') if (s->lookahead == '!')
return (lex_advance(282, lexer, s)); return (lex_advance(286, lexer, s));
if (s->lookahead == '#') if (s->lookahead == '#')
return (lex_advance(534, lexer, s)); return (lex_advance(529, lexer, s));
if (s->lookahead == '-')
return (lex_advance(520, lexer, s));
if (s->lookahead == '0')
return (lex_advance(403, lexer, s));
if (s->lookahead == '\\') if (s->lookahead == '\\')
return (lex_advance(130, lexer, s)); return (lex_advance(142, lexer, s));
if (s->lookahead == 'f')
return (lex_advance(521, lexer, s));
if (s->lookahead == '{') if (s->lookahead == '{')
return (lex_advance(276, lexer, s)); return (lex_advance(280, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(507, lexer, s)); return (lex_advance(507, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9')) if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(404, lexer, s)); return (lex_advance(407, lexer, s));
if ((!s->eof && set_contains(sym_word_character_set_1(), \ if ((!s->eof && set_contains(sym_word_character_set_1(), \
9, s->lookahead))) 9, s->lookahead)))
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s508(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s508(t_lexer *lexer, t_lexer_state *s)
{ {
lex_accept_token(sym_word, lexer, s); lex_accept_token(sym_word, lexer, s);
if (lex_normal_map508(lexer, s)) if (s->lookahead == '!')
return (true); return (lex_advance(286, lexer, s));
if (s->lookahead == '#')
return (lex_advance(529, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(159, lexer, s));
if (s->lookahead == 'e')
return (lex_advance(527, lexer, s));
if (s->lookahead == '{')
return (lex_advance(280, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(508, lexer, s)); return (lex_advance(508, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9')) if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(404, lexer, s)); return (lex_advance(407, lexer, s));
if ((!s->eof && set_contains(sym_word_character_set_1(), \ if ((!s->eof && set_contains(sym_word_character_set_1(), \
9, s->lookahead))) 9, s->lookahead)))
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s509(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s509(t_lexer *lexer, t_lexer_state *s)
{ {
lex_accept_token(sym_word, lexer, s); lex_accept_token(sym_word, lexer, s);
if (s->lookahead == '!')
return (lex_advance(282, lexer, s));
if (s->lookahead == '#') if (s->lookahead == '#')
return (lex_advance(534, lexer, s)); return (lex_advance(529, lexer, s));
if (s->lookahead == '-')
return (lex_advance(520, lexer, s));
if (s->lookahead == '0')
return (lex_advance(403, lexer, s));
if (s->lookahead == '\\') if (s->lookahead == '\\')
return (lex_advance(137, lexer, s)); return (lex_advance(144, lexer, s));
if (s->lookahead == 'd')
return (lex_advance(530, lexer, s));
if (s->lookahead == '{') if (s->lookahead == '{')
return (lex_advance(276, lexer, s)); return (lex_advance(280, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(509, lexer, s)); return (lex_advance(509, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9')) if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(404, lexer, s)); return (lex_advance(407, lexer, s));
if ((!s->eof && set_contains(sym_word_character_set_1(), \ if ((!s->eof && set_contains(sym_word_character_set_1(), \
9, s->lookahead))) 9, s->lookahead)))
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }

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

@ -15,81 +15,53 @@
bool lex_normal_s510(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s510(t_lexer *lexer, t_lexer_state *s)
{ {
lex_accept_token(sym_word, lexer, s); lex_accept_token(sym_word, lexer, s);
if (s->lookahead == '!')
return (lex_advance(282, lexer, s));
if (s->lookahead == '#') if (s->lookahead == '#')
return (lex_advance(534, lexer, s)); return (lex_advance(529, lexer, s));
if (s->lookahead == '-')
return (lex_advance(520, lexer, s));
if (s->lookahead == '0')
return (lex_advance(403, lexer, s));
if (s->lookahead == '\\') if (s->lookahead == '\\')
return (lex_advance(139, lexer, s)); return (lex_advance(156, lexer, s));
if (s->lookahead == '{')
return (lex_advance(276, lexer, s));
if (s->lookahead == '}')
return (lex_advance(278, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(510, lexer, s)); return (lex_advance(510, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9')) if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(404, lexer, s)); return (lex_advance(407, lexer, s));
if ((!s->eof && set_contains(sym_word_character_set_1(), \ if ((!s->eof && set_contains(sym_word_character_set_1(), \
9, s->lookahead))) 9, s->lookahead)))
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s511(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s511(t_lexer *lexer, t_lexer_state *s)
{ {
lex_accept_token(sym_word, lexer, s); lex_accept_token(sym_word, lexer, s);
if (s->lookahead == '!')
return (lex_advance(282, lexer, s));
if (s->lookahead == '#') if (s->lookahead == '#')
return (lex_advance(534, lexer, s)); return (lex_advance(529, lexer, s));
if (s->lookahead == '-')
return (lex_advance(520, lexer, s));
if (s->lookahead == '0')
return (lex_advance(403, lexer, s));
if (s->lookahead == '\\') if (s->lookahead == '\\')
return (lex_advance(141, lexer, s)); return (lex_advance(161, lexer, s));
if (s->lookahead == 'f')
return (lex_advance(525, lexer, s));
if (s->lookahead == '{')
return (lex_advance(276, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(511, lexer, s)); return (lex_advance(511, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9')) if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(404, lexer, s)); return (lex_advance(407, lexer, s));
if ((!s->eof && set_contains(sym_word_character_set_1(), \ if ((!s->eof && set_contains(sym_word_character_set_1(), \
9, s->lookahead))) 9, s->lookahead)))
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s512(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s512(t_lexer *lexer, t_lexer_state *s)
{ {
lex_accept_token(sym_word, lexer, s); lex_accept_token(sym_word, lexer, s);
if (s->lookahead == '!')
return (lex_advance(282, lexer, s));
if (s->lookahead == '#') if (s->lookahead == '#')
return (lex_advance(534, lexer, s)); return (lex_advance(529, lexer, s));
if (s->lookahead == '-')
return (lex_advance(520, lexer, s));
if (s->lookahead == '0')
return (lex_advance(403, lexer, s));
if (s->lookahead == '\\') if (s->lookahead == '\\')
return (lex_advance(158, lexer, s)); return (lex_advance(166, lexer, s));
if (s->lookahead == 'e') if (s->lookahead == 'e')
return (lex_advance(531, lexer, s)); return (lex_advance(527, lexer, s));
if (s->lookahead == '{')
return (lex_advance(276, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(512, lexer, s)); return (lex_advance(512, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9')) if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(404, lexer, s)); return (lex_advance(407, lexer, s));
if ((!s->eof && set_contains(sym_word_character_set_1(), \ if ((!s->eof && set_contains(sym_word_character_set_1(), \
9, s->lookahead))) 9, s->lookahead)))
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -97,22 +69,16 @@ bool lex_normal_s513(t_lexer *lexer, t_lexer_state *s)
{ {
lex_accept_token(sym_word, lexer, s); lex_accept_token(sym_word, lexer, s);
if (s->lookahead == '#') if (s->lookahead == '#')
return (lex_advance(534, lexer, s)); return (lex_advance(529, lexer, s));
if (s->lookahead == '-')
return (lex_advance(520, lexer, s));
if (s->lookahead == '0')
return (lex_advance(403, lexer, s));
if (s->lookahead == '\\') if (s->lookahead == '\\')
return (lex_advance(143, lexer, s)); return (lex_advance(171, lexer, s));
if (s->lookahead == '{')
return (lex_advance(276, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(513, lexer, s)); return (lex_advance(513, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9')) if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(404, lexer, s)); return (lex_advance(407, lexer, s));
if ((!s->eof && set_contains(sym_word_character_set_1(), \ if ((!s->eof && set_contains(sym_word_character_set_1(), \
9, s->lookahead))) 9, s->lookahead)))
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -120,19 +86,15 @@ bool lex_normal_s514(t_lexer *lexer, t_lexer_state *s)
{ {
lex_accept_token(sym_word, lexer, s); lex_accept_token(sym_word, lexer, s);
if (s->lookahead == '#') if (s->lookahead == '#')
return (lex_advance(534, lexer, s)); return (lex_advance(529, lexer, s));
if (s->lookahead == '-')
return (lex_advance(520, lexer, s));
if (s->lookahead == '0')
return (lex_advance(403, lexer, s));
if (s->lookahead == '\\') if (s->lookahead == '\\')
return (lex_advance(151, lexer, s)); return (lex_advance(173, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(514, lexer, s)); return (lex_advance(514, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9')) if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(404, lexer, s)); return (lex_advance(407, lexer, s));
if ((!s->eof && set_contains(sym_word_character_set_1(), \ if ((!s->eof && set_contains(sym_word_character_set_1(), \
9, s->lookahead))) 9, s->lookahead)))
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }

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

@ -16,20 +16,16 @@ bool lex_normal_s515(t_lexer *lexer, t_lexer_state *s)
{ {
lex_accept_token(sym_word, lexer, s); lex_accept_token(sym_word, lexer, s);
if (s->lookahead == '#') if (s->lookahead == '#')
return (lex_advance(534, lexer, s)); return (lex_advance(529, lexer, s));
if (s->lookahead == '-')
return (lex_advance(520, lexer, s));
if (s->lookahead == '0')
return (lex_advance(403, lexer, s));
if (s->lookahead == '\\') if (s->lookahead == '\\')
return (lex_advance(160, lexer, s)); return (lex_advance(177, lexer, s));
if (s->lookahead == '}')
return (lex_advance(282, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(515, lexer, s)); return (lex_advance(515, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(404, lexer, s));
if ((!s->eof && set_contains(sym_word_character_set_1(), \ if ((!s->eof && set_contains(sym_word_character_set_1(), \
9, s->lookahead))) 9, s->lookahead)))
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -37,74 +33,55 @@ bool lex_normal_s516(t_lexer *lexer, t_lexer_state *s)
{ {
lex_accept_token(sym_word, lexer, s); lex_accept_token(sym_word, lexer, s);
if (s->lookahead == '#') if (s->lookahead == '#')
return (lex_advance(534, lexer, s)); return (lex_advance(529, lexer, s));
if (s->lookahead == '-')
return (lex_advance(520, lexer, s));
if (s->lookahead == '0')
return (lex_advance(403, lexer, s));
if (s->lookahead == '\\') if (s->lookahead == '\\')
return (lex_advance(165, lexer, s)); return (lex_advance(181, lexer, s));
if (s->lookahead == 'e')
return (lex_advance(531, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(516, lexer, s)); return (lex_advance(516, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(404, lexer, s));
if ((!s->eof && set_contains(sym_word_character_set_1(), \ if ((!s->eof && set_contains(sym_word_character_set_1(), \
9, s->lookahead))) 9, s->lookahead)))
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s517(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s517(t_lexer *lexer, t_lexer_state *s)
{ {
lex_accept_token(sym_word, lexer, s); lex_accept_token(sym_word, lexer, s);
if (s->lookahead == '#')
return (lex_advance(534, lexer, s));
if (s->lookahead == '-')
return (lex_advance(520, lexer, s));
if (s->lookahead == '0')
return (lex_advance(403, lexer, s));
if (s->lookahead == '\\') if (s->lookahead == '\\')
return (lex_advance(170, lexer, s)); return (lex_advance(238, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if (s->lookahead == 'a')
return (lex_advance(517, lexer, s)); return (lex_advance(518, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9')) if ((!s->eof && \
return (lex_advance(404, lexer, s)); set_contains(sym__comment_word_character_set_1(), 10, \
if ((!s->eof && set_contains(sym_word_character_set_1(), \ s->lookahead)))
9, s->lookahead))) return (lex_advance(528, lexer, s));
return (lex_advance(533, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s518(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s518(t_lexer *lexer, t_lexer_state *s)
{ {
lex_accept_token(sym_word, lexer, s); lex_accept_token(sym_word, lexer, s);
if (s->lookahead == '#')
return (lex_advance(534, lexer, s));
if (s->lookahead == '\\') if (s->lookahead == '\\')
return (lex_advance(175, lexer, s)); return (lex_advance(238, lexer, s));
if (s->lookahead == '}') if (s->lookahead == 'c')
return (lex_advance(278, lexer, s)); return (lex_advance(268, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if ((!s->eof && \
return (lex_advance(518, lexer, s)); set_contains(sym__comment_word_character_set_1(), 10, \
if ((!s->eof && set_contains(sym_word_character_set_1(), \ s->lookahead)))
9, s->lookahead))) return (lex_advance(528, lexer, s));
return (lex_advance(533, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s519(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s519(t_lexer *lexer, t_lexer_state *s)
{ {
lex_accept_token(sym_word, lexer, s); lex_accept_token(sym_word, lexer, s);
if (s->lookahead == '#')
return (lex_advance(534, lexer, s));
if (s->lookahead == '\\') if (s->lookahead == '\\')
return (lex_advance(178, lexer, s)); return (lex_advance(238, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if (s->lookahead == 'e')
return (lex_advance(519, lexer, s)); return (lex_advance(266, lexer, s));
if ((!s->eof && set_contains(sym_word_character_set_1(), \ if ((!s->eof && \
9, s->lookahead))) set_contains(sym__comment_word_character_set_1(), 10, \
return (lex_advance(533, lexer, s)); s->lookahead)))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }

46
parser/static/lex_funcs/lex_normal/state_104.c
View file

@ -15,16 +15,14 @@
bool lex_normal_s520(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s520(t_lexer *lexer, t_lexer_state *s)
{ {
lex_accept_token(sym_word, lexer, s); lex_accept_token(sym_word, lexer, s);
if (s->lookahead == '0')
return (lex_advance(403, lexer, s));
if (s->lookahead == '\\') if (s->lookahead == '\\')
return (lex_advance(234, lexer, s)); return (lex_advance(238, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9')) if (s->lookahead == 'f')
return (lex_advance(404, lexer, s)); return (lex_advance(264, lexer, s));
if ((!s->eof && \ if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \ set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead))) s->lookahead)))
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -32,13 +30,13 @@ bool lex_normal_s521(t_lexer *lexer, t_lexer_state *s)
{ {
lex_accept_token(sym_word, lexer, s); lex_accept_token(sym_word, lexer, s);
if (s->lookahead == '\\') if (s->lookahead == '\\')
return (lex_advance(234, lexer, s)); return (lex_advance(238, lexer, s));
if (s->lookahead == 'a') if (s->lookahead == 'i')
return (lex_advance(522, lexer, s)); return (lex_advance(262, lexer, s));
if ((!s->eof && \ if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \ set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead))) s->lookahead)))
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -46,13 +44,15 @@ bool lex_normal_s522(t_lexer *lexer, t_lexer_state *s)
{ {
lex_accept_token(sym_word, lexer, s); lex_accept_token(sym_word, lexer, s);
if (s->lookahead == '\\') if (s->lookahead == '\\')
return (lex_advance(234, lexer, s)); return (lex_advance(238, lexer, s));
if (s->lookahead == 'c') if (s->lookahead == 'i')
return (lex_advance(264, lexer, s)); return (lex_advance(520, lexer, s));
if (s->lookahead == 's')
return (lex_advance(519, lexer, s));
if ((!s->eof && \ if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \ set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead))) s->lookahead)))
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -60,13 +60,15 @@ bool lex_normal_s523(t_lexer *lexer, t_lexer_state *s)
{ {
lex_accept_token(sym_word, lexer, s); lex_accept_token(sym_word, lexer, s);
if (s->lookahead == '\\') if (s->lookahead == '\\')
return (lex_advance(234, lexer, s)); return (lex_advance(238, lexer, s));
if (s->lookahead == 'e') if (s->lookahead == 'l')
return (lex_advance(262, lexer, s)); return (lex_advance(522, lexer, s));
if (s->lookahead == 's')
return (lex_advance(517, lexer, s));
if ((!s->eof && \ if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \ set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead))) s->lookahead)))
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -74,12 +76,12 @@ bool lex_normal_s524(t_lexer *lexer, t_lexer_state *s)
{ {
lex_accept_token(sym_word, lexer, s); lex_accept_token(sym_word, lexer, s);
if (s->lookahead == '\\') if (s->lookahead == '\\')
return (lex_advance(234, lexer, s)); return (lex_advance(238, lexer, s));
if (s->lookahead == 'f') if (s->lookahead == 'l')
return (lex_advance(260, lexer, s)); return (lex_advance(522, lexer, s));
if ((!s->eof && \ if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \ set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead))) s->lookahead)))
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }

38
parser/static/lex_funcs/lex_normal/state_105.c
View file

@ -16,13 +16,13 @@ bool lex_normal_s525(t_lexer *lexer, t_lexer_state *s)
{ {
lex_accept_token(sym_word, lexer, s); lex_accept_token(sym_word, lexer, s);
if (s->lookahead == '\\') if (s->lookahead == '\\')
return (lex_advance(234, lexer, s)); return (lex_advance(238, lexer, s));
if (s->lookahead == 'i') if (s->lookahead == 'n')
return (lex_advance(258, lexer, s)); return (lex_advance(257, lexer, s));
if ((!s->eof && \ if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \ set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead))) s->lookahead)))
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -30,15 +30,13 @@ bool lex_normal_s526(t_lexer *lexer, t_lexer_state *s)
{ {
lex_accept_token(sym_word, lexer, s); lex_accept_token(sym_word, lexer, s);
if (s->lookahead == '\\') if (s->lookahead == '\\')
return (lex_advance(234, lexer, s)); return (lex_advance(238, lexer, s));
if (s->lookahead == 'i') if (s->lookahead == 'o')
return (lex_advance(524, lexer, s)); return (lex_advance(260, lexer, s));
if (s->lookahead == 's')
return (lex_advance(523, lexer, s));
if ((!s->eof && \ if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \ set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead))) s->lookahead)))
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -46,15 +44,13 @@ bool lex_normal_s527(t_lexer *lexer, t_lexer_state *s)
{ {
lex_accept_token(sym_word, lexer, s); lex_accept_token(sym_word, lexer, s);
if (s->lookahead == '\\') if (s->lookahead == '\\')
return (lex_advance(234, lexer, s)); return (lex_advance(238, lexer, s));
if (s->lookahead == 'l')
return (lex_advance(526, lexer, s));
if (s->lookahead == 's') if (s->lookahead == 's')
return (lex_advance(521, lexer, s)); return (lex_advance(517, lexer, s));
if ((!s->eof && \ if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \ set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead))) s->lookahead)))
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -62,13 +58,11 @@ bool lex_normal_s528(t_lexer *lexer, t_lexer_state *s)
{ {
lex_accept_token(sym_word, lexer, s); lex_accept_token(sym_word, lexer, s);
if (s->lookahead == '\\') if (s->lookahead == '\\')
return (lex_advance(234, lexer, s)); return (lex_advance(238, lexer, s));
if (s->lookahead == 'l')
return (lex_advance(526, lexer, s));
if ((!s->eof && \ if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \ set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead))) s->lookahead)))
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -76,12 +70,10 @@ bool lex_normal_s529(t_lexer *lexer, t_lexer_state *s)
{ {
lex_accept_token(sym_word, lexer, s); lex_accept_token(sym_word, lexer, s);
if (s->lookahead == '\\') if (s->lookahead == '\\')
return (lex_advance(234, lexer, s)); return (lex_advance(434, lexer, s));
if (s->lookahead == 'n')
return (lex_advance(253, lexer, s));
if ((!s->eof && \ if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \ set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead))) s->lookahead)))
return (lex_advance(533, lexer, s)); return (lex_advance(529, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }

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

@ -14,66 +14,16 @@
bool lex_normal_s530(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s530(t_lexer *lexer, t_lexer_state *s)
{ {
lex_accept_token(sym_word, lexer, s); lex_accept_token(anon_sym_SEMI, lexer, s);
if (s->lookahead == '\\') if (s->lookahead == ';')
return (lex_advance(234, lexer, s)); return (lex_advance(279, lexer, s));
if (s->lookahead == 'o')
return (lex_advance(256, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(533, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s531(t_lexer *lexer, t_lexer_state *s) bool lex_normal_default(t_lexer *lexer, t_lexer_state *s)
{ {
lex_accept_token(sym_word, lexer, s); (void)(lexer);
if (s->lookahead == '\\') (void)(s);
return (lex_advance(234, lexer, s)); s->result = false;
if (s->lookahead == 's') return (false);
return (lex_advance(521, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(533, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s532(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(sym_word, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(234, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(404, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(533, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s533(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(sym_word, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(234, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(533, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s534(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(sym_word, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(436, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(534, lexer, s));
return (lex_end_state(lexer, s));
} }

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

@ -1,29 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_107.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#include "./lex_normal_funcs.h"
bool lex_normal_s535(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_SEMI, lexer, s);
if (s->lookahead == ';')
return (lex_advance(275, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_default(t_lexer *lexer, t_lexer_state *s)
{
(void)(lexer);
(void)(s);
s->result = false;
return (false);
}

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

@ -15,52 +15,44 @@
bool lex_normal_s55(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s55(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(456, lexer, s)); return (lex_advance(453, lexer, s));
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_advance(54, lexer, s)); return (lex_advance(54, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' ')) s->lookahead == ' '))
return (lex_skip(111, lexer, s)); return (lex_skip(113, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s56(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s56(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(458, lexer, s)); return (lex_advance(455, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s57(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s57(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(458, lexer, s)); return (lex_advance(455, lexer, s));
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_advance(56, lexer, s)); return (lex_advance(56, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' ')) s->lookahead == ' '))
return (lex_skip(115, lexer, s)); return (lex_skip(117, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s58(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s58(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(468, lexer, s)); return (lex_skip(191, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s59(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s59(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(468, lexer, s)); return (lex_advance(464, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(58, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(506, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(184, lexer, s));
if (s->lookahead != 0)
return (lex_advance(533, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }

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

@ -15,46 +15,54 @@
bool lex_normal_s60(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s60(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(468, lexer, s)); return (lex_advance(464, lexer, s));
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_advance(58, lexer, s)); return (lex_advance(59, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (s->lookahead == ' ')
s->lookahead == ' ')) return (lex_advance(502, lexer, s));
return (lex_skip(184, lexer, s)); if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(187, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s61(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s61(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_skip(188, lexer, s)); return (lex_advance(464, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(59, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(187, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s62(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s62(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_skip(195, lexer, s)); return (lex_advance(457, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s63(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s63(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(460, lexer, s)); return (lex_advance(457, 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_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s64(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s64(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(460, lexer, s)); return (lex_advance(467, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(63, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(118, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }

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

@ -15,54 +15,54 @@
bool lex_normal_s65(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s65(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(471, lexer, s)); return (lex_advance(467, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(64, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(199, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s66(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s66(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(471, lexer, s)); return (lex_advance(312, lexer, s));
if (s->lookahead == '\r') if (s->lookahead == '#')
return (lex_advance(65, lexer, s)); return (lex_advance(435, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (s->lookahead == '&')
return (lex_advance(356, lexer, s));
if (s->lookahead == ';')
return (lex_advance(530, lexer, s));
if (s->lookahead == '\\')
return (lex_skip(185, 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 == ' ')) s->lookahead == ' '))
return (lex_skip(196, lexer, s)); return (lex_skip(66, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s67(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s67(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_skip(113, lexer, s)); return (lex_skip(198, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s68(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s68(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(308, lexer, s)); return (lex_skip(114, lexer, s));
if (s->lookahead == '#')
return (lex_advance(437, lexer, s));
if (s->lookahead == '&')
return (lex_advance(352, lexer, s));
if (s->lookahead == ';')
return (lex_advance(535, lexer, s));
if (s->lookahead == '\\')
return (lex_skip(182, lexer, s));
if (s->lookahead == '`')
return (lex_advance(222, lexer, s));
if (s->lookahead == 'i')
return (lex_advance(230, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(68, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s69(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s69(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(466, lexer, s)); return (lex_advance(462, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }

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

@ -15,49 +15,57 @@
bool lex_normal_s70(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s70(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(466, lexer, s)); return (lex_advance(462, lexer, s));
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_advance(69, lexer, s)); return (lex_advance(69, lexer, s));
if (s->lookahead == ' ') if (s->lookahead == ' ')
return (lex_advance(501, lexer, s)); return (lex_advance(497, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f')) if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(125, lexer, s)); return (lex_skip(126, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s71(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s71(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(466, lexer, s)); return (lex_advance(462, lexer, s));
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_advance(69, lexer, s)); return (lex_advance(69, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' ')) s->lookahead == ' '))
return (lex_skip(125, lexer, s)); return (lex_skip(126, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s72(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s72(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_skip(204, lexer, s)); return (lex_skip(207, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s73(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s73(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_skip(117, lexer, s)); return (lex_advance(463, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s74(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s74(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(467, lexer, s)); 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)); return (lex_end_state(lexer, s));
} }

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

@ -15,49 +15,41 @@
bool lex_normal_s75(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s75(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(467, lexer, s)); return (lex_advance(463, lexer, s));
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_advance(74, lexer, s)); return (lex_advance(73, lexer, s));
if (s->lookahead == ' ') if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
return (lex_advance(502, lexer, s)); s->lookahead == ' '))
if ((s->lookahead >= '\t' && s->lookahead <= '\f')) return (lex_skip(127, lexer, s));
return (lex_skip(126, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s76(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s76(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(467, lexer, s)); return (lex_skip(118, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(74, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(126, lexer, s));
if (s->lookahead != 0)
return (lex_advance(533, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s77(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s77(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_skip(213, lexer, s)); return (lex_skip(217, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s78(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s78(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_skip(209, lexer, s)); return (lex_skip(212, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s79(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s79(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(464, lexer, s)); return (lex_advance(461, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }

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

@ -15,46 +15,46 @@
bool lex_normal_s80(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s80(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(464, lexer, s)); return (lex_advance(461, lexer, s));
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_advance(79, lexer, s)); return (lex_advance(79, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' ')) s->lookahead == ' '))
return (lex_skip(123, lexer, s)); return (lex_skip(125, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s81(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s81(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_skip(212, lexer, s)); return (lex_skip(209, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s82(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s82(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_skip(206, lexer, s)); return (lex_skip(216, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s83(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s83(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(396, lexer, s)); return (lex_advance(400, lexer, s));
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_advance(392, lexer, s)); return (lex_advance(396, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' ')) s->lookahead == ' '))
return (lex_advance(396, lexer, s)); return (lex_advance(400, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(399, lexer, s)); return (lex_advance(403, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s84(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s84(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(472, lexer, s)); return (lex_advance(468, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }

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

@ -15,46 +15,46 @@
bool lex_normal_s85(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s85(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(472, lexer, s)); return (lex_advance(468, lexer, s));
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_advance(84, lexer, s)); return (lex_advance(84, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' ')) s->lookahead == ' '))
return (lex_skip(197, lexer, s)); return (lex_skip(200, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s86(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s86(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_skip(199, lexer, s)); return (lex_skip(202, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s87(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s87(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_skip(207, lexer, s)); return (lex_skip(210, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s88(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s88(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(397, lexer, s)); return (lex_advance(401, lexer, s));
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_advance(394, lexer, s)); return (lex_advance(398, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' ')) s->lookahead == ' '))
return (lex_advance(397, lexer, s)); return (lex_advance(401, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(399, lexer, s)); return (lex_advance(403, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s89(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s89(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(473, lexer, s)); return (lex_advance(469, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }

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

@ -15,33 +15,33 @@
bool lex_normal_s90(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s90(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(473, lexer, s)); return (lex_advance(469, lexer, s));
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_advance(89, lexer, s)); return (lex_advance(89, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' ')) s->lookahead == ' '))
return (lex_skip(200, lexer, s)); return (lex_skip(203, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s91(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s91(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_skip(205, lexer, s)); return (lex_skip(208, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s92(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s92(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_skip(208, lexer, s)); return (lex_skip(211, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s93(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s93(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_skip(68, lexer, s)); return (lex_skip(66, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -52,13 +52,14 @@ bool lex_normal_s94(t_lexer *lexer, t_lexer_state *s)
if ((s->lookahead == '\t' || s->lookahead == ' ')) if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(94, lexer, s)); return (lex_skip(94, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(485, lexer, s)); return (lex_advance(481, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9')) if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(405, lexer, s)); return (lex_advance(408, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \ if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z'))) (s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(443, lexer, s)); return (lex_advance(440, lexer, s));
if (s->lookahead != 0) if ((s->lookahead != 0 && (s->lookahead > '&' && \
return (lex_advance(533, lexer, s)); s->lookahead < '*')))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }

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

@ -15,49 +15,49 @@
bool lex_normal_s95(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s95(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_skip(109, lexer, s)); return (lex_skip(110, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s96(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s96(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_skip(114, lexer, s)); return (lex_skip(115, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s97(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s97(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(465, lexer, s)); return (lex_advance(460, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s98(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s98(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(465, lexer, s)); return (lex_advance(460, lexer, s));
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_advance(97, lexer, s)); return (lex_advance(97, lexer, s));
if (s->lookahead == ' ') if (s->lookahead == ' ')
return (lex_advance(500, lexer, s)); return (lex_advance(496, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f')) if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(124, lexer, s)); return (lex_skip(124, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s99(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s99(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(465, lexer, s)); return (lex_advance(460, lexer, s));
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_advance(97, lexer, s)); return (lex_advance(97, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' ')) s->lookahead == ' '))
return (lex_skip(124, lexer, s)); return (lex_skip(124, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }

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

@ -19,57 +19,57 @@ bool lex_normal_s10(t_lexer *lexer, t_lexer_state *s)
if ((s->lookahead == '\t' || s->lookahead == ' ')) if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(10, lexer, s)); return (lex_skip(10, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(484, lexer, s)); return (lex_advance(480, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9')) if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(405, lexer, s)); return (lex_advance(408, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \ if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z'))) (s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(443, lexer, s)); return (lex_advance(440, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \ if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*'))) s->lookahead < '*')))
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s11(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s11(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(450, lexer, s)); return (lex_advance(446, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s12(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s12(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(450, lexer, s)); return (lex_advance(446, lexer, s));
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_advance(11, lexer, s)); return (lex_advance(11, lexer, s));
if (s->lookahead == ' ') if (s->lookahead == ' ')
return (lex_advance(484, lexer, s)); return (lex_advance(480, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f')) if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(10, lexer, s)); return (lex_skip(10, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s13(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s13(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(450, lexer, s)); return (lex_advance(446, lexer, s));
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_advance(11, lexer, s)); return (lex_advance(11, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' ')) s->lookahead == ' '))
return (lex_skip(10, lexer, s)); return (lex_skip(10, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s14(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s14(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(474, lexer, s)); return (lex_advance(470, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }

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

@ -15,48 +15,39 @@
bool lex_normal_s100(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s100(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_skip(203, lexer, s)); return (lex_skip(206, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s101(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s101(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(462, lexer, s)); return (lex_advance(459, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s102(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s102(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(462, lexer, s)); return (lex_advance(459, lexer, s));
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_advance(101, lexer, s)); return (lex_advance(101, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' ')) s->lookahead == ' '))
return (lex_skip(121, lexer, s)); return (lex_skip(123, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s103(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s103(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_skip(120, lexer, s)); return (lex_skip(121, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s104(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s104(t_lexer *lexer, t_lexer_state *s)
{ {
if (lex_normal_map104(lexer, s)) if (s->lookahead == '\n')
return (true); return (lex_skip(213, lexer, s));
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(104, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(486, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(404, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')')))
return (lex_advance(533, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }

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

@ -19,11 +19,12 @@ bool lex_normal_s105(t_lexer *lexer, t_lexer_state *s)
if ((s->lookahead == '\t' || s->lookahead == ' ')) if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(105, lexer, s)); return (lex_skip(105, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(487, lexer, s)); return (lex_advance(482, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9')) if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(404, lexer, s)); return (lex_advance(407, lexer, s));
if (s->lookahead != 0) if ((s->lookahead != 0 && (s->lookahead > '&' && \
return (lex_advance(533, lexer, s)); s->lookahead < ')')))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -34,15 +35,11 @@ bool lex_normal_s106(t_lexer *lexer, t_lexer_state *s)
if ((s->lookahead == '\t' || s->lookahead == ' ')) if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(106, lexer, s)); return (lex_skip(106, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(488, lexer, s)); return (lex_advance(483, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9')) if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(405, lexer, s)); return (lex_advance(407, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \ if (s->lookahead != 0)
(s->lookahead >= 'a' && s->lookahead <= 'z'))) return (lex_advance(528, lexer, s));
return (lex_advance(443, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*')))
return (lex_advance(533, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -50,13 +47,17 @@ bool lex_normal_s107(t_lexer *lexer, t_lexer_state *s)
{ {
if (lex_normal_map107(lexer, s)) if (lex_normal_map107(lexer, s))
return (true); return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \ if ((s->lookahead == '\t' || s->lookahead == ' '))
s->lookahead == ' '))
return (lex_skip(107, lexer, s)); return (lex_skip(107, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \ if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \ return (lex_advance(484, 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'))) (s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(449, lexer, s)); return (lex_advance(440, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -64,18 +65,13 @@ bool lex_normal_s108(t_lexer *lexer, t_lexer_state *s)
{ {
if (lex_normal_map108(lexer, s)) if (lex_normal_map108(lexer, s))
return (true); return (true);
if ((s->lookahead == '\t' || s->lookahead == ' ')) if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(108, lexer, s)); return (lex_skip(108, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if (((s->lookahead >= '1' && s->lookahead <= '9') || \
return (lex_advance(489, lexer, s)); (s->lookahead >= 'A' && s->lookahead <= 'Z') || \
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(405, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z'))) (s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(443, lexer, s)); return (lex_advance(445, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*')))
return (lex_advance(533, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -86,11 +82,14 @@ bool lex_normal_s109(t_lexer *lexer, t_lexer_state *s)
if ((s->lookahead == '\t' || s->lookahead == ' ')) if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(109, lexer, s)); return (lex_skip(109, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(490, lexer, s)); return (lex_advance(485, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9')) if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(404, lexer, s)); 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 > '&' && \ if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')'))) s->lookahead < '*')))
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }

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

@ -19,13 +19,12 @@ bool lex_normal_s110(t_lexer *lexer, t_lexer_state *s)
if ((s->lookahead == '\t' || s->lookahead == ' ')) if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(110, lexer, s)); return (lex_skip(110, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(491, lexer, s)); return (lex_advance(486, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9')) if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(404, lexer, s)); return (lex_advance(407, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \ if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \ s->lookahead < ')')))
!= '<')) return (lex_advance(528, lexer, s));
return (lex_advance(533, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -33,13 +32,16 @@ bool lex_normal_s111(t_lexer *lexer, t_lexer_state *s)
{ {
if (lex_normal_map111(lexer, s)) if (lex_normal_map111(lexer, s))
return (true); return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \ if ((s->lookahead == '\t' || s->lookahead == ' '))
s->lookahead == ' '))
return (lex_skip(111, lexer, s)); return (lex_skip(111, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \ if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \ return (lex_advance(487, lexer, s));
(s->lookahead >= 'a' && s->lookahead <= 'z'))) if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(449, lexer, s)); return (lex_advance(407, 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)); return (lex_end_state(lexer, s));
} }
@ -50,15 +52,15 @@ bool lex_normal_s112(t_lexer *lexer, t_lexer_state *s)
if ((s->lookahead == '\t' || s->lookahead == ' ')) if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(112, lexer, s)); return (lex_skip(112, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(492, lexer, s)); return (lex_advance(488, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9')) if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(405, lexer, s)); return (lex_advance(408, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \ if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z'))) (s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(443, lexer, s)); return (lex_advance(440, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \ if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*'))) s->lookahead < '*')))
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -66,16 +68,13 @@ bool lex_normal_s113(t_lexer *lexer, t_lexer_state *s)
{ {
if (lex_normal_map113(lexer, s)) if (lex_normal_map113(lexer, s))
return (true); return (true);
if ((s->lookahead == '\t' || s->lookahead == ' ')) if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(113, lexer, s)); return (lex_skip(113, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if (((s->lookahead >= '1' && s->lookahead <= '9') || \
return (lex_advance(493, lexer, s)); (s->lookahead >= 'A' && s->lookahead <= 'Z') || \
if ((s->lookahead >= '1' && s->lookahead <= '9')) (s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(404, lexer, s)); return (lex_advance(445, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '>' && s->lookahead != '|'))
return (lex_advance(533, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -86,10 +85,12 @@ bool lex_normal_s114(t_lexer *lexer, t_lexer_state *s)
if ((s->lookahead == '\t' || s->lookahead == ' ')) if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(114, lexer, s)); return (lex_skip(114, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(494, lexer, s)); return (lex_advance(489, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9')) if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(404, lexer, s)); return (lex_advance(407, lexer, s));
if (s->lookahead != 0) if ((s->lookahead != 0 && (s->lookahead > '&' && \
return (lex_advance(533, lexer, s)); s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '>' && s->lookahead != '|'))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }

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

@ -16,13 +16,14 @@ bool lex_normal_s115(t_lexer *lexer, t_lexer_state *s)
{ {
if (lex_normal_map115(lexer, s)) if (lex_normal_map115(lexer, s))
return (true); return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \ if ((s->lookahead == '\t' || s->lookahead == ' '))
s->lookahead == ' '))
return (lex_skip(115, lexer, s)); return (lex_skip(115, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \ if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \ return (lex_advance(490, lexer, s));
(s->lookahead >= 'a' && s->lookahead <= 'z'))) if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(449, lexer, s)); return (lex_advance(407, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -33,15 +34,15 @@ bool lex_normal_s116(t_lexer *lexer, t_lexer_state *s)
if ((s->lookahead == '\t' || s->lookahead == ' ')) if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(116, lexer, s)); return (lex_skip(116, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(495, lexer, s)); return (lex_advance(491, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9')) if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(405, lexer, s)); return (lex_advance(408, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \ if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z'))) (s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(443, lexer, s)); return (lex_advance(440, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \ if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*'))) s->lookahead < '*')))
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -49,16 +50,13 @@ bool lex_normal_s117(t_lexer *lexer, t_lexer_state *s)
{ {
if (lex_normal_map117(lexer, s)) if (lex_normal_map117(lexer, s))
return (true); return (true);
if ((s->lookahead == '\t' || s->lookahead == ' ')) if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(117, lexer, s)); return (lex_skip(117, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if (((s->lookahead >= '1' && s->lookahead <= '9') || \
return (lex_advance(496, lexer, s)); (s->lookahead >= 'A' && s->lookahead <= 'Z') || \
if ((s->lookahead >= '1' && s->lookahead <= '9')) (s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(404, lexer, s)); return (lex_advance(445, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '>' && s->lookahead != '|'))
return (lex_advance(533, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -66,13 +64,16 @@ bool lex_normal_s118(t_lexer *lexer, t_lexer_state *s)
{ {
if (lex_normal_map118(lexer, s)) if (lex_normal_map118(lexer, s))
return (true); return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \ if ((s->lookahead == '\t' || s->lookahead == ' '))
s->lookahead == ' '))
return (lex_skip(118, lexer, s)); return (lex_skip(118, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \ if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \ return (lex_advance(492, lexer, s));
(s->lookahead >= 'a' && s->lookahead <= 'z'))) if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(449, lexer, s)); return (lex_advance(407, lexer, s));
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)); return (lex_end_state(lexer, s));
} }
@ -83,15 +84,15 @@ bool lex_normal_s119(t_lexer *lexer, t_lexer_state *s)
if ((s->lookahead == '\t' || s->lookahead == ' ')) if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(119, lexer, s)); return (lex_skip(119, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(497, lexer, s)); return (lex_advance(493, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9')) if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(405, lexer, s)); return (lex_advance(408, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \ if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z'))) (s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(443, lexer, s)); return (lex_advance(440, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \ if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*') && s->lookahead != ';' && s->lookahead \ s->lookahead < '*') && s->lookahead != ';' && s->lookahead \
!= '<')) != '<'))
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }

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

@ -16,16 +16,13 @@ bool lex_normal_s120(t_lexer *lexer, t_lexer_state *s)
{ {
if (lex_normal_map120(lexer, s)) if (lex_normal_map120(lexer, s))
return (true); return (true);
if ((s->lookahead == '\t' || s->lookahead == ' ')) if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(120, lexer, s)); return (lex_skip(120, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if (((s->lookahead >= '1' && s->lookahead <= '9') || \
return (lex_advance(498, lexer, s)); (s->lookahead >= 'A' && s->lookahead <= 'Z') || \
if ((s->lookahead >= '1' && s->lookahead <= '9')) (s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(404, lexer, s)); return (lex_advance(445, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '>' && s->lookahead != '|'))
return (lex_advance(533, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -33,13 +30,16 @@ bool lex_normal_s121(t_lexer *lexer, t_lexer_state *s)
{ {
if (lex_normal_map121(lexer, s)) if (lex_normal_map121(lexer, s))
return (true); return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \ if ((s->lookahead == '\t' || s->lookahead == ' '))
s->lookahead == ' '))
return (lex_skip(121, lexer, s)); return (lex_skip(121, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \ if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \ return (lex_advance(494, lexer, s));
(s->lookahead >= 'a' && s->lookahead <= 'z'))) if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(449, lexer, s)); return (lex_advance(407, lexer, s));
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)); return (lex_end_state(lexer, s));
} }
@ -50,16 +50,16 @@ bool lex_normal_s122(t_lexer *lexer, t_lexer_state *s)
if ((s->lookahead == '\t' || s->lookahead == ' ')) if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(122, lexer, s)); return (lex_skip(122, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(499, lexer, s)); return (lex_advance(495, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9')) if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(405, lexer, s)); return (lex_advance(408, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \ if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z'))) (s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(443, lexer, s)); return (lex_advance(440, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \ if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*') && s->lookahead != ';' && s->lookahead \ s->lookahead < '*') && s->lookahead != ';' && s->lookahead \
!= '<')) != '<'))
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -73,7 +73,7 @@ bool lex_normal_s123(t_lexer *lexer, t_lexer_state *s)
if (((s->lookahead >= '1' && s->lookahead <= '9') || \ if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \ (s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z'))) (s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(449, lexer, s)); return (lex_advance(445, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -84,15 +84,15 @@ bool lex_normal_s124(t_lexer *lexer, t_lexer_state *s)
if ((s->lookahead == '\t' || s->lookahead == ' ')) if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(124, lexer, s)); return (lex_skip(124, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(500, lexer, s)); return (lex_advance(496, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9')) if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(405, lexer, s)); return (lex_advance(408, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \ if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z'))) (s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(443, lexer, s)); return (lex_advance(440, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \ if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*') && s->lookahead != ';' && s->lookahead \ s->lookahead < '*') && s->lookahead != ';' && s->lookahead \
!= '<')) != '<'))
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }

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

@ -16,20 +16,13 @@ bool lex_normal_s125(t_lexer *lexer, t_lexer_state *s)
{ {
if (lex_normal_map125(lexer, s)) if (lex_normal_map125(lexer, s))
return (true); return (true);
if ((s->lookahead == '\t' || s->lookahead == ' ')) if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(125, lexer, s)); return (lex_skip(125, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if (((s->lookahead >= '1' && s->lookahead <= '9') || \
return (lex_advance(501, lexer, s)); (s->lookahead >= 'A' && s->lookahead <= 'Z') || \
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(405, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z'))) (s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(443, lexer, s)); return (lex_advance(445, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*') && s->lookahead != ';' && s->lookahead \
!= '<' && (s->lookahead > '>' && s->lookahead < 'Z') && \
s->lookahead != '|'))
return (lex_advance(533, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -40,30 +33,38 @@ bool lex_normal_s126(t_lexer *lexer, t_lexer_state *s)
if ((s->lookahead == '\t' || s->lookahead == ' ')) if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(126, lexer, s)); return (lex_skip(126, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r')) if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(502, lexer, s)); return (lex_advance(497, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9')) if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(405, lexer, s)); return (lex_advance(408, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \ if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z'))) (s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(443, lexer, s)); return (lex_advance(440, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \ if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*') && s->lookahead != ';' && s->lookahead \ s->lookahead < '*') && s->lookahead != ';' && s->lookahead \
!= '<' && (s->lookahead > '>' && s->lookahead < 'Z') && \ != '<' && (s->lookahead > '>' && s->lookahead < 'Z') && \
s->lookahead != '|')) s->lookahead != '|'))
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s127(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s127(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (lex_normal_map127(lexer, s))
return (lex_skip(1, lexer, s)); return (true);
if (s->lookahead == ' ') if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_advance(503, lexer, s)); return (lex_skip(127, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f')) if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_skip(183, lexer, s)); return (lex_advance(498, lexer, s));
if (s->lookahead != 0) if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(533, lexer, s)); 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 \
!= '<' && (s->lookahead > '>' && s->lookahead < 'Z') && \
s->lookahead != '|'))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -71,19 +72,23 @@ bool lex_normal_s128(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(1, lexer, s)); return (lex_skip(1, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (s->lookahead == ' ')
s->lookahead == ' ')) return (lex_advance(499, lexer, s));
return (lex_skip(183, lexer, s)); if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(186, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s129(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s129(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_advance(400, lexer, s)); return (lex_skip(1, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(186, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(399, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }

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

@ -15,13 +15,9 @@
bool lex_normal_s130(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s130(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(2, lexer, s)); return (lex_advance(404, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(507, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(187, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(403, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -29,24 +25,24 @@ bool lex_normal_s131(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(2, lexer, s)); return (lex_skip(2, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (s->lookahead == ' ')
s->lookahead == ' ')) return (lex_advance(503, lexer, s));
return (lex_skip(187, lexer, s)); if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(190, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s132(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s132(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(3, lexer, s)); return (lex_skip(2, lexer, s));
if (s->lookahead == ' ') if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
return (lex_advance(508, lexer, s)); s->lookahead == ' '))
if ((s->lookahead >= '\t' && s->lookahead <= '\f')) return (lex_skip(190, lexer, s));
return (lex_skip(189, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -54,22 +50,23 @@ bool lex_normal_s133(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(3, lexer, s)); return (lex_skip(3, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (s->lookahead == ' ')
s->lookahead == ' ')) return (lex_advance(504, lexer, s));
return (lex_skip(189, lexer, s)); if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(192, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s134(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s134(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_advance(395, lexer, s)); return (lex_skip(3, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' ')) s->lookahead == ' '))
return (lex_advance(398, lexer, s)); return (lex_skip(192, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(399, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }

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

@ -15,13 +15,12 @@
bool lex_normal_s135(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s135(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(4, lexer, s)); return (lex_advance(399, lexer, s));
if (s->lookahead == ' ') if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
return (lex_advance(483, lexer, s)); s->lookahead == ' '))
if ((s->lookahead >= '\t' && s->lookahead <= '\f')) return (lex_advance(402, lexer, s));
return (lex_skip(5, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(403, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -29,24 +28,24 @@ bool lex_normal_s136(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(4, lexer, s)); return (lex_skip(4, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (s->lookahead == ' ')
s->lookahead == ' ')) return (lex_advance(479, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(5, lexer, s)); return (lex_skip(5, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s137(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s137(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(6, lexer, s)); return (lex_skip(4, lexer, s));
if (s->lookahead == ' ') if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
return (lex_advance(509, lexer, s)); s->lookahead == ' '))
if ((s->lookahead >= '\t' && s->lookahead <= '\f')) return (lex_skip(5, lexer, s));
return (lex_skip(190, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -54,23 +53,23 @@ bool lex_normal_s138(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(6, lexer, s)); return (lex_skip(6, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (s->lookahead == ' ')
s->lookahead == ' ')) return (lex_advance(505, lexer, s));
return (lex_skip(190, lexer, s)); if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(193, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s139(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s139(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(7, lexer, s)); return (lex_skip(6, lexer, s));
if (s->lookahead == ' ') if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
return (lex_advance(510, lexer, s)); s->lookahead == ' '))
if ((s->lookahead >= '\t' && s->lookahead <= '\f')) return (lex_skip(193, lexer, s));
return (lex_skip(191, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }

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

@ -16,24 +16,24 @@ bool lex_normal_s140(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(7, lexer, s)); return (lex_skip(7, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (s->lookahead == ' ')
s->lookahead == ' ')) return (lex_advance(506, lexer, s));
return (lex_skip(191, lexer, s)); if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(194, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s141(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s141(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(8, lexer, s)); return (lex_skip(7, lexer, s));
if (s->lookahead == ' ') if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
return (lex_advance(511, lexer, s)); s->lookahead == ' '))
if ((s->lookahead >= '\t' && s->lookahead <= '\f')) return (lex_skip(194, lexer, s));
return (lex_skip(192, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -41,24 +41,24 @@ bool lex_normal_s142(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(8, lexer, s)); return (lex_skip(8, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (s->lookahead == ' ')
s->lookahead == ' ')) return (lex_advance(507, lexer, s));
return (lex_skip(192, lexer, s)); if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(195, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s143(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s143(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(9, lexer, s)); return (lex_skip(8, lexer, s));
if (s->lookahead == ' ') if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
return (lex_advance(513, lexer, s)); s->lookahead == ' '))
if ((s->lookahead >= '\t' && s->lookahead <= '\f')) return (lex_skip(195, lexer, s));
return (lex_skip(201, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -66,10 +66,11 @@ bool lex_normal_s144(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(9, lexer, s)); return (lex_skip(9, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (s->lookahead == ' ')
s->lookahead == ' ')) return (lex_advance(509, lexer, s));
return (lex_skip(201, lexer, s)); if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(204, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }

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

@ -15,13 +15,12 @@
bool lex_normal_s145(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s145(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(32, lexer, s)); return (lex_skip(9, lexer, s));
if (s->lookahead == ' ') if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
return (lex_advance(486, lexer, s)); s->lookahead == ' '))
if ((s->lookahead >= '\t' && s->lookahead <= '\f')) return (lex_skip(204, lexer, s));
return (lex_skip(104, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -29,24 +28,24 @@ bool lex_normal_s146(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(32, lexer, s)); return (lex_skip(32, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (s->lookahead == ' ')
s->lookahead == ' ')) return (lex_advance(482, lexer, s));
return (lex_skip(104, lexer, s)); if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(105, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s147(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s147(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(33, lexer, s)); return (lex_skip(32, lexer, s));
if (s->lookahead == ' ') if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
return (lex_advance(487, lexer, s)); s->lookahead == ' '))
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(105, lexer, s)); return (lex_skip(105, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -54,23 +53,23 @@ bool lex_normal_s148(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(33, lexer, s)); return (lex_skip(33, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (s->lookahead == ' ')
s->lookahead == ' ')) return (lex_advance(483, lexer, s));
return (lex_skip(105, lexer, s)); if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(106, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s149(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s149(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(43, lexer, s)); return (lex_skip(33, lexer, s));
if (s->lookahead == ' ') if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
return (lex_advance(491, lexer, s)); s->lookahead == ' '))
if ((s->lookahead >= '\t' && s->lookahead <= '\f')) return (lex_skip(106, lexer, s));
return (lex_skip(110, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }

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

@ -15,7 +15,7 @@
bool lex_normal_s15(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s15(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(474, lexer, s)); return (lex_advance(470, lexer, s));
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_advance(14, lexer, s)); return (lex_advance(14, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
@ -24,47 +24,47 @@ bool lex_normal_s15(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s16(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s16(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(474, lexer, s)); return (lex_advance(470, lexer, s));
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_advance(14, lexer, s)); return (lex_advance(14, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '\t' && \ if ((s->lookahead != 0 && (s->lookahead > '\t' && \
s->lookahead < '\r'))) s->lookahead < '\r')))
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s17(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s17(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(452, lexer, s)); return (lex_advance(449, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s18(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s18(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(452, lexer, s)); return (lex_advance(449, lexer, s));
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_advance(17, lexer, s)); return (lex_advance(17, lexer, s));
if (s->lookahead == ' ') if (s->lookahead == ' ')
return (lex_advance(485, lexer, s)); return (lex_advance(484, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f')) if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(94, lexer, s)); return (lex_skip(107, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s19(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s19(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\n') if (s->lookahead == '\n')
return (lex_advance(452, lexer, s)); return (lex_advance(449, lexer, s));
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_advance(17, lexer, s)); return (lex_advance(17, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' ')) s->lookahead == ' '))
return (lex_skip(94, lexer, s)); return (lex_skip(107, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }

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

@ -15,50 +15,50 @@
bool lex_normal_s150(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s150(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(43, lexer, s)); return (lex_skip(46, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (s->lookahead == ' ')
s->lookahead == ' ')) return (lex_advance(487, lexer, s));
return (lex_skip(110, lexer, s)); if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(111, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s151(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s151(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(47, lexer, s)); return (lex_skip(46, lexer, s));
if (s->lookahead == ' ') if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
return (lex_advance(514, lexer, s)); s->lookahead == ' '))
if ((s->lookahead >= '\t' && s->lookahead <= '\f')) return (lex_skip(111, lexer, s));
return (lex_skip(202, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s152(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s152(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(47, lexer, s)); return (lex_skip(96, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (s->lookahead == ' ')
s->lookahead == ' ')) return (lex_advance(490, lexer, s));
return (lex_skip(202, lexer, s)); if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(115, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s153(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s153(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(95, lexer, s)); return (lex_skip(96, lexer, s));
if (s->lookahead == ' ') if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
return (lex_advance(490, lexer, s)); s->lookahead == ' '))
if ((s->lookahead >= '\t' && s->lookahead <= '\f')) return (lex_skip(115, lexer, s));
return (lex_skip(109, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -66,10 +66,11 @@ bool lex_normal_s154(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(95, lexer, s)); return (lex_skip(95, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (s->lookahead == ' ')
s->lookahead == ' ')) return (lex_advance(486, lexer, s));
return (lex_skip(109, lexer, s)); if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(110, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }

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

@ -15,59 +15,59 @@
bool lex_normal_s155(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s155(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(96, lexer, s)); return (lex_skip(95, lexer, s));
if (s->lookahead == ' ') if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
return (lex_advance(494, lexer, s)); s->lookahead == ' '))
if ((s->lookahead >= '\t' && s->lookahead <= '\f')) return (lex_skip(110, lexer, s));
return (lex_skip(114, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s156(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s156(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(96, lexer, s)); return (lex_skip(47, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (s->lookahead == ' ')
s->lookahead == ' ')) return (lex_advance(510, lexer, s));
return (lex_skip(114, lexer, s)); if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(205, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s157(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s157(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(48, lexer, s)); return (lex_skip(47, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' ')) s->lookahead == ' '))
return (lex_skip(193, lexer, s)); return (lex_skip(205, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s158(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s158(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(61, lexer, s)); return (lex_skip(48, lexer, s));
if (s->lookahead == ' ') if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
return (lex_advance(512, lexer, s)); s->lookahead == ' '))
if ((s->lookahead >= '\t' && s->lookahead <= '\f')) return (lex_skip(196, lexer, s));
return (lex_skip(188, lexer, s));
if (s->lookahead != 0)
return (lex_advance(533, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s159(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s159(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(61, lexer, s)); return (lex_skip(58, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (s->lookahead == ' ')
s->lookahead == ' ')) return (lex_advance(508, lexer, s));
return (lex_skip(188, lexer, s)); if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(191, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }

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

@ -15,13 +15,12 @@
bool lex_normal_s160(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s160(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(100, lexer, s)); return (lex_skip(58, lexer, s));
if (s->lookahead == ' ') if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
return (lex_advance(515, lexer, s)); s->lookahead == ' '))
if ((s->lookahead >= '\t' && s->lookahead <= '\f')) return (lex_skip(191, lexer, s));
return (lex_skip(203, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -29,21 +28,24 @@ bool lex_normal_s161(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(100, lexer, s)); return (lex_skip(100, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (s->lookahead == ' ')
s->lookahead == ' ')) return (lex_advance(511, lexer, s));
return (lex_skip(203, lexer, s)); if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(206, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s162(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s162(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(62, lexer, s)); return (lex_skip(100, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' ')) s->lookahead == ' '))
return (lex_skip(195, lexer, s)); return (lex_skip(206, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -51,23 +53,21 @@ bool lex_normal_s163(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(67, lexer, s)); return (lex_skip(67, lexer, s));
if (s->lookahead == ' ') if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
return (lex_advance(493, lexer, s)); s->lookahead == ' '))
if ((s->lookahead >= '\t' && s->lookahead <= '\f')) return (lex_skip(198, lexer, s));
return (lex_skip(113, lexer, s));
if (s->lookahead != 0)
return (lex_advance(533, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s164(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s164(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(67, lexer, s)); return (lex_skip(68, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (s->lookahead == ' ')
s->lookahead == ' ')) return (lex_advance(489, lexer, s));
return (lex_skip(113, lexer, s)); if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(114, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }

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

@ -15,13 +15,12 @@
bool lex_normal_s165(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s165(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(72, lexer, s)); return (lex_skip(68, lexer, s));
if (s->lookahead == ' ') if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
return (lex_advance(516, lexer, s)); s->lookahead == ' '))
if ((s->lookahead >= '\t' && s->lookahead <= '\f')) return (lex_skip(114, lexer, s));
return (lex_skip(204, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -29,45 +28,48 @@ bool lex_normal_s166(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(72, lexer, s)); return (lex_skip(72, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (s->lookahead == ' ')
s->lookahead == ' ')) return (lex_advance(512, lexer, s));
return (lex_skip(204, lexer, s)); if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(207, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s167(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s167(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(73, lexer, s)); return (lex_skip(72, lexer, s));
if (s->lookahead == ' ') if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
return (lex_advance(496, lexer, s)); s->lookahead == ' '))
if ((s->lookahead >= '\t' && s->lookahead <= '\f')) return (lex_skip(207, lexer, s));
return (lex_skip(117, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s168(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s168(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(73, lexer, s)); return (lex_skip(76, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (s->lookahead == ' ')
s->lookahead == ' ')) return (lex_advance(492, lexer, s));
return (lex_skip(117, lexer, s)); if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(118, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s169(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s169(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(77, lexer, s)); return (lex_skip(76, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' ')) s->lookahead == ' '))
return (lex_skip(213, lexer, s)); return (lex_skip(118, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }

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

@ -15,13 +15,10 @@
bool lex_normal_s170(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s170(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(78, lexer, s)); return (lex_skip(77, lexer, s));
if (s->lookahead == ' ') if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
return (lex_advance(517, lexer, s)); s->lookahead == ' '))
if ((s->lookahead >= '\t' && s->lookahead <= '\f')) return (lex_skip(217, lexer, s));
return (lex_skip(209, lexer, s));
if (s->lookahead != 0)
return (lex_advance(533, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
@ -29,45 +26,48 @@ bool lex_normal_s171(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(78, lexer, s)); return (lex_skip(78, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (s->lookahead == ' ')
s->lookahead == ' ')) return (lex_advance(513, lexer, s));
return (lex_skip(209, lexer, s)); if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(212, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s172(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s172(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(103, lexer, s)); return (lex_skip(78, lexer, s));
if (s->lookahead == ' ') if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
return (lex_advance(498, lexer, s)); s->lookahead == ' '))
if ((s->lookahead >= '\t' && s->lookahead <= '\f')) return (lex_skip(212, lexer, s));
return (lex_skip(120, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s173(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s173(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(103, lexer, s)); return (lex_skip(104, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (s->lookahead == ' ')
s->lookahead == ' ')) return (lex_advance(514, lexer, s));
return (lex_skip(120, lexer, s)); if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(213, lexer, s));
if (s->lookahead != 0) if (s->lookahead != 0)
return (lex_advance(533, lexer, s)); return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }
bool lex_normal_s174(t_lexer *lexer, t_lexer_state *s) bool lex_normal_s174(t_lexer *lexer, t_lexer_state *s)
{ {
if (s->lookahead == '\r') if (s->lookahead == '\r')
return (lex_skip(81, lexer, s)); return (lex_skip(104, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \ if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' ')) s->lookahead == ' '))
return (lex_skip(212, lexer, s)); return (lex_skip(213, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s)); return (lex_end_state(lexer, s));
} }

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