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));