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

Updated syntax with a simpler one

Browse source
This commit is contained in:
Maieul BOYER 2024-06-06 19:43:58 +02:00
parent 38fa2d2e84
commit aeb576024f
No known key found for this signature in database
4465 changed files with 195554 additions and 526060 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -22,13 +22,13 @@
static inline bool lex_normal_map0(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 820, '"', 788, '#', 825, \
'$', 781, '%', 647, '&', 601, '\'', 491, '(', 654, ')', \
655, '*', 824, '+', 770, ',', 557, '-', 768, '.', 949, \
'/', 642, '0', 944, ':', 763, ';', 554, '<', 607, '=', \
827, '>', 616, '?', 837, '@', 822, '[', 674, '\\', 301, \
']', 675, '^', 595, '_', 946, '`', 856, 'e', 956, 'i', \
955, '{', 666, '|', 592, '}', 778, '~', 772};
static uint32_t map[] = {'!', 248, '"', 373, '#', 396, \
'$', 370, '%', 351, '&', 335, '\'', 201, '(', 232, ')', \
237, '*', 346, '+', 363, ',', 311, '-', 361, '.', 475, \
'/', 349, '0', 470, ':', 357, ';', 483, '<', 253, '=', \
404, '>', 256, '?', 408, '@', 468, '[', 372, '\\', 133, \
']', 485, '^', 331, '_', 472, '`', 417, 'e', 480, 'i', \
479, '{', 242, '|', 234, '}', 316, '~', 365};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
@ -37,50 +37,52 @@ static inline bool lex_normal_map0(t_lexer *lexer, \
static inline bool lex_normal_map6(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 688, '!', 670, '"', 788, \
'#', 862, '$', 781, '%', 649, '&', 601, '\'', 491, '(', \
654, ')', 655, '*', 638, '+', 771, '-', 769, '/', 644, \
'0', 803, ';', 555, '<', 607, '=', 560, '>', 616, '?', \
761, '\\', 307, '^', 596, '`', 856, '|', 592, '~', 772, \
'[', 786, ']', 786, '{', 786, '}', 786};
static uint32_t map[] = {'\n', 272, '"', 373, '#', 421, \
'$', 370, '&', 336, '\'', 201, '(', 232, '-', 476, '0', \
385, ';', 483, '<', 254, '>', 257, '\\', 139, '`', 416, \
'e', 480, '|', 235, '[', 372, ']', 372, '{', 372, '}', \
372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map12(t_lexer *lexer, \
static inline bool lex_normal_map80(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 689, '!', 670, '"', 788, \
'#', 816, '$', 781, '%', 649, '&', 601, '\'', 491, '(', \
654, ')', 655, '*', 638, '+', 630, '-', 633, '/', 644, \
'0', 943, ';', 555, '<', 607, '=', 560, '>', 616, '?', \
761, '@', 942, '\\', 14, '^', 596, '_', 947, '`', 855, \
'|', 592, '[', 786, ']', 786, '{', 786, '}', 786};
static uint32_t map[] = {'\n', 274, '!', 248, '"', 373, \
'#', 396, '$', 370, '&', 336, '\'', 201, '(', 232, '*', \
348, '-', 344, '0', 469, ';', 483, '<', 254, '>', 257, \
'?', 355, '@', 468, '\\', 9, '_', 473, '`', 416, 'e', 430, \
'|', 235, '[', 372, ']', 372, '{', 372, '}', 372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map83(t_lexer *lexer, \
static inline bool lex_normal_map99(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 690, '!', 506, '#', 862, \
'%', 650, '&', 600, '*', 639, '+', 631, ',', 556, '-', \
635, '/', 645, ';', 553, '<', 615, '=', 561, '>', 620};
static uint32_t map[] = {'\n', 275, '!', 248, '"', 373, \
'#', 396, '$', 370, '&', 336, '\'', 201, '(', 232, '*', \
348, '-', 344, '0', 469, ';', 483, '<', 254, '>', 257, \
'?', 355, '@', 468, '\\', 14, '_', 473, '`', 416, '|', \
235, '[', 372, ']', 372, '{', 372, '}', 372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map84(t_lexer *lexer, \
static inline bool lex_normal_map100(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 690, '"', 788, '#', 862, \
'$', 785, '&', 599, '(', 653, '+', 500, ',', 556, '-', \
502, '0', 809, ';', 553};
static uint32_t map[] = {'\n', 276, '!', 248, '"', 373, \
'#', 396, '$', 370, '&', 336, '\'', 201, '*', 348, '-', \
344, '0', 469, ';', 483, '<', 254, '>', 257, '?', 355, \
'@', 468, '\\', 16, '_', 473, '`', 416, 'e', 430, '|', \
235, '[', 372, ']', 372, '{', 372, '}', 372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif
#endif // INLINE_IMPL0_H

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

@ -19,68 +19,68 @@
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map85(t_lexer *lexer, \
static inline bool lex_normal_map101(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 690, '#', 862, '$', 783, \
'&', 489, '(', 654, '-', 504, '0', 808, ':', 762, '<', \
611, '>', 618};
static uint32_t map[] = {'\n', 277, '!', 248, '"', 373, \
'#', 396, '$', 370, '&', 336, '\'', 201, '(', 232, ')', \
237, '*', 348, '-', 344, '0', 469, ';', 484, '<', 254, \
'>', 257, '?', 355, '@', 468, '\\', 22, '_', 473, '`', \
416, '|', 235, '[', 372, ']', 372, '{', 372, '}', 372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map146(t_lexer *lexer, \
static inline bool lex_normal_map102(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 691, '!', 951, '"', 788, \
'#', 862, '$', 781, '%', 649, '&', 601, '\'', 491, '(', \
654, ')', 655, '*', 638, '+', 630, '-', 633, '/', 644, \
'0', 803, ';', 555, '<', 607, '=', 560, '>', 616, '?', \
761, '\\', 316, '^', 596, '`', 856, '|', 592, '[', 786, \
']', 786, '{', 786, '}', 786};
static uint32_t map[] = {'\n', 278, '!', 248, '"', 373, \
'#', 396, '$', 370, '&', 336, '\'', 201, '(', 232, '*', \
348, '-', 344, '0', 469, ';', 484, '<', 254, '>', 257, \
'?', 355, '@', 468, '\\', 83, '_', 473, '`', 416, '|', \
235, '[', 372, ']', 372, '{', 372, '}', 372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map200(t_lexer *lexer, \
static inline bool lex_normal_map103(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 692, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
945, ';', 554, '<', 612, '>', 618, '?', 760, '@', 941, \
'\\', 81, '_', 948, 'e', 877, '|', 593};
static uint32_t map[] = {'\n', 279, '!', 248, '"', 373, \
'#', 396, '$', 370, '&', 336, '\'', 201, '*', 348, '-', \
344, '0', 469, ';', 483, '<', 254, '>', 257, '?', 355, \
'@', 468, '\\', 24, '_', 473, '`', 416, '|', 235, '[', \
372, ']', 372, '{', 372, '}', 372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map219(t_lexer *lexer, \
static inline bool lex_normal_map104(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 693, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 654, '*', \
640, '-', 636, '0', 943, ';', 554, '<', 609, '=', 952, \
'>', 617, '?', 761, '@', 942, '\\', 27, '_', 947, '`', \
855, 'e', 871, '|', 593, '[', 786, ']', 786, '{', 786, \
'}', 786};
static uint32_t map[] = {'\n', 280, '!', 248, '"', 373, \
'#', 396, '$', 370, '&', 336, '\'', 201, ')', 237, '*', \
348, '-', 344, '0', 469, ';', 484, '<', 254, '>', 257, \
'?', 355, '@', 468, '\\', 26, '_', 473, '`', 416, '|', \
235, '[', 372, ']', 372, '{', 372, '}', 372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map236(t_lexer *lexer, \
static inline bool lex_normal_map105(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 694, '!', 951, '"', 788, \
'#', 862, '$', 781, '%', 649, '&', 601, '\'', 491, '(', \
654, ')', 655, '*', 638, '+', 630, '-', 633, '/', 644, \
'0', 803, ';', 555, '<', 607, '=', 560, '>', 616, '?', \
761, '\\', 317, '^', 596, '`', 855, '|', 592, '[', 786, \
']', 786, '{', 786, '}', 786};
static uint32_t map[] = {'\n', 281, '!', 248, '"', 373, \
'#', 396, '$', 370, '&', 336, '\'', 201, '*', 348, '-', \
344, '0', 469, ';', 484, '<', 254, '>', 257, '?', 355, \
'@', 468, '\\', 89, '_', 473, '`', 416, '|', 235, '[', \
372, ']', 372, '{', 372, '}', 372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif
#endif // INLINE_IMPL1_H

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

@ -19,68 +19,61 @@
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map277(t_lexer *lexer, \
static inline bool lex_normal_map183(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 735, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 654, '-', 950, '0', \
803, ';', 554, '<', 609, '=', 952, '>', 617, '\\', 335, \
'`', 856, 'e', 956, '|', 593, '[', 786, ']', 786, '{', \
786, '}', 786};
static uint32_t map[] = {'!', 247, '#', 396, '$', 369, \
'*', 345, '-', 342, '0', 471, '?', 354, '@', 467, '\\', \
75, '_', 474};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map278(t_lexer *lexer, \
static inline bool lex_normal_map184(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 736, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, ')', \
655, '*', 640, '-', 636, '0', 943, ';', 555, '<', 610, \
'>', 617, '?', 761, '@', 942, '\\', 228, '_', 947, '`', \
855, '|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
static uint32_t map[] = {'!', 205, '#', 421, '$', 371, \
'%', 353, '&', 334, ')', 202, '*', 347, '+', 341, ',', \
310, '-', 343, '.', 204, '/', 350, ':', 356, ';', 200, \
'<', 255, '=', 250, '>', 258, '?', 354};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map279(t_lexer *lexer, \
static inline bool lex_normal_map185(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 737, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 654, '-', 950, '0', \
803, ';', 554, '<', 609, '=', 952, '>', 617, '\\', 337, \
'`', 856, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
786};
static uint32_t map[] = {'!', 205, '#', 421, '$', 371, \
'%', 353, '&', 334, ')', 202, '*', 347, '+', 341, ',', \
310, '-', 343, '/', 350, ':', 356, ';', 200, '<', 255, \
'=', 250, '>', 258, '?', 354};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map280(t_lexer *lexer, \
static inline bool lex_normal_map186(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 738, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, ';', 555, '<', 610, '>', 617, \
'?', 761, '@', 942, '\\', 207, '_', 947, '`', 855, '|', \
593, '[', 786, ']', 786, '{', 786, '}', 786};
static uint32_t map[] = {'!', 205, '#', 421, '%', 353, \
'&', 334, ')', 237, '*', 347, '+', 341, '-', 343, '/', \
350, '<', 255, '=', 250, '>', 258, '?', 354};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map281(t_lexer *lexer, \
static inline bool lex_normal_map187(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 739, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 654, ')', 655, '-', \
950, '0', 803, ';', 555, '<', 609, '=', 952, '>', 617, \
'\\', 339, '`', 856, '|', 593, '[', 786, ']', 786, '{', \
786, '}', 786};
static uint32_t map[] = {'"', 373, '#', 421, '$', 370, \
'&', 199, '\'', 201, '(', 232, '-', 476, '0', 385, '<', \
254, '>', 257, '\\', 145, '`', 416, '|', 235, '[', 372, \
']', 372, '{', 372, '}', 372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif
#endif // INLINE_IMPL10_H

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

@ -19,68 +19,62 @@
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map282(t_lexer *lexer, \
static inline bool lex_normal_map188(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 740, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 489, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, '<', 609, '=', 952, '>', 617, \
'?', 761, '@', 942, '\\', 168, '_', 947, '`', 855, '|', \
593, '[', 786, ']', 786, '{', 786, '}', 786};
static uint32_t map[] = {'"', 373, '#', 421, '$', 370, \
'&', 199, '\'', 201, '(', 232, '-', 476, '0', 385, '<', \
254, '>', 257, '\\', 153, '`', 417, '|', 235, '[', 372, \
']', 372, '{', 372, '}', 372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map283(t_lexer *lexer, \
static inline bool lex_normal_map189(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 741, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
804, ';', 554, '<', 610, '>', 617, '\\', 341, '`', 856, \
'e', 866, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
786};
static uint32_t map[] = {'"', 373, '#', 421, '$', 370, \
'&', 199, '\'', 201, '-', 476, '0', 386, '<', 254, '>', \
257, '\\', 146, '`', 416, '|', 235, '[', 372, ']', 372, \
'{', 372, '}', 372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map284(t_lexer *lexer, \
static inline bool lex_normal_map190(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 742, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 489, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, '<', 609, '>', 617, '?', 761, \
'@', 942, '\\', 58, '_', 947, '`', 855, '|', 593, '[', \
786, ']', 786, '{', 786, '}', 786};
static uint32_t map[] = {'"', 373, '#', 421, '$', 370, \
'&', 199, '\'', 201, '-', 476, '0', 386, '<', 254, '>', \
257, '\\', 154, '`', 417, '|', 235, '[', 372, ']', 372, \
'{', 372, '}', 372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map285(t_lexer *lexer, \
static inline bool lex_normal_map191(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 743, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
803, ';', 554, '<', 609, '>', 617, '\\', 343, '`', 856, \
'e', 956, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
786};
static uint32_t map[] = {'"', 373, '#', 421, '$', 370, \
'\'', 201, '(', 232, ')', 237, '-', 476, '0', 385, '\\', \
158, '`', 416, 'e', 480, '|', 233, '[', 372, ']', 372, \
'{', 372, '}', 372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map286(t_lexer *lexer, \
static inline bool lex_normal_map192(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 744, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 489, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, '<', 610, '>', 617, '?', 761, \
'@', 942, '\\', 233, '_', 947, '`', 855, '|', 593, '[', \
786, ']', 786, '{', 786, '}', 786};
static uint32_t map[] = {'"', 373, '#', 421, '$', 371, \
'\'', 201, '(', 232, '\\', 164, '`', 416, '{', 242, '}', \
398};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif
#endif // INLINE_IMPL11_H

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

@ -19,66 +19,64 @@
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map287(t_lexer *lexer, \
static inline bool lex_normal_map194(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 745, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
804, ';', 554, '<', 610, '>', 617, '\\', 344, '`', 856, \
'|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
static uint32_t map[] = {'"', 373, '#', 422, '$', 370, \
'\'', 201, '-', 476, '0', 385, '\\', 162, '`', 416, '[', \
372, ']', 372, '{', 372, '}', 372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map288(t_lexer *lexer, \
static inline bool lex_normal_map214(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 746, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 489, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, '<', 608, '>', 617, '?', 761, \
'@', 942, '\\', 176, '_', 947, '`', 855, '|', 516, '[', \
786, ']', 786, '{', 786, '}', 786};
static uint32_t map[] = {'\n', 278, '!', 248, '"', 373, \
'#', 396, '$', 370, '&', 336, '\'', 201, '(', 232, '*', \
348, '-', 344, '0', 469, ';', 484, '<', 254, '>', 257, \
'?', 355, '@', 468, '\\', 83, '_', 473, '`', 416, '|', \
235, '[', 372, ']', 372, '{', 372, '}', 372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map289(t_lexer *lexer, \
static inline bool lex_normal_map215(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 747, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
803, ';', 554, '<', 609, '>', 617, '\\', 346, '`', 856, \
'|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
static uint32_t map[] = {'\n', 281, '!', 248, '"', 373, \
'#', 396, '$', 370, '&', 336, '\'', 201, '*', 348, '-', \
344, '0', 469, ';', 484, '<', 254, '>', 257, '?', 355, \
'@', 468, '\\', 89, '_', 473, '`', 416, '|', 235, '[', \
372, ']', 372, '{', 372, '}', 372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map290(t_lexer *lexer, \
static inline bool lex_normal_map216(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 748, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 599, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, ';', 555, '<', 495, '>', 496, \
'?', 761, '@', 942, '\\', 100, '_', 947, '`', 855, '[', \
786, ']', 786, '{', 786, '}', 786};
static uint32_t map[] = {'\n', 288, '!', 247, '#', 396, \
'$', 369, '&', 336, '*', 345, '-', 342, '0', 471, ';', \
484, '<', 254, '>', 257, '?', 354, '@', 467, '\\', 95, \
'_', 474, '|', 235};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map291(t_lexer *lexer, \
static inline bool lex_normal_map217(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 749, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
803, ';', 554, '<', 610, '>', 617, '\\', 347, '`', 856, \
'e', 956, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
786};
static uint32_t map[] = {'\n', 298, '"', 373, '#', 421, \
'$', 370, '&', 336, '\'', 201, ')', 237, '-', 476, '0', \
386, ';', 484, '<', 254, '>', 257, '\\', 143, '`', 416, \
'|', 235, '[', 372, ']', 372, '{', 372, '}', 372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif
#endif // INLINE_IMPL12_H

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

@ -19,67 +19,69 @@
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map292(t_lexer *lexer, \
static inline bool lex_normal_map218(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 750, '!', 672, '"', 788, \
'#', 816, '$', 781, '\'', 491, '(', 494, '*', 640, '-', \
636, '0', 943, '<', 495, '>', 496, '?', 761, '@', 942, \
'\\', 112, '_', 947, '`', 855, '[', 786, ']', 786, '{', \
786, '}', 786};
static uint32_t map[] = {'\n', 299, '"', 373, '#', 421, \
'$', 370, '&', 336, '\'', 201, '(', 232, ')', 237, '-', \
476, '0', 385, ';', 484, '<', 254, '>', 257, '\\', 144, \
'`', 416, '|', 235, '[', 372, ']', 372, '{', 372, '}', \
372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map293(t_lexer *lexer, \
static inline bool lex_normal_map219(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 751, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, ')', 655, '-', \
950, '0', 804, ';', 555, '<', 610, '>', 617, '\\', 349, \
'`', 856, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
786};
static uint32_t map[] = {'\n', 304, '"', 373, '#', 421, \
'$', 370, '&', 336, '\'', 201, ')', 237, '-', 476, '0', \
386, ';', 484, '<', 254, '>', 257, '\\', 151, '`', 417, \
'|', 235, '[', 372, ']', 372, '{', 372, '}', 372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map294(t_lexer *lexer, \
static inline bool lex_normal_map220(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 752, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, ')', 655, '-', \
950, '0', 803, ';', 555, '<', 609, '>', 617, '\\', 350, \
'`', 856, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
786};
static uint32_t map[] = {'\n', 305, '"', 373, '#', 421, \
'$', 370, '&', 336, '\'', 201, '(', 232, ')', 237, '-', \
476, '0', 385, ';', 484, '<', 254, '>', 257, '\\', 152, \
'`', 417, '|', 235, '[', 372, ']', 372, '{', 372, '}', \
372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map295(t_lexer *lexer, \
static inline bool lex_normal_map221(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 753, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
803, ';', 554, '<', 610, '>', 617, '\\', 351, '`', 856, \
'|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
static uint32_t map[] = {'!', 248, '"', 373, '#', 396, \
'$', 370, '%', 351, '&', 335, '\'', 201, '(', 232, ')', \
237, '*', 346, '+', 363, ',', 311, '-', 361, '/', 349, \
'0', 470, ':', 358, ';', 483, '<', 253, '=', 251, '>', \
256, '?', 355, '@', 468, '[', 372, '\\', 133, ']', 485, \
'^', 331, '_', 472, '`', 417, 'e', 480, 'i', 479, '{', \
242, '|', 234, '}', 398, '~', 365};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map296(t_lexer *lexer, \
static inline bool lex_normal_map222(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 754, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, ')', 655, '-', \
950, '0', 803, ';', 555, '<', 610, '>', 617, '\\', 354, \
'`', 856, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
786};
static uint32_t map[] = {'!', 248, '"', 373, '#', 421, \
'$', 370, '&', 199, '\'', 201, '(', 232, ')', 237, '-', \
476, '0', 385, ';', 200, '<', 254, '>', 257, '\\', 135, \
'`', 416, '{', 242, '|', 235, '[', 372, ']', 372, '}', \
372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif
#endif // INLINE_IMPL13_H

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

@ -19,66 +19,64 @@
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map297(t_lexer *lexer, \
static inline bool lex_normal_map378(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 755, '"', 788, '#', 862, \
'$', 781, '&', 599, '\'', 491, '(', 654, '-', 950, '0', \
803, ';', 555, '<', 495, '>', 496, '\\', 357, '`', 855, \
'e', 956, '[', 786, ']', 786, '{', 786, '}', 786};
static uint32_t map[] = {'!', 247, '"', 373, '#', 396, \
'$', 369, '*', 345, '-', 342, '0', 471, '?', 354, '@', \
467, '\\', 69, '_', 474};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map298(t_lexer *lexer, \
static inline bool lex_normal_map379(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 756, '"', 788, '#', 862, \
'$', 781, '&', 489, '\'', 491, '(', 494, '-', 950, '0', \
803, '<', 608, '>', 617, '\\', 370, '`', 856, '|', 516, \
'[', 786, ']', 786, '{', 786, '}', 786};
static uint32_t map[] = {'!', 247, '#', 396, '$', 369, \
'*', 345, '-', 342, '0', 471, '?', 354, '@', 467, '\\', \
73, '_', 474};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map299(t_lexer *lexer, \
static inline bool lex_normal_map439(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 757, '"', 788, '#', 862, \
'$', 781, '&', 599, '\'', 491, '(', 494, '-', 950, '0', \
803, ';', 555, '<', 495, '>', 496, '\\', 372, '`', 855, \
'[', 786, ']', 786, '{', 786, '}', 786};
static uint32_t map[] = {'\n', 274, '!', 248, '"', 373, \
'#', 396, '$', 370, '&', 336, '\'', 201, '(', 232, '*', \
348, '-', 344, '0', 469, ';', 483, '<', 254, '>', 257, \
'?', 355, '@', 468, '\\', 9, '_', 473, '`', 416, 'e', 430, \
'|', 235};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map300(t_lexer *lexer, \
static inline bool lex_normal_map440(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 758, '"', 788, '#', 862, \
'$', 781, '&', 599, '\'', 491, '(', 494, '-', 950, '0', \
803, ';', 555, '<', 495, '>', 496, '\\', 381, '`', 856, \
'[', 786, ']', 786, '{', 786, '}', 786};
static uint32_t map[] = {'\n', 275, '!', 248, '"', 373, \
'#', 396, '$', 370, '&', 336, '\'', 201, '(', 232, '*', \
348, '-', 344, '0', 469, ';', 483, '<', 254, '>', 257, \
'?', 355, '@', 468, '\\', 14, '_', 473, '`', 416, '|', \
235};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map401(t_lexer *lexer, \
static inline bool lex_normal_map441(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 670, '"', 788, '#', 816, \
'$', 781, '%', 647, '&', 601, '\'', 491, '(', 654, ')', \
655, '*', 638, '+', 770, ',', 557, '-', 768, '/', 642, \
'0', 944, ':', 765, ';', 554, '<', 607, '=', 563, '>', \
616, '?', 761, '@', 942, '[', 674, '\\', 301, ']', 675, \
'^', 595, '_', 946, '`', 856, 'e', 956, 'i', 955, '{', \
666, '|', 592, '}', 818, '~', 772};
static uint32_t map[] = {'\n', 276, '!', 248, '"', 373, \
'#', 396, '$', 370, '&', 336, '\'', 201, '*', 348, '-', \
344, '0', 469, ';', 483, '<', 254, '>', 257, '?', 355, \
'@', 468, '\\', 16, '_', 473, '`', 416, 'e', 430, '|', \
235};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif
#endif // INLINE_IMPL14_H

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

@ -19,73 +19,66 @@
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map402(t_lexer *lexer, \
static inline bool lex_normal_map442(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 670, '"', 788, '#', 816, \
'$', 781, '%', 649, '&', 601, '\'', 491, '(', 654, '*', \
638, '+', 630, '-', 633, '/', 644, '0', 943, '<', 607, \
'=', 560, '>', 616, '?', 761, '@', 942, '\\', 19, ']', \
675, '^', 596, '_', 947, '`', 855, '|', 592, '[', 786, \
'{', 786, '}', 786};
static uint32_t map[] = {'\n', 277, '!', 248, '"', 373, \
'#', 396, '$', 370, '&', 336, '\'', 201, '(', 232, ')', \
237, '*', 348, '-', 344, '0', 469, ';', 484, '<', 254, \
'>', 257, '?', 355, '@', 468, '\\', 22, '_', 473, '`', \
416, '|', 235};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map403(t_lexer *lexer, \
static inline bool lex_normal_map443(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 670, '"', 788, '#', 862, \
'$', 781, '%', 649, '&', 601, '\'', 491, '(', 654, '*', \
638, '+', 771, '-', 769, '/', 644, '0', 803, '<', 607, \
'=', 560, '>', 616, '?', 761, '\\', 308, ']', 675, '^', \
596, '`', 856, '|', 592, '~', 772, '[', 786, '{', 786, \
'}', 786};
static uint32_t map[] = {'\n', 278, '!', 248, '"', 373, \
'#', 396, '$', 370, '&', 336, '\'', 201, '(', 232, '*', \
348, '-', 344, '0', 469, ';', 484, '<', 254, '>', 257, \
'?', 355, '@', 468, '\\', 83, '_', 473, '`', 416, '|', \
235};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map404(t_lexer *lexer, \
static inline bool lex_normal_map444(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 670, '"', 788, '#', 862, \
'$', 781, '%', 649, '&', 600, '\'', 491, '(', 654, ')', \
655, '*', 638, '+', 771, '-', 769, '/', 644, '0', 803, \
'<', 614, '=', 560, '>', 619, '?', 761, '\\', 311, '^', \
596, '`', 856, '|', 594, '~', 772, '[', 786, ']', 786, \
'{', 786, '}', 786};
static uint32_t map[] = {'\n', 279, '!', 248, '"', 373, \
'#', 396, '$', 370, '&', 336, '\'', 201, '*', 348, '-', \
344, '0', 469, ';', 483, '<', 254, '>', 257, '?', 355, \
'@', 468, '\\', 24, '_', 473, '`', 416, '|', 235};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map405(t_lexer *lexer, \
static inline bool lex_normal_map445(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 670, '"', 788, '#', 862, \
'$', 781, '%', 649, '&', 600, '\'', 491, '(', 654, ')', \
499, '*', 638, '+', 771, '-', 769, '/', 644, '0', 803, \
'<', 614, '=', 560, '>', 619, '?', 761, '\\', 314, '^', \
596, '`', 856, '|', 594, '~', 772, '[', 786, ']', 786, \
'{', 786, '}', 786};
static uint32_t map[] = {'\n', 280, '!', 248, '"', 373, \
'#', 396, '$', 370, '&', 336, '\'', 201, ')', 237, '*', \
348, '-', 344, '0', 469, ';', 484, '<', 254, '>', 257, \
'?', 355, '@', 468, '\\', 26, '_', 473, '`', 416, '|', \
235};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map406(t_lexer *lexer, \
static inline bool lex_normal_map446(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 670, '"', 788, '#', 862, \
'$', 781, '%', 649, '&', 600, '\'', 491, '(', 654, '*', \
638, '+', 771, '-', 769, '/', 644, '0', 803, ':', 765, \
'<', 614, '=', 560, '>', 619, '?', 761, '\\', 313, '^', \
596, '`', 856, '|', 594, '~', 772, '[', 786, ']', 786, \
'{', 786, '}', 786};
static uint32_t map[] = {'\n', 281, '!', 248, '"', 373, \
'#', 396, '$', 370, '&', 336, '\'', 201, '*', 348, '-', \
344, '0', 469, ';', 484, '<', 254, '>', 257, '?', 355, \
'@', 468, '\\', 89, '_', 473, '`', 416, '|', 235};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif
#endif // INLINE_IMPL15_H

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

@ -19,70 +19,63 @@
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map407(t_lexer *lexer, \
static inline bool lex_normal_map447(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 670, '"', 788, '#', 862, \
'$', 781, '%', 649, '&', 600, '\'', 491, '(', 654, '*', \
638, '+', 771, '-', 769, '/', 644, '0', 803, '<', 614, \
'=', 560, '>', 619, '?', 761, '\\', 312, ']', 675, '^', \
596, '`', 856, '|', 594, '~', 772, '[', 786, '{', 786, \
'}', 786};
static uint32_t map[] = {'\n', 282, '!', 248, '"', 373, \
'#', 396, '$', 370, '&', 199, '\'', 201, '(', 232, '*', \
348, '-', 344, '0', 469, '<', 254, '>', 257, '?', 355, \
'@', 468, '\\', 28, '_', 473, '`', 416, '|', 235};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map408(t_lexer *lexer, \
static inline bool lex_normal_map448(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 670, '"', 788, '#', 862, \
'$', 781, '%', 649, '&', 600, '\'', 491, '(', 654, '*', \
638, '+', 771, '-', 769, '/', 644, '0', 803, '<', 614, \
'=', 560, '>', 619, '?', 761, '\\', 315, ']', 787, '^', \
596, '`', 856, '|', 594, '~', 772, '[', 786, '{', 786, \
'}', 786};
static uint32_t map[] = {'\n', 283, '!', 248, '"', 373, \
'#', 396, '$', 370, '&', 199, '\'', 201, '*', 348, '-', \
344, '0', 469, '<', 254, '>', 257, '?', 355, '@', 468, \
'\\', 34, '_', 473, '`', 416, '|', 235};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map409(t_lexer *lexer, \
static inline bool lex_normal_map449(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
'$', 781, '&', 508, '\'', 491, '(', 494, '*', 640, '-', \
636, '0', 943, '<', 608, '>', 617, '?', 761, '@', 942, \
'\\', 74, '_', 947, '`', 855, '[', 786, ']', 786, '{', \
786, '}', 786};
static uint32_t map[] = {'\n', 284, '!', 247, '#', 396, \
'$', 369, '&', 336, '*', 345, '-', 342, '0', 471, ';', \
483, '<', 254, '>', 257, '?', 354, '@', 467, '\\', 40, \
'_', 474, 'e', 436, '|', 235};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map410(t_lexer *lexer, \
static inline bool lex_normal_map450(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
'$', 781, '&', 489, '\'', 491, '(', 654, '*', 640, '-', \
636, '0', 943, '<', 609, '=', 952, '>', 617, '?', 761, \
'@', 942, '\\', 51, '_', 947, '`', 855, '|', 593, '[', \
786, ']', 786, '{', 786, '}', 786};
static uint32_t map[] = {'\n', 285, '!', 247, '#', 396, \
'$', 369, '&', 336, '*', 345, '-', 342, '0', 471, ';', \
483, '<', 254, '>', 257, '?', 354, '@', 467, '\\', 43, \
'_', 474, '|', 235};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map411(t_lexer *lexer, \
static inline bool lex_normal_map451(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
'$', 781, '&', 489, '\'', 491, '(', 494, '*', 640, '-', \
636, '0', 943, '<', 609, '=', 952, '>', 617, '?', 761, \
'@', 942, '\\', 171, '_', 947, '`', 855, '|', 593, '[', \
786, ']', 786, '{', 786, '}', 786};
static uint32_t map[] = {'\n', 286, '!', 247, '#', 396, \
'$', 369, '&', 336, '*', 345, '-', 342, '0', 471, ';', \
484, '<', 254, '>', 257, '?', 354, '@', 467, '\\', 45, \
'_', 474, '`', 416, '|', 235};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif
#endif // INLINE_IMPL16_H

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

@ -19,68 +19,62 @@
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map412(t_lexer *lexer, \
static inline bool lex_normal_map452(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
'$', 781, '&', 489, '\'', 491, '(', 494, '*', 640, '-', \
636, '0', 943, '<', 609, '>', 617, '?', 761, '@', 942, \
'\\', 55, ']', 675, '_', 947, '`', 855, '|', 593, '[', \
786, '{', 786, '}', 786};
static uint32_t map[] = {'\n', 287, '!', 247, '#', 396, \
'$', 369, '&', 336, ')', 237, '*', 345, '-', 342, '0', \
471, ';', 484, '<', 254, '>', 257, '?', 354, '@', 467, \
'\\', 48, '_', 474, '|', 235};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map413(t_lexer *lexer, \
static inline bool lex_normal_map453(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
'$', 781, '&', 489, '\'', 491, '(', 494, '*', 640, '-', \
636, '0', 943, '<', 609, '>', 617, '?', 761, '@', 942, \
'\\', 62, '_', 947, '`', 855, '|', 593, '[', 786, ']', \
786, '{', 786, '}', 786};
static uint32_t map[] = {'\n', 288, '!', 247, '#', 396, \
'$', 369, '&', 336, '*', 345, '-', 342, '0', 471, ';', \
484, '<', 254, '>', 257, '?', 354, '@', 467, '\\', 95, \
'_', 474, '|', 235};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map414(t_lexer *lexer, \
static inline bool lex_normal_map454(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
'$', 781, '&', 489, '\'', 491, '(', 494, '*', 640, '-', \
636, '0', 943, '<', 610, '>', 617, '?', 761, '@', 942, \
'\\', 231, ']', 675, '_', 947, '`', 855, '|', 593, '[', \
786, '{', 786, '}', 786};
static uint32_t map[] = {'\n', 289, '!', 247, '#', 396, \
'$', 369, '&', 199, '*', 345, '-', 342, '0', 471, '<', \
254, '>', 257, '?', 354, '@', 467, '\\', 51, '_', 474, \
'|', 235};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map415(t_lexer *lexer, \
static inline bool lex_normal_map455(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
'$', 781, '&', 489, '\'', 491, '(', 494, '*', 640, '-', \
636, '0', 943, '<', 610, '>', 617, '?', 761, '@', 942, \
'\\', 235, '_', 947, '`', 855, '|', 593, '[', 786, ']', \
786, '{', 786, '}', 786};
static uint32_t map[] = {'\n', 290, '!', 247, '#', 396, \
'$', 369, '&', 199, '*', 345, '-', 342, '0', 471, '<', \
252, '>', 257, '?', 354, '@', 467, '\\', 97, '_', 474, \
'|', 212};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map416(t_lexer *lexer, \
static inline bool lex_normal_map456(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
'$', 781, '\'', 491, '(', 494, ')', 655, '*', 640, '-', \
636, '0', 943, '<', 495, '>', 496, '?', 761, '@', 942, \
'\\', 110, '_', 947, '`', 855, '[', 786, ']', 786, '{', \
786, '}', 786};
static uint32_t map[] = {'\n', 291, '!', 247, '#', 396, \
'$', 369, '&', 333, '*', 345, '-', 342, '0', 471, ';', \
484, '?', 354, '@', 467, '\\', 66, '_', 474, 'i', 435};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif
#endif // INLINE_IMPL17_H

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

@ -19,65 +19,62 @@
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map417(t_lexer *lexer, \
static inline bool lex_normal_map457(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 862, \
'$', 781, '&', 508, '\'', 491, '(', 654, ')', 655, '-', \
950, '0', 803, ';', 490, '<', 608, '>', 617, '[', 674, \
'\\', 304, '`', 855, '{', 666, '|', 590, ']', 786, '}', \
786};
static uint32_t map[] = {'\n', 293, '!', 248, '"', 373, \
'#', 396, '$', 370, '&', 199, '\'', 201, '*', 348, '-', \
344, '0', 469, '<', 252, '>', 257, '?', 355, '@', 468, \
'\\', 93, '_', 473, '`', 416, '|', 212};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map418(t_lexer *lexer, \
static inline bool lex_normal_map458(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 862, \
'$', 781, '&', 508, '\'', 491, '(', 654, ')', 499, '+', \
771, '-', 769, '0', 803, '<', 608, '>', 617, '[', 674, \
'\\', 305, '`', 855, '{', 666, '|', 591, '~', 772, ']', \
786, '}', 786};
static uint32_t map[] = {'\n', 295, '!', 248, '"', 373, \
'#', 396, '$', 370, '&', 333, '\'', 201, '*', 348, '-', \
344, '0', 469, ';', 484, '?', 355, '@', 468, '\\', 57, \
'_', 473, '`', 416};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map419(t_lexer *lexer, \
static inline bool lex_normal_map459(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 862, \
'$', 781, '&', 508, '\'', 491, '(', 654, '+', 771, '-', \
769, '0', 803, '<', 608, '>', 617, '[', 674, '\\', 306, \
']', 675, '`', 855, '{', 666, '}', 786, '~', 772};
static uint32_t map[] = {'\n', 297, '!', 248, '"', 373, \
'#', 396, '$', 370, '\'', 201, '*', 348, '-', 344, '0', \
469, '?', 355, '@', 468, '\\', 63, '_', 473, '`', 416};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map420(t_lexer *lexer, \
static inline bool lex_normal_map460(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 862, \
'$', 781, '&', 508, '\'', 491, '(', 654, '+', 771, '-', \
769, '0', 803, '<', 608, '>', 617, '[', 674, '\\', 320, \
'`', 855, '~', 772, ']', 786, '{', 786, '}', 786};
static uint32_t map[] = {'!', 248, '"', 373, '#', 396, \
'$', 370, '&', 199, '\'', 201, '(', 232, '*', 348, '-', \
344, '0', 469, '<', 254, '>', 257, '?', 355, '@', 468, \
'\\', 31, '_', 473, '`', 416, '|', 235};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map421(t_lexer *lexer, \
static inline bool lex_normal_map461(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 862, \
'$', 781, '&', 508, '\'', 491, '(', 654, '-', 950, '0', \
803, ';', 490, '<', 608, '>', 617, '[', 674, '\\', 309, \
'`', 855, 'e', 956, '{', 666, ']', 786, '}', 786};
static uint32_t map[] = {'!', 248, '"', 373, '#', 396, \
'$', 370, '&', 199, '\'', 201, '*', 348, '-', 344, '0', \
469, '<', 254, '>', 257, '?', 355, '@', 468, '\\', 36, \
'_', 473, '`', 416, '|', 235};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif
#endif // INLINE_IMPL18_H

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

@ -19,65 +19,48 @@
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map422(t_lexer *lexer, \
static inline bool lex_normal_map462(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 862, \
'$', 781, '&', 508, '\'', 491, '(', 654, '-', 950, '0', \
803, '<', 608, '>', 617, '[', 674, '\\', 310, ']', 786, \
'`', 855, '{', 666, '}', 667};
static uint32_t map[] = {'!', 248, '"', 373, '#', 396, \
'$', 370, '&', 206, '\'', 201, '*', 348, '-', 344, '0', \
469, '<', 252, '>', 257, '?', 355, '@', 468, '\\', 38, \
'_', 473, '`', 416};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map423(t_lexer *lexer, \
static inline bool lex_normal_map463(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 862, \
'$', 781, '\'', 491, '(', 654, ')', 499, '+', 771, '-', \
769, '0', 803, '<', 495, '>', 496, '\\', 352, '`', 855, \
'~', 772, '[', 786, ']', 786, '{', 786, '}', 786};
static uint32_t map[] = {'!', 247, '#', 396, '$', 369, \
'&', 199, '*', 345, '-', 342, '0', 471, '<', 254, '>', \
257, '?', 354, '@', 467, '\\', 54, '_', 474, '|', 235};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map424(t_lexer *lexer, \
static inline bool lex_normal_map464(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 862, \
'$', 781, '\'', 491, '(', 654, ')', 499, '+', 771, '-', \
769, '0', 804, '<', 495, '>', 496, '\\', 332, '`', 855, \
'~', 772, '[', 786, ']', 786, '{', 786, '}', 786};
static uint32_t map[] = {'!', 247, '#', 396, '$', 369, \
')', 237, '*', 345, '-', 342, '0', 471, '?', 354, '@', \
467, '\\', 71, '_', 474, '|', 233};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map425(t_lexer *lexer, \
static inline bool lex_normal_map465(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 951, '"', 788, '#', 862, \
'$', 781, '%', 649, '&', 601, '\'', 491, '(', 654, '*', \
638, '+', 630, '-', 633, '/', 644, '0', 803, '<', 607, \
'=', 560, '>', 616, '?', 761, '\\', 318, ']', 675, '^', \
596, '`', 856, '|', 592, '[', 786, '{', 786, '}', 786};
static uint32_t map[] = {'!', 247, '#', 396, '$', 369, \
'*', 345, '-', 342, '0', 471, '?', 354, '@', 467, '\\', \
75, '_', 474};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map426(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 951, '"', 788, '#', 862, \
'$', 781, '%', 649, '&', 601, '\'', 491, '(', 654, '*', \
638, '+', 630, '-', 633, '/', 644, '0', 803, '<', 607, \
'=', 560, '>', 616, '?', 761, '\\', 319, ']', 675, '^', \
596, '`', 855, '|', 592, '[', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif
#endif // INLINE_IMPL19_H

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

@ -19,67 +19,65 @@
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map237(t_lexer *lexer, \
static inline bool lex_normal_map106(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 695, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
945, ';', 554, '<', 612, '>', 618, '?', 760, '@', 941, \
'\\', 91, '_', 948, '|', 593};
static uint32_t map[] = {'\n', 282, '!', 248, '"', 373, \
'#', 396, '$', 370, '&', 199, '\'', 201, '(', 232, '*', \
348, '-', 344, '0', 469, '<', 254, '>', 257, '?', 355, \
'@', 468, '\\', 28, '_', 473, '`', 416, '|', 235, '[', \
372, ']', 372, '{', 372, '}', 372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map238(t_lexer *lexer, \
static inline bool lex_normal_map107(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 696, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 654, '*', \
640, '-', 636, '0', 943, ';', 554, '<', 609, '=', 952, \
'>', 617, '?', 761, '@', 942, '\\', 30, '_', 947, '`', \
855, '|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
static uint32_t map[] = {'\n', 283, '!', 248, '"', 373, \
'#', 396, '$', 370, '&', 199, '\'', 201, '*', 348, '-', \
344, '0', 469, '<', 254, '>', 257, '?', 355, '@', 468, \
'\\', 34, '_', 473, '`', 416, '|', 235, '[', 372, ']', \
372, '{', 372, '}', 372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map239(t_lexer *lexer, \
static inline bool lex_normal_map108(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 697, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 654, '-', 950, '0', \
803, ';', 554, '<', 609, '=', 952, '>', 617, '\\', 321, \
'`', 855, 'e', 956, '|', 593, '[', 786, ']', 786, '{', \
786, '}', 786};
static uint32_t map[] = {'\n', 284, '!', 247, '#', 396, \
'$', 369, '&', 336, '*', 345, '-', 342, '0', 471, ';', \
483, '<', 254, '>', 257, '?', 354, '@', 467, '\\', 40, \
'_', 474, 'e', 436, '|', 235};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map240(t_lexer *lexer, \
static inline bool lex_normal_map109(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 698, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
945, ';', 554, '<', 613, '>', 618, '?', 760, '@', 941, \
'\\', 183, '_', 948, 'e', 877, '|', 593};
static uint32_t map[] = {'\n', 285, '!', 247, '#', 396, \
'$', 369, '&', 336, '*', 345, '-', 342, '0', 471, ';', \
483, '<', 254, '>', 257, '?', 354, '@', 467, '\\', 43, \
'_', 474, '|', 235};
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_map110(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 699, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, ';', 554, '<', 609, '=', 952, \
'>', 617, '?', 761, '@', 942, '\\', 153, '_', 947, '`', \
855, 'e', 871, '|', 593, '[', 786, ']', 786, '{', 786, \
'}', 786};
static uint32_t map[] = {'\n', 286, '!', 247, '#', 396, \
'$', 369, '&', 336, '*', 345, '-', 342, '0', 471, ';', \
484, '<', 254, '>', 257, '?', 354, '@', 467, '\\', 45, \
'_', 474, '`', 416, '|', 235};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif
#endif // INLINE_IMPL2_H

86
parser/static/lex_funcs/lex_normal/inline/inline_impl20.h
View file

@ -1,86 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl20.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL20_H
# define INLINE_IMPL20_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map427(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 671, '"', 788, '#', 816, \
'$', 780, '%', 650, '&', 600, ')', 655, '*', 639, '+', \
631, '-', 634, '/', 645, '0', 945, '<', 615, '=', 562, \
'>', 620, '?', 760, '@', 941, '\\', 67, '^', 597, '_', \
948, '|', 594};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map428(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 671, '"', 788, '#', 816, \
'$', 780, '%', 650, '&', 600, ')', 499, '*', 639, '+', \
631, '-', 634, '/', 645, '0', 945, '<', 615, '=', 562, \
'>', 620, '?', 760, '@', 941, '\\', 181, '^', 597, '_', \
948, '|', 594};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map429(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 671, '"', 788, '#', 816, \
'$', 780, '%', 650, '&', 600, '*', 639, '+', 631, '-', \
634, '/', 645, '0', 945, ':', 762, '<', 615, '=', 562, \
'>', 620, '?', 760, '@', 941, '\\', 64, '^', 597, '_', \
948, '|', 594};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map430(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 671, '"', 788, '#', 816, \
'$', 780, '%', 650, '&', 600, '*', 639, '+', 631, '-', \
634, '/', 645, '0', 945, '<', 615, '=', 562, '>', 620, \
'?', 760, '@', 941, '\\', 60, ']', 675, '^', 597, '_', \
948, '|', 594};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map431(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 671, '"', 788, '#', 816, \
'$', 780, '%', 650, '&', 600, '*', 639, '+', 631, '-', \
634, '/', 645, '0', 945, '<', 615, '=', 562, '>', 620, \
'?', 760, '@', 941, '\\', 178, ']', 509, '^', 597, '_', \
948, '|', 594};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif

82
parser/static/lex_funcs/lex_normal/inline/inline_impl21.h
View file

@ -1,82 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl21.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL21_H
# define INLINE_IMPL21_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map432(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 671, '"', 788, '#', 816, \
'$', 780, '%', 650, '&', 600, '*', 639, '+', 631, '-', \
634, '/', 645, '0', 945, '<', 615, '=', 562, '>', 620, \
'?', 760, '@', 941, '\\', 69, '^', 597, '_', 948, '|', \
594};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map433(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 506, '"', 788, '#', 862, \
'$', 785, '%', 650, '&', 600, ')', 499, '*', 639, '+', \
631, ',', 556, '-', 634, '.', 503, '/', 645, ':', 762, \
';', 490, '<', 615, '=', 562, '>', 620, '?', 760, '[', \
673};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map434(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 506, '"', 788, '#', 862, \
'$', 785, '%', 650, '&', 600, ')', 499, '*', 639, '+', \
631, ',', 556, '-', 634, '/', 645, ':', 762, ';', 490, \
'<', 615, '=', 562, '>', 620, '?', 760, '[', 673};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map435(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 506, '"', 788, '#', 862, \
'$', 498, '%', 650, '&', 600, '(', 494, ')', 655, '*', \
639, '+', 631, ',', 556, '-', 634, '/', 645, '<', 615, \
'=', 562, '>', 620, '?', 760};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map436(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 506, '#', 862, '%', 650, \
'&', 600, ')', 655, '*', 639, '+', 631, ',', 556, '-', \
635, '/', 645, '<', 615, '=', 561, '>', 620};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif

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

@ -1,77 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl22.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL22_H
# define INLINE_IMPL22_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map437(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 506, '#', 862, '%', 650, \
'&', 600, ')', 655, '*', 639, '+', 631, '-', 634, '/', \
645, '<', 615, '=', 562, '>', 620, '?', 760, '[', 673};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map438(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 506, '#', 862, '%', 650, \
'&', 600, ')', 655, '*', 639, '+', 631, '-', 634, '/', \
645, '<', 615, '=', 562, '>', 620, '?', 760};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map439(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 506, '#', 862, '%', 650, \
'&', 600, ')', 655, '*', 639, '+', 631, '-', 634, '/', \
645, '<', 615, '=', 562, '>', 620, '?', 760};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map440(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 506, '#', 862, '%', 650, \
'&', 600, ')', 499, '*', 639, '+', 631, ',', 556, '-', \
634, '/', 645, ':', 762, '<', 615, '=', 562, '>', 620, \
'?', 760};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map441(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 506, '#', 862, '%', 650, \
'&', 600, ')', 499, '*', 639, '+', 631, ',', 556, '-', \
635, '/', 645, '<', 615, '=', 561, '>', 620};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif

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

@ -1,79 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl23.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL23_H
# define INLINE_IMPL23_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map442(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 506, '#', 862, '%', 650, \
'&', 600, ')', 499, '*', 639, '+', 631, ',', 556, '-', \
635, '/', 645, '<', 615, '=', 561, '>', 620};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map443(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 506, '#', 862, '%', 650, \
'&', 600, ')', 499, '*', 639, '+', 631, '-', 634, '/', \
645, ':', 762, '<', 615, '=', 562, '>', 620, '?', 760};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map444(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 669, '"', 788, '#', 816, \
'$', 780, '&', 489, '*', 637, '-', 632, '0', 945, '<', \
612, '>', 618, '?', 760, '@', 941, '\\', 108, ']', 675, \
'_', 948, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map445(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 669, '"', 788, '#', 816, \
'$', 780, '&', 489, '*', 637, '-', 632, '0', 945, '<', \
612, '>', 618, '?', 760, '@', 941, '\\', 114, '_', 948, \
'|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map446(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 669, '"', 788, '#', 816, \
'$', 780, '&', 489, '*', 637, '-', 632, '0', 945, '<', \
613, '>', 618, '?', 760, '@', 941, '\\', 195, ']', 675, \
'_', 948, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif

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

@ -1,77 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl24.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL24_H
# define INLINE_IMPL24_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map447(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 669, '"', 788, '#', 816, \
'$', 780, '&', 489, '*', 637, '-', 632, '0', 945, '<', \
613, '>', 618, '?', 760, '@', 941, '\\', 197, '_', 948, \
'|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map448(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 669, '"', 788, '#', 816, \
'$', 780, ')', 655, '*', 637, '-', 632, '0', 945, '?', \
760, '@', 941, '\\', 132, '_', 948, '|', 590};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map449(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 669, '"', 788, '#', 816, \
'$', 780, '*', 637, '-', 632, '0', 945, '?', 760, '@', \
941, '\\', 135, '_', 948};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map450(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 669, '"', 788, '#', 816, \
'$', 780, '*', 637, '-', 632, '0', 945, '?', 760, '@', \
941, '\\', 134, '_', 948};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map451(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 669, '"', 788, '#', 862, \
'$', 785, '&', 489, '(', 653, '+', 771, '-', 769, '0', \
808, '<', 612, '>', 618};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif

74
parser/static/lex_funcs/lex_normal/inline/inline_impl25.h
View file

@ -1,74 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl25.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL25_H
# define INLINE_IMPL25_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map452(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 669, '#', 816, '$', 780, \
'*', 637, '-', 632, '0', 945, '?', 760, '@', 941, '\\', \
136, '_', 948};
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[] = {'!', 669, '#', 816, '$', 780, \
'*', 637, '-', 632, '0', 945, '?', 760, '@', 941, '\\', \
138, '_', 948};
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[] = {'!', 669, '#', 816, '$', 784, \
'*', 637, '-', 632, '0', 945, '?', 760, '@', 941};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map455(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 669, '#', 816, '$', 784, \
'*', 637, '-', 632, '0', 945, '?', 760, '@', 941};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map456(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 819, '#', 825, '$', 784, \
'*', 637, '-', 632, '0', 945, '=', 826, '?', 760, '@', \
941};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif

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

@ -1,81 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl26.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL26_H
# define INLINE_IMPL26_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map457(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'"', 788, '#', 862, '$', 781, \
'&', 508, '\'', 491, '(', 654, '-', 950, '0', 803, '<', \
608, '>', 617, '[', 674, '\\', 330, '`', 855, ']', 786, \
'{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map458(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'"', 788, '#', 862, '$', 781, \
'&', 508, '\'', 491, '(', 494, ')', 655, '-', 950, '0', \
803, '<', 608, '>', 617, '\\', 340, '`', 855, '|', 590, \
'[', 786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map459(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'"', 788, '#', 862, '$', 781, \
'&', 508, '\'', 491, '(', 494, ')', 655, '-', 950, '0', \
803, '<', 608, '>', 617, '\\', 371, '`', 856, '|', 590, \
'[', 786, ']', 786, '{', 786, '}', 786};
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[] = {'"', 788, '#', 862, '$', 781, \
'&', 489, '\'', 491, '(', 654, ')', 655, '-', 950, '0', \
803, '<', 609, '>', 617, '\\', 338, '`', 855, '|', 593, \
'[', 786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map461(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'"', 788, '#', 862, '$', 781, \
'&', 489, '\'', 491, '(', 654, '-', 950, '0', 803, '<', \
609, '=', 952, '>', 617, '\\', 329, '`', 855, '|', 593, \
'[', 786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif

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

@ -1,81 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl27.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL27_H
# define INLINE_IMPL27_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map462(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'"', 788, '#', 862, '$', 781, \
'&', 489, '\'', 491, '(', 654, '-', 950, '0', 803, '<', \
609, '=', 952, '>', 617, '\\', 353, '`', 856, '|', 593, \
'[', 786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map463(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'"', 788, '#', 862, '$', 781, \
'&', 489, '\'', 491, '(', 494, ')', 655, '-', 950, '0', \
803, '<', 609, '>', 617, '\\', 358, '`', 856, '|', 593, \
'[', 786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map464(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'"', 788, '#', 862, '$', 781, \
'&', 489, '\'', 491, '(', 494, '-', 950, '0', 803, '<', \
609, '>', 617, '\\', 336, ']', 675, '`', 855, '|', 593, \
'[', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map465(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'"', 788, '#', 862, '$', 781, \
'&', 489, '\'', 491, '(', 494, '-', 950, '0', 803, '<', \
609, '>', 617, '\\', 355, ']', 675, '`', 856, '|', 593, \
'[', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map466(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'"', 788, '#', 862, '$', 781, \
'&', 489, '\'', 491, '(', 494, '-', 950, '0', 803, '<', \
610, '>', 617, '\\', 342, '`', 855, '|', 593, '[', 786, \
']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif

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

@ -1,81 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl28.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL28_H
# define INLINE_IMPL28_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map467(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'"', 788, '#', 862, '$', 781, \
'&', 489, '\'', 491, '(', 494, '-', 950, '0', 803, '<', \
610, '>', 617, '\\', 363, ']', 675, '`', 856, '|', 593, \
'[', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map468(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'"', 788, '#', 862, '$', 781, \
'&', 489, '\'', 491, '(', 494, '-', 950, '0', 803, '<', \
610, '>', 617, '\\', 364, '`', 856, '|', 593, '[', 786, \
']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map469(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'"', 788, '#', 862, '$', 781, \
'&', 489, '\'', 491, '(', 494, '-', 950, '0', 803, '<', \
610, '>', 617, '\\', 400, ']', 675, '`', 855, '|', 593, \
'[', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map470(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'"', 788, '#', 862, '$', 781, \
'&', 489, '\'', 491, '(', 494, '-', 950, '0', 804, '<', \
610, '>', 617, '\\', 334, '`', 855, '|', 593, '[', 786, \
']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map471(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'"', 788, '#', 862, '$', 781, \
'&', 489, '\'', 491, '(', 494, '-', 950, '0', 804, '<', \
610, '>', 617, '\\', 359, '`', 856, '|', 593, '[', 786, \
']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif

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

@ -1,78 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl29.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL29_H
# define INLINE_IMPL29_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map472(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'"', 788, '#', 862, '$', 781, \
'\'', 491, '(', 654, '-', 950, '0', 803, '<', 495, '>', \
496, '\\', 366, '`', 855, 'e', 956, '[', 786, ']', 786, \
'{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map473(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'"', 788, '#', 862, '$', 781, \
'\'', 491, '(', 654, '-', 950, '0', 803, '<', 495, '>', \
496, '\\', 373, '`', 855, '}', 818, '[', 786, ']', 786, \
'{', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map474(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'"', 788, '#', 862, '$', 785, \
'&', 489, '(', 653, ')', 499, '+', 501, '-', 502, '0', \
809, '<', 613, '=', 559, '>', 618};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map475(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'"', 788, '#', 862, '$', 782, \
'\'', 491, '(', 653, ')', 655, ';', 553, '<', 495, '>', \
496, '\\', 389, '`', 855, '{', 666, '|', 590, '}', 818};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map476(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'"', 788, '#', 862, '$', 497, \
'%', 646, '*', 637, '+', 629, '-', 632, '/', 641, ':', \
762};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif

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

@ -19,67 +19,62 @@
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map242(t_lexer *lexer, \
static inline bool lex_normal_map111(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 700, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 654, '-', 950, '0', \
803, ';', 554, '<', 609, '=', 952, '>', 617, '\\', 322, \
'`', 855, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
786};
static uint32_t map[] = {'\n', 287, '!', 247, '#', 396, \
'$', 369, '&', 336, ')', 237, '*', 345, '-', 342, '0', \
471, ';', 484, '<', 254, '>', 257, '?', 354, '@', 467, \
'\\', 48, '_', 474, '|', 235};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map243(t_lexer *lexer, \
static inline bool lex_normal_map112(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 701, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
945, ';', 554, '<', 613, '>', 618, '?', 760, '@', 941, \
'\\', 185, '_', 948, '|', 593};
static uint32_t map[] = {'\n', 288, '!', 247, '#', 396, \
'$', 369, '&', 336, '*', 345, '-', 342, '0', 471, ';', \
484, '<', 254, '>', 257, '?', 354, '@', 467, '\\', 95, \
'_', 474, '|', 235};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map244(t_lexer *lexer, \
static inline bool lex_normal_map113(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 702, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 654, ')', \
655, '*', 640, '-', 636, '0', 943, ';', 555, '<', 609, \
'=', 952, '>', 617, '?', 761, '@', 942, '\\', 32, '_', \
947, '`', 855, '|', 593, '[', 786, ']', 786, '{', 786, \
'}', 786};
static uint32_t map[] = {'\n', 289, '!', 247, '#', 396, \
'$', 369, '&', 199, '*', 345, '-', 342, '0', 471, '<', \
254, '>', 257, '?', 354, '@', 467, '\\', 51, '_', 474, \
'|', 235};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map245(t_lexer *lexer, \
static inline bool lex_normal_map114(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 703, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 654, ')', 655, '-', \
950, '0', 803, ';', 555, '<', 609, '=', 952, '>', 617, \
'\\', 323, '`', 855, '|', 593, '[', 786, ']', 786, '{', \
786, '}', 786};
static uint32_t map[] = {'\n', 290, '!', 247, '#', 396, \
'$', 369, '&', 199, '*', 345, '-', 342, '0', 471, '<', \
252, '>', 257, '?', 354, '@', 467, '\\', 97, '_', 474, \
'|', 212};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map246(t_lexer *lexer, \
static inline bool lex_normal_map115(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 704, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
945, ';', 555, '<', 612, '>', 618, '?', 760, '@', 941, \
'\\', 96, '_', 948, '`', 855, '|', 593};
static uint32_t map[] = {'\n', 291, '!', 247, '#', 396, \
'$', 369, '&', 333, '*', 345, '-', 342, '0', 471, ';', \
484, '?', 354, '@', 467, '\\', 66, '_', 474, 'i', 435};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif
#endif // INLINE_IMPL3_H

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

@ -1,77 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl30.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL30_H
# define INLINE_IMPL30_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map478(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'"', 788, '#', 863, '$', 781, \
'\'', 491, '(', 654, '-', 950, '0', 803, '<', 495, '>', \
496, '\\', 374, '`', 855, '[', 786, ']', 786, '{', 786, \
'}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map479(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'"', 788, '#', 863, '$', 781, \
'\'', 491, '(', 494, '-', 950, '0', 803, '<', 495, '>', \
496, '\\', 376, ']', 675, '`', 855, '[', 786, '{', 786, \
'}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map481(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'#', 816, '%', 648, '*', 823, \
'+', 833, ',', 558, '-', 830, '/', 643, ':', 764, '=', \
826, '?', 836, '@', 821, '[', 673};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map484(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'#', 862, '%', 646, '&', 489, \
'*', 637, '+', 629, '-', 632, '/', 641, '<', 613, '>', \
618};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map485(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'#', 862, '&', 508, '(', 654, \
'<', 611, '>', 618, '[', 674, '\\', 392, '{', 666};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif

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

@ -1,83 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl31.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL31_H
# define INLINE_IMPL31_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map487(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'#', 862, '&', 489, '<', 612, \
'>', 618, '\\', 384, ']', 675, '`', 510, '|', 593, '[', \
786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map527(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 703, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 654, ')', 655, '-', \
950, '0', 803, ';', 555, '<', 609, '=', 952, '>', 617, \
'\\', 323, '`', 855, '|', 593, '[', 786, ']', 786, '{', \
786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map528(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 705, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 654, '*', \
640, '-', 636, '0', 943, ';', 555, '<', 609, '=', 952, \
'>', 617, '?', 761, '@', 942, '\\', 156, '_', 947, '`', \
855, '|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map529(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 710, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
945, ';', 555, '<', 612, '>', 618, '?', 760, '@', 941, \
'\\', 211, '_', 948, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map530(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 712, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, ')', 655, '-', \
950, '0', 804, ';', 555, '<', 610, '>', 617, '\\', 326, \
'`', 855, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif

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

@ -1,85 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl32.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL32_H
# define INLINE_IMPL32_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map531(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 714, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, ';', 555, '<', 609, '=', 952, \
'>', 617, '?', 761, '@', 942, '\\', 215, '_', 947, '`', \
855, '|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map532(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 716, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
945, ';', 555, '<', 613, '>', 618, '?', 760, '@', 941, \
'\\', 218, '_', 948, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map533(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 724, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, ')', 655, '-', \
950, '0', 803, ';', 555, '<', 609, '>', 617, '\\', 331, \
'`', 855, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map534(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 730, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, ')', 655, '-', \
950, '0', 803, ';', 555, '<', 610, '>', 617, '\\', 399, \
'`', 855, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map535(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 732, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, ';', 555, '<', 609, '>', 617, \
'?', 761, '@', 942, '\\', 166, '_', 947, '`', 855, '|', \
593, '[', 786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif

86
parser/static/lex_funcs/lex_normal/inline/inline_impl33.h
View file

@ -1,86 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl33.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL33_H
# define INLINE_IMPL33_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map536(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 738, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, ';', 555, '<', 610, '>', 617, \
'?', 761, '@', 942, '\\', 207, '_', 947, '`', 855, '|', \
593, '[', 786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map537(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 739, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 654, ')', 655, '-', \
950, '0', 803, ';', 555, '<', 609, '=', 952, '>', 617, \
'\\', 339, '`', 856, '|', 593, '[', 786, ']', 786, '{', \
786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map538(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 751, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, ')', 655, '-', \
950, '0', 804, ';', 555, '<', 610, '>', 617, '\\', 349, \
'`', 856, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map539(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 752, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, ')', 655, '-', \
950, '0', 803, ';', 555, '<', 609, '>', 617, '\\', 350, \
'`', 856, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map540(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 754, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, ')', 655, '-', \
950, '0', 803, ';', 555, '<', 610, '>', 617, '\\', 354, \
'`', 856, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif

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

@ -1,85 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl34.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL34_H
# define INLINE_IMPL34_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map545(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 670, '"', 788, '#', 816, \
'$', 781, '%', 647, '&', 601, '\'', 491, '(', 654, ')', \
655, '*', 638, '+', 770, ',', 557, '-', 768, '/', 642, \
'0', 944, ':', 765, ';', 554, '<', 607, '=', 563, '>', \
616, '?', 761, '@', 942, '[', 674, '\\', 301, ']', 675, \
'^', 595, '_', 946, '`', 856, 'e', 956, 'i', 955, '{', \
666, '|', 592, '}', 818, '~', 772};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map546(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 862, \
'$', 781, '&', 508, '\'', 491, '(', 654, ')', 655, '-', \
950, '0', 803, ';', 490, '<', 608, '>', 617, '[', 674, \
'\\', 304, '`', 855, '{', 666, '|', 590, ']', 786, '}', \
786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map793(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 669, '"', 788, '#', 816, \
'$', 780, '*', 637, '-', 632, '0', 945, '?', 760, '@', \
941, '\\', 135, '_', 948};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map794(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 669, '#', 816, '$', 780, \
'*', 637, '-', 632, '0', 945, '?', 760, '@', 941, '\\', \
136, '_', 948};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map880(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 689, '!', 670, '"', 788, \
'#', 816, '$', 781, '%', 649, '&', 601, '\'', 491, '(', \
654, ')', 655, '*', 638, '+', 630, '-', 633, '/', 644, \
'0', 943, ';', 555, '<', 607, '=', 560, '>', 616, '?', \
761, '@', 942, '\\', 14, '^', 596, '_', 947, '`', 855, \
'|', 592};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif

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

@ -1,83 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl35.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL35_H
# define INLINE_IMPL35_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map881(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 692, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
945, ';', 554, '<', 612, '>', 618, '?', 760, '@', 941, \
'\\', 81, '_', 948, 'e', 877, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map882(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 693, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 654, '*', \
640, '-', 636, '0', 943, ';', 554, '<', 609, '=', 952, \
'>', 617, '?', 761, '@', 942, '\\', 27, '_', 947, '`', \
855, 'e', 871, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map883(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 695, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
945, ';', 554, '<', 612, '>', 618, '?', 760, '@', 941, \
'\\', 91, '_', 948, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map884(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 696, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 654, '*', \
640, '-', 636, '0', 943, ';', 554, '<', 609, '=', 952, \
'>', 617, '?', 761, '@', 942, '\\', 30, '_', 947, '`', \
855, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map885(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 698, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
945, ';', 554, '<', 613, '>', 618, '?', 760, '@', 941, \
'\\', 183, '_', 948, 'e', 877, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif

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

@ -1,84 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl36.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL36_H
# define INLINE_IMPL36_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map886(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 699, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, ';', 554, '<', 609, '=', 952, \
'>', 617, '?', 761, '@', 942, '\\', 153, '_', 947, '`', \
855, 'e', 871, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map887(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 701, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
945, ';', 554, '<', 613, '>', 618, '?', 760, '@', 941, \
'\\', 185, '_', 948, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map888(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 702, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 654, ')', \
655, '*', 640, '-', 636, '0', 943, ';', 555, '<', 609, \
'=', 952, '>', 617, '?', 761, '@', 942, '\\', 32, '_', \
947, '`', 855, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map889(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 704, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
945, ';', 555, '<', 612, '>', 618, '?', 760, '@', 941, \
'\\', 96, '_', 948, '`', 855, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map890(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 705, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 654, '*', \
640, '-', 636, '0', 943, ';', 555, '<', 609, '=', 952, \
'>', 617, '?', 761, '@', 942, '\\', 156, '_', 947, '`', \
855, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif

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

@ -1,83 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl37.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL37_H
# define INLINE_IMPL37_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map891(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 707, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 602, ')', 655, '*', 637, '-', \
632, '0', 945, ';', 555, '<', 612, '>', 618, '?', 760, \
'@', 941, '\\', 98, '_', 948, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map892(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 708, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, ';', 554, '<', 609, '=', 952, \
'>', 617, '?', 761, '@', 942, '\\', 202, '_', 947, '`', \
855, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map893(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 710, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
945, ';', 555, '<', 612, '>', 618, '?', 760, '@', 941, \
'\\', 211, '_', 948, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map894(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 711, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, ')', \
655, '*', 640, '-', 636, '0', 943, ';', 555, '<', 609, \
'=', 952, '>', 617, '?', 761, '@', 942, '\\', 158, '_', \
947, '`', 855, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map895(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 713, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
945, ';', 555, '<', 613, '>', 618, '?', 760, '@', 941, \
'\\', 188, '_', 948, '`', 855, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif

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

@ -1,84 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl38.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL38_H
# define INLINE_IMPL38_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map896(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 714, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, ';', 555, '<', 609, '=', 952, \
'>', 617, '?', 761, '@', 942, '\\', 215, '_', 947, '`', \
855, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map897(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 716, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
945, ';', 555, '<', 613, '>', 618, '?', 760, '@', 941, \
'\\', 218, '_', 948, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map898(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 717, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, ';', 554, '<', 609, '>', 617, \
'?', 761, '@', 942, '\\', 37, '_', 947, '`', 855, 'e', \
871, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map899(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 719, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 602, ')', 655, '*', 637, '-', \
632, '0', 945, ';', 555, '<', 613, '>', 618, '?', 760, \
'@', 941, '\\', 190, '_', 948, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map900(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 720, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, ';', 554, '<', 610, '>', 617, \
'?', 761, '@', 942, '\\', 222, '_', 947, '`', 855, 'e', \
871, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif

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

@ -1,83 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl39.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL39_H
# define INLINE_IMPL39_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map901(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 722, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 489, '*', 637, '-', 632, '0', \
945, '<', 612, '>', 618, '?', 760, '@', 941, '\\', 106, \
'_', 948, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map902(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 723, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, ';', 554, '<', 609, '>', 617, \
'?', 761, '@', 942, '\\', 43, '_', 947, '`', 855, '|', \
593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map903(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 725, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 489, '*', 637, '-', 632, '0', \
945, '<', 613, '>', 618, '?', 760, '@', 941, '\\', 193, \
'_', 948, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map904(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 726, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, ')', \
655, '*', 640, '-', 636, '0', 943, ';', 555, '<', 609, \
'>', 617, '?', 761, '@', 942, '\\', 46, '_', 947, '`', \
855, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map905(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 728, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 489, '*', 637, '-', 632, '0', \
945, '<', 611, '>', 618, '?', 760, '@', 941, '\\', 213, \
'_', 948, '|', 516};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif

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

@ -19,66 +19,65 @@
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map247(t_lexer *lexer, \
static inline bool lex_normal_map116(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 705, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 654, '*', \
640, '-', 636, '0', 943, ';', 555, '<', 609, '=', 952, \
'>', 617, '?', 761, '@', 942, '\\', 156, '_', 947, '`', \
855, '|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
static uint32_t map[] = {'\n', 292, '"', 373, '#', 421, \
'$', 370, '&', 336, '\'', 201, '-', 476, '0', 386, ';', \
483, '<', 254, '>', 257, '\\', 140, '`', 416, 'e', 425, \
'|', 235, '[', 372, ']', 372, '{', 372, '}', 372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map248(t_lexer *lexer, \
static inline bool lex_normal_map117(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 706, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
804, ';', 554, '<', 610, '>', 617, '\\', 324, '`', 855, \
'e', 866, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
786};
static uint32_t map[] = {'\n', 293, '!', 248, '"', 373, \
'#', 396, '$', 370, '&', 199, '\'', 201, '*', 348, '-', \
344, '0', 469, '<', 252, '>', 257, '?', 355, '@', 468, \
'\\', 93, '_', 473, '`', 416, '|', 212, '[', 372, ']', \
372, '{', 372, '}', 372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map249(t_lexer *lexer, \
static inline bool lex_normal_map118(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 707, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 602, ')', 655, '*', 637, '-', \
632, '0', 945, ';', 555, '<', 612, '>', 618, '?', 760, \
'@', 941, '\\', 98, '_', 948, '|', 593};
static uint32_t map[] = {'\n', 294, '"', 373, '#', 421, \
'$', 370, '&', 336, '\'', 201, '-', 476, '0', 386, ';', \
483, '<', 254, '>', 257, '\\', 141, '`', 416, '|', 235, \
'[', 372, ']', 372, '{', 372, '}', 372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map250(t_lexer *lexer, \
static inline bool lex_normal_map119(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 708, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, ';', 554, '<', 609, '=', 952, \
'>', 617, '?', 761, '@', 942, '\\', 202, '_', 947, '`', \
855, '|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
static uint32_t map[] = {'\n', 295, '!', 248, '"', 373, \
'#', 396, '$', 370, '&', 333, '\'', 201, '*', 348, '-', \
344, '0', 469, ';', 484, '?', 355, '@', 468, '\\', 57, \
'_', 473, '`', 416, '[', 372, ']', 372, '{', 372, '}', \
372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map251(t_lexer *lexer, \
static inline bool lex_normal_map120(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 709, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
804, ';', 554, '<', 610, '>', 617, '\\', 325, '`', 855, \
'|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
static uint32_t map[] = {'\n', 296, '"', 373, '#', 421, \
'$', 370, '&', 336, '\'', 201, '(', 232, '-', 476, '0', \
385, ';', 483, '<', 254, '>', 257, '\\', 142, '`', 416, \
'|', 235, '[', 372, ']', 372, '{', 372, '}', 372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif
#endif // INLINE_IMPL4_H

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

@ -1,85 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl40.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL40_H
# define INLINE_IMPL40_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map906(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 729, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, ';', 554, '<', 610, '>', 617, \
'?', 761, '@', 942, '\\', 226, '_', 947, '`', 855, '|', \
593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map907(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 731, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 599, '*', 637, '-', 632, '0', \
945, ';', 555, '?', 760, '@', 941, '\\', 128, '_', 948, \
'i', 876};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map908(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 732, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, ';', 555, '<', 609, '>', 617, \
'?', 761, '@', 942, '\\', 166, '_', 947, '`', 855, '|', \
593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map909(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 734, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 489, '\'', 491, '(', 654, '*', \
640, '-', 636, '0', 943, '<', 609, '=', 952, '>', 617, \
'?', 761, '@', 942, '\\', 48, '_', 947, '`', 855, '|', \
593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map910(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 736, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, ')', \
655, '*', 640, '-', 636, '0', 943, ';', 555, '<', 610, \
'>', 617, '?', 761, '@', 942, '\\', 228, '_', 947, '`', \
855, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif

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

@ -1,83 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl41.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL41_H
# define INLINE_IMPL41_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map911(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 738, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, ';', 555, '<', 610, '>', 617, \
'?', 761, '@', 942, '\\', 207, '_', 947, '`', 855, '|', \
593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map912(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 740, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 489, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, '<', 609, '=', 952, '>', 617, \
'?', 761, '@', 942, '\\', 168, '_', 947, '`', 855, '|', \
593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map913(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 742, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 489, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, '<', 609, '>', 617, '?', 761, \
'@', 942, '\\', 58, '_', 947, '`', 855, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map914(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 744, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 489, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, '<', 610, '>', 617, '?', 761, \
'@', 942, '\\', 233, '_', 947, '`', 855, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map915(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 746, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 489, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, '<', 608, '>', 617, '?', 761, \
'@', 942, '\\', 176, '_', 947, '`', 855, '|', 516};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif

82
parser/static/lex_funcs/lex_normal/inline/inline_impl42.h
View file

@ -1,82 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl42.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL42_H
# define INLINE_IMPL42_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map916(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 748, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 599, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, ';', 555, '<', 495, '>', 496, \
'?', 761, '@', 942, '\\', 100, '_', 947, '`', 855};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map917(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 750, '!', 672, '"', 788, \
'#', 816, '$', 781, '\'', 491, '(', 494, '*', 640, '-', \
636, '0', 943, '<', 495, '>', 496, '?', 761, '@', 942, \
'\\', 112, '_', 947, '`', 855};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map918(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 670, '"', 788, '#', 816, \
'$', 781, '%', 649, '&', 601, '\'', 491, '(', 654, '*', \
638, '+', 630, '-', 633, '/', 644, '0', 943, '<', 607, \
'=', 560, '>', 616, '?', 761, '@', 942, '\\', 19, ']', \
675, '^', 596, '_', 947, '`', 855, '|', 592};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map919(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
'$', 781, '&', 508, '\'', 491, '(', 494, '*', 640, '-', \
636, '0', 943, '<', 608, '>', 617, '?', 761, '@', 942, \
'\\', 74, '_', 947, '`', 855};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map920(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
'$', 781, '&', 489, '\'', 491, '(', 654, '*', 640, '-', \
636, '0', 943, '<', 609, '=', 952, '>', 617, '?', 761, \
'@', 942, '\\', 51, '_', 947, '`', 855, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif

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

@ -1,81 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl43.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL43_H
# define INLINE_IMPL43_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map921(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
'$', 781, '&', 489, '\'', 491, '(', 494, '*', 640, '-', \
636, '0', 943, '<', 609, '=', 952, '>', 617, '?', 761, \
'@', 942, '\\', 171, '_', 947, '`', 855, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map922(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
'$', 781, '&', 489, '\'', 491, '(', 494, '*', 640, '-', \
636, '0', 943, '<', 609, '>', 617, '?', 761, '@', 942, \
'\\', 55, ']', 675, '_', 947, '`', 855, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map923(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
'$', 781, '&', 489, '\'', 491, '(', 494, '*', 640, '-', \
636, '0', 943, '<', 609, '>', 617, '?', 761, '@', 942, \
'\\', 62, '_', 947, '`', 855, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map924(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
'$', 781, '&', 489, '\'', 491, '(', 494, '*', 640, '-', \
636, '0', 943, '<', 610, '>', 617, '?', 761, '@', 942, \
'\\', 231, ']', 675, '_', 947, '`', 855, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map925(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
'$', 781, '&', 489, '\'', 491, '(', 494, '*', 640, '-', \
636, '0', 943, '<', 610, '>', 617, '?', 761, '@', 942, \
'\\', 235, '_', 947, '`', 855, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif

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

@ -1,85 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl44.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL44_H
# define INLINE_IMPL44_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map926(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
'$', 781, '\'', 491, '(', 494, ')', 655, '*', 640, '-', \
636, '0', 943, '<', 495, '>', 496, '?', 761, '@', 942, \
'\\', 110, '_', 947, '`', 855};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map927(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 671, '"', 788, '#', 816, \
'$', 780, '%', 650, '&', 600, ')', 655, '*', 639, '+', \
631, '-', 634, '/', 645, '0', 945, '<', 615, '=', 562, \
'>', 620, '?', 760, '@', 941, '\\', 67, '^', 597, '_', \
948, '|', 594};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map928(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 671, '"', 788, '#', 816, \
'$', 780, '%', 650, '&', 600, ')', 499, '*', 639, '+', \
631, '-', 634, '/', 645, '0', 945, '<', 615, '=', 562, \
'>', 620, '?', 760, '@', 941, '\\', 181, '^', 597, '_', \
948, '|', 594};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map929(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 671, '"', 788, '#', 816, \
'$', 780, '%', 650, '&', 600, '*', 639, '+', 631, '-', \
634, '/', 645, '0', 945, ':', 762, '<', 615, '=', 562, \
'>', 620, '?', 760, '@', 941, '\\', 64, '^', 597, '_', \
948, '|', 594};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map930(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 671, '"', 788, '#', 816, \
'$', 780, '%', 650, '&', 600, '*', 639, '+', 631, '-', \
634, '/', 645, '0', 945, '<', 615, '=', 562, '>', 620, \
'?', 760, '@', 941, '\\', 60, ']', 675, '^', 597, '_', \
948, '|', 594};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif

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

@ -1,83 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl45.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL45_H
# define INLINE_IMPL45_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map931(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 671, '"', 788, '#', 816, \
'$', 780, '%', 650, '&', 600, '*', 639, '+', 631, '-', \
634, '/', 645, '0', 945, '<', 615, '=', 562, '>', 620, \
'?', 760, '@', 941, '\\', 178, ']', 509, '^', 597, '_', \
948, '|', 594};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map932(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 671, '"', 788, '#', 816, \
'$', 780, '%', 650, '&', 600, '*', 639, '+', 631, '-', \
634, '/', 645, '0', 945, '<', 615, '=', 562, '>', 620, \
'?', 760, '@', 941, '\\', 69, '^', 597, '_', 948, '|', \
594};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map933(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 669, '"', 788, '#', 816, \
'$', 780, '&', 489, '*', 637, '-', 632, '0', 945, '<', \
612, '>', 618, '?', 760, '@', 941, '\\', 108, ']', 675, \
'_', 948, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map934(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 669, '"', 788, '#', 816, \
'$', 780, '&', 489, '*', 637, '-', 632, '0', 945, '<', \
612, '>', 618, '?', 760, '@', 941, '\\', 114, '_', 948, \
'|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map935(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 669, '"', 788, '#', 816, \
'$', 780, '&', 489, '*', 637, '-', 632, '0', 945, '<', \
613, '>', 618, '?', 760, '@', 941, '\\', 195, ']', 675, \
'_', 948, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif

66
parser/static/lex_funcs/lex_normal/inline/inline_impl46.h
View file

@ -1,66 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl46.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef INLINE_IMPL46_H
# define INLINE_IMPL46_H
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map936(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 669, '"', 788, '#', 816, \
'$', 780, '&', 489, '*', 637, '-', 632, '0', 945, '<', \
613, '>', 618, '?', 760, '@', 941, '\\', 197, '_', 948, \
'|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map937(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 669, '"', 788, '#', 816, \
'$', 780, ')', 655, '*', 637, '-', 632, '0', 945, '?', \
760, '@', 941, '\\', 132, '_', 948, '|', 590};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map938(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 669, '"', 788, '#', 816, \
'$', 780, '*', 637, '-', 632, '0', 945, '?', 760, '@', \
941, '\\', 134, '_', 948};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map939(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 669, '#', 816, '$', 780, \
'*', 637, '-', 632, '0', 945, '?', 760, '@', 941, '\\', \
138, '_', 948};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif

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

@ -19,67 +19,65 @@
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map252(t_lexer *lexer, \
static inline bool lex_normal_map121(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 710, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
945, ';', 555, '<', 612, '>', 618, '?', 760, '@', 941, \
'\\', 211, '_', 948, '|', 593};
static uint32_t map[] = {'\n', 297, '!', 248, '"', 373, \
'#', 396, '$', 370, '\'', 201, '*', 348, '-', 344, '0', \
469, '?', 355, '@', 468, '\\', 63, '_', 473, '`', 416, \
'[', 372, ']', 372, '{', 372, '}', 372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map253(t_lexer *lexer, \
static inline bool lex_normal_map122(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 711, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, ')', \
655, '*', 640, '-', 636, '0', 943, ';', 555, '<', 609, \
'=', 952, '>', 617, '?', 761, '@', 942, '\\', 158, '_', \
947, '`', 855, '|', 593, '[', 786, ']', 786, '{', 786, \
'}', 786};
static uint32_t map[] = {'\n', 298, '"', 373, '#', 421, \
'$', 370, '&', 336, '\'', 201, ')', 237, '-', 476, '0', \
386, ';', 484, '<', 254, '>', 257, '\\', 143, '`', 416, \
'|', 235, '[', 372, ']', 372, '{', 372, '}', 372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map254(t_lexer *lexer, \
static inline bool lex_normal_map123(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 712, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, ')', 655, '-', \
950, '0', 804, ';', 555, '<', 610, '>', 617, '\\', 326, \
'`', 855, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
786};
static uint32_t map[] = {'\n', 299, '"', 373, '#', 421, \
'$', 370, '&', 336, '\'', 201, '(', 232, ')', 237, '-', \
476, '0', 385, ';', 484, '<', 254, '>', 257, '\\', 144, \
'`', 416, '|', 235, '[', 372, ']', 372, '{', 372, '}', \
372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map255(t_lexer *lexer, \
static inline bool lex_normal_map124(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 713, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
945, ';', 555, '<', 613, '>', 618, '?', 760, '@', 941, \
'\\', 188, '_', 948, '`', 855, '|', 593};
static uint32_t map[] = {'\n', 300, '"', 373, '#', 421, \
'$', 370, '&', 336, '\'', 201, '-', 476, '0', 386, ';', \
483, '<', 254, '>', 257, '\\', 147, '`', 417, 'e', 425, \
'|', 235, '[', 372, ']', 372, '{', 372, '}', 372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map256(t_lexer *lexer, \
static inline bool lex_normal_map125(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 714, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, ';', 555, '<', 609, '=', 952, \
'>', 617, '?', 761, '@', 942, '\\', 215, '_', 947, '`', \
855, '|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
static uint32_t map[] = {'\n', 301, '"', 373, '#', 421, \
'$', 370, '&', 336, '\'', 201, '(', 232, '-', 476, '0', \
385, ';', 483, '<', 254, '>', 257, '\\', 148, '`', 417, \
'e', 480, '|', 235, '[', 372, ']', 372, '{', 372, '}', \
372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif
#endif // INLINE_IMPL5_H

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

@ -19,65 +19,64 @@
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map257(t_lexer *lexer, \
static inline bool lex_normal_map126(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 715, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
803, ';', 554, '<', 609, '>', 617, '\\', 327, '`', 855, \
'e', 956, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
786};
static uint32_t map[] = {'\n', 302, '"', 373, '#', 421, \
'$', 370, '&', 336, '\'', 201, '(', 232, '-', 476, '0', \
385, ';', 483, '<', 254, '>', 257, '\\', 149, '`', 417, \
'|', 235, '[', 372, ']', 372, '{', 372, '}', 372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map258(t_lexer *lexer, \
static inline bool lex_normal_map127(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 716, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
945, ';', 555, '<', 613, '>', 618, '?', 760, '@', 941, \
'\\', 218, '_', 948, '|', 593};
static uint32_t map[] = {'\n', 303, '"', 373, '#', 421, \
'$', 370, '&', 336, '\'', 201, '-', 476, '0', 386, ';', \
483, '<', 254, '>', 257, '\\', 150, '`', 417, '|', 235, \
'[', 372, ']', 372, '{', 372, '}', 372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map259(t_lexer *lexer, \
static inline bool lex_normal_map128(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 717, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, ';', 554, '<', 609, '>', 617, \
'?', 761, '@', 942, '\\', 37, '_', 947, '`', 855, 'e', \
871, '|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
static uint32_t map[] = {'\n', 304, '"', 373, '#', 421, \
'$', 370, '&', 336, '\'', 201, ')', 237, '-', 476, '0', \
386, ';', 484, '<', 254, '>', 257, '\\', 151, '`', 417, \
'|', 235, '[', 372, ']', 372, '{', 372, '}', 372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map260(t_lexer *lexer, \
static inline bool lex_normal_map129(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 718, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
803, ';', 554, '<', 609, '>', 617, '\\', 328, '`', 855, \
'|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
static uint32_t map[] = {'\n', 305, '"', 373, '#', 421, \
'$', 370, '&', 336, '\'', 201, '(', 232, ')', 237, '-', \
476, '0', 385, ';', 484, '<', 254, '>', 257, '\\', 152, \
'`', 417, '|', 235, '[', 372, ']', 372, '{', 372, '}', \
372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map261(t_lexer *lexer, \
static inline bool lex_normal_map130(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 719, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 602, ')', 655, '*', 637, '-', \
632, '0', 945, ';', 555, '<', 613, '>', 618, '?', 760, \
'@', 941, '\\', 190, '_', 948, '|', 593};
static uint32_t map[] = {'\n', 306, '"', 373, '#', 421, \
'$', 370, '&', 333, '\'', 201, '(', 232, '-', 476, '0', \
385, ';', 484, '\\', 156, '`', 416, 'e', 480, '[', 372, \
']', 372, '{', 372, '}', 372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif
#endif // INLINE_IMPL6_H

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

@ -19,67 +19,68 @@
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map262(t_lexer *lexer, \
static inline bool lex_normal_map131(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 720, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, ';', 554, '<', 610, '>', 617, \
'?', 761, '@', 942, '\\', 222, '_', 947, '`', 855, 'e', \
871, '|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
static uint32_t map[] = {'\n', 307, '"', 373, '#', 421, \
'$', 370, '&', 333, '\'', 201, '-', 476, '0', 385, ';', \
484, '\\', 161, '`', 416, '[', 372, ']', 372, '{', 372, \
'}', 372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map263(t_lexer *lexer, \
static inline bool lex_normal_map132(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 721, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
803, ';', 554, '<', 610, '>', 617, '\\', 397, '`', 855, \
'e', 956, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
786};
static uint32_t map[] = {'\n', 308, '"', 373, '#', 421, \
'$', 370, '&', 333, '\'', 201, '-', 476, '0', 385, ';', \
484, '\\', 163, '`', 417, '[', 372, ']', 372, '{', 372, \
'}', 372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map264(t_lexer *lexer, \
static inline bool lex_normal_map170(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 722, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 489, '*', 637, '-', 632, '0', \
945, '<', 612, '>', 618, '?', 760, '@', 941, '\\', 106, \
'_', 948, '|', 593};
static uint32_t map[] = {'!', 248, '"', 373, '#', 396, \
'$', 370, '%', 351, '&', 335, '\'', 201, '(', 232, ')', \
237, '*', 346, '+', 363, ',', 311, '-', 361, '/', 349, \
'0', 470, ':', 358, ';', 483, '<', 253, '=', 251, '>', \
256, '?', 355, '@', 468, '[', 372, '\\', 133, ']', 485, \
'^', 331, '_', 472, '`', 417, 'e', 480, 'i', 479, '{', \
242, '|', 234, '}', 398, '~', 365};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map265(t_lexer *lexer, \
static inline bool lex_normal_map171(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 723, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, ';', 554, '<', 609, '>', 617, \
'?', 761, '@', 942, '\\', 43, '_', 947, '`', 855, '|', \
593, '[', 786, ']', 786, '{', 786, '}', 786};
static uint32_t map[] = {'!', 248, '"', 373, '#', 396, \
'$', 370, '&', 199, '\'', 201, '(', 232, '*', 348, '-', \
344, '0', 469, '<', 254, '>', 257, '?', 355, '@', 468, \
'\\', 31, '_', 473, '`', 416, '|', 235, '[', 372, ']', \
372, '{', 372, '}', 372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map266(t_lexer *lexer, \
static inline bool lex_normal_map172(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 724, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, ')', 655, '-', \
950, '0', 803, ';', 555, '<', 609, '>', 617, '\\', 331, \
'`', 855, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
786};
static uint32_t map[] = {'!', 248, '"', 373, '#', 396, \
'$', 370, '&', 199, '\'', 201, '*', 348, '-', 344, '0', \
469, '<', 254, '>', 257, '?', 355, '@', 468, '\\', 36, \
'_', 473, '`', 416, '|', 235, '[', 372, ']', 372, '{', \
372, '}', 372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif
#endif // INLINE_IMPL7_H

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

@ -19,65 +19,65 @@
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map267(t_lexer *lexer, \
static inline bool lex_normal_map173(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 725, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 489, '*', 637, '-', 632, '0', \
945, '<', 613, '>', 618, '?', 760, '@', 941, '\\', 193, \
'_', 948, '|', 593};
static uint32_t map[] = {'!', 248, '"', 373, '#', 396, \
'$', 370, '&', 206, '\'', 201, '*', 348, '-', 344, '0', \
469, '<', 252, '>', 257, '?', 355, '@', 468, '\\', 38, \
'_', 473, '`', 416, '[', 372, ']', 372, '{', 372, '}', \
372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map268(t_lexer *lexer, \
static inline bool lex_normal_map174(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 726, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, ')', \
655, '*', 640, '-', 636, '0', 943, ';', 555, '<', 609, \
'>', 617, '?', 761, '@', 942, '\\', 46, '_', 947, '`', \
855, '|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
static uint32_t map[] = {'!', 248, '"', 373, '#', 421, \
'$', 370, '&', 199, '\'', 201, '(', 232, ')', 237, '-', \
476, '0', 385, ';', 200, '<', 254, '>', 257, '\\', 135, \
'`', 416, '{', 242, '|', 235, '[', 372, ']', 372, '}', \
372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map269(t_lexer *lexer, \
static inline bool lex_normal_map175(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 727, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
803, ';', 554, '<', 610, '>', 617, '\\', 398, '`', 855, \
'|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
static uint32_t map[] = {'!', 248, '"', 373, '#', 421, \
'$', 370, '&', 206, '\'', 201, '(', 232, ')', 237, '-', \
476, '0', 385, ';', 200, '<', 252, '>', 257, '\\', 137, \
'`', 416, 'e', 480, '{', 242, '|', 233, '[', 372, ']', \
372, '}', 372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map270(t_lexer *lexer, \
static inline bool lex_normal_map176(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 728, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 489, '*', 637, '-', 632, '0', \
945, '<', 611, '>', 618, '?', 760, '@', 941, '\\', 213, \
'_', 948, '|', 516};
static uint32_t map[] = {'!', 248, '"', 373, '#', 421, \
'$', 370, '&', 206, '\'', 201, '(', 232, '-', 476, '0', \
385, '<', 252, '>', 257, '\\', 138, '`', 416, '{', 242, \
'}', 243, '[', 372, ']', 372};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map271(t_lexer *lexer, \
static inline bool lex_normal_map177(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 729, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, ';', 554, '<', 610, '>', 617, \
'?', 761, '@', 942, '\\', 226, '_', 947, '`', 855, '|', \
593, '[', 786, ']', 786, '{', 786, '}', 786};
static uint32_t map[] = {'!', 247, '"', 373, '#', 396, \
'$', 369, '*', 345, '-', 342, '0', 471, '?', 354, '@', \
467, '\\', 69, '_', 474};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif
#endif // INLINE_IMPL8_H

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

@ -19,66 +19,57 @@
# include "../../../headers/constants.h"
# include "../../../../parse_types.h"
static inline bool lex_normal_map272(t_lexer *lexer, \
static inline bool lex_normal_map178(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 730, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, ')', 655, '-', \
950, '0', 803, ';', 555, '<', 610, '>', 617, '\\', 399, \
'`', 855, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
786};
static uint32_t map[] = {'!', 247, '"', 373, '#', 421, \
'$', 371, '(', 232, ')', 237, '+', 364, '-', 362, '0', \
390, '=', 249};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map273(t_lexer *lexer, \
static inline bool lex_normal_map179(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 731, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 599, '*', 637, '-', 632, '0', \
945, ';', 555, '?', 760, '@', 941, '\\', 128, '_', 948, \
'i', 876};
static uint32_t map[] = {'!', 247, '#', 396, '$', 369, \
'&', 199, '*', 345, '-', 342, '0', 471, '<', 254, '>', \
257, '?', 354, '@', 467, '\\', 54, '_', 474, '|', 235};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map274(t_lexer *lexer, \
static inline bool lex_normal_map180(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 732, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, ';', 555, '<', 609, '>', 617, \
'?', 761, '@', 942, '\\', 166, '_', 947, '`', 855, '|', \
593, '[', 786, ']', 786, '{', 786, '}', 786};
static uint32_t map[] = {'!', 247, '#', 396, '$', 369, \
')', 237, '*', 345, '-', 342, '0', 471, '?', 354, '@', \
467, '\\', 71, '_', 474, '|', 233};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map275(t_lexer *lexer, \
static inline bool lex_normal_map181(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 733, '"', 788, '#', 862, \
'$', 781, '&', 489, '\'', 491, '(', 494, '-', 950, '0', \
803, '<', 608, '>', 617, '\\', 333, '`', 855, '|', 593, \
'[', 786, ']', 786, '{', 786, '}', 786};
static uint32_t map[] = {'!', 247, '#', 396, '$', 369, \
'*', 345, '-', 342, '0', 471, '?', 354, '@', 467, '\\', \
73, '_', 474};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map276(t_lexer *lexer, \
static inline bool lex_normal_map182(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 734, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 489, '\'', 491, '(', 654, '*', \
640, '-', 636, '0', 943, '<', 609, '=', 952, '>', 617, \
'?', 761, '@', 942, '\\', 48, '_', 947, '`', 855, '|', \
593, '[', 786, ']', 786, '{', 786, '}', 786};
static uint32_t map[] = {'!', 247, '#', 396, '$', 369, \
'*', 345, '-', 342, '0', 471, '?', 354, '@', 467};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif
#endif // INLINE_IMPL9_H