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

Updated parser

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -27,21 +27,21 @@ bool lex_normal_s90(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s91(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(208, lexer, s));
return (lex_skip(67, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s92(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(211, lexer, s));
return (lex_skip(208, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s93(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(66, lexer, s));
return (lex_skip(211, lexer, s));
return (lex_end_state(lexer, s));
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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