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

Started working on ast

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -1,31 +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_map508(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 282, '#', 534, '-', 520, \
'0', 403, '\\', 132, 'e', 528, 'f', 525, '{', 276};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif // INLINE_IMPL20_H

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

42
parser/static/lex_funcs/lex_normal/state_35.c
View file

@ -15,59 +15,59 @@
bool lex_normal_s175(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(82, lexer, s));
return (lex_skip(103, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(518, lexer, s));
return (lex_advance(494, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(206, lexer, s));
return (lex_skip(121, lexer, s));
if (s->lookahead != 0)
return (lex_advance(533, lexer, s));
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s176(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(82, lexer, s));
return (lex_skip(103, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(206, lexer, s));
return (lex_skip(121, lexer, s));
if (s->lookahead != 0)
return (lex_advance(533, lexer, s));
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s177(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(86, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(199, lexer, s));
return (lex_skip(81, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(515, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(209, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s178(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(87, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(519, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(207, lexer, s));
return (lex_skip(81, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(209, lexer, s));
if (s->lookahead != 0)
return (lex_advance(533, lexer, s));
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s179(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(87, lexer, s));
return (lex_skip(82, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(207, lexer, s));
if (s->lookahead != 0)
return (lex_advance(533, lexer, s));
return (lex_skip(216, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -15,64 +15,54 @@
bool lex_normal_s180(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(91, lexer, s));
return (lex_skip(86, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(205, lexer, s));
return (lex_skip(202, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s181(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(92, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(208, lexer, s));
return (lex_skip(87, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(516, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(210, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s182(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\r')
return (lex_skip(93, lexer, s));
return (lex_skip(87, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(68, lexer, s));
return (lex_skip(210, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s183(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map183(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
if (s->lookahead == '\r')
return (lex_skip(91, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(183, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(503, lexer, s));
if (s->lookahead != 0)
return (lex_advance(533, lexer, s));
return (lex_skip(208, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s184(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map184(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
if (s->lookahead == '\r')
return (lex_skip(92, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(184, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(506, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(405, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(443, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '|'))
return (lex_advance(533, lexer, s));
return (lex_skip(211, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -14,22 +14,11 @@
bool lex_normal_s185(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map185(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
if (s->lookahead == '\r')
return (lex_skip(93, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(185, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(504, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(405, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(443, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*') && s->lookahead != ';' && s->lookahead \
!= '<'))
return (lex_advance(533, lexer, s));
return (lex_skip(66, lexer, s));
return (lex_end_state(lexer, s));
}
@ -41,16 +30,11 @@ bool lex_normal_s186(t_lexer *lexer, t_lexer_state *s)
s->lookahead == ' '))
return (lex_skip(186, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(505, lexer, s));
return (lex_advance(499, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(405, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(443, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*') && s->lookahead != ';' && s->lookahead \
!= '<'))
return (lex_advance(533, lexer, s));
return (lex_advance(407, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
@ -62,12 +46,16 @@ bool lex_normal_s187(t_lexer *lexer, t_lexer_state *s)
s->lookahead == ' '))
return (lex_skip(187, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(507, lexer, s));
return (lex_advance(502, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(404, lexer, s));
if ((s->lookahead != 0 && s->lookahead != '{' && \
s->lookahead != '|'))
return (lex_advance(533, lexer, s));
return (lex_advance(408, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(440, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '|'))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
@ -79,13 +67,16 @@ bool lex_normal_s188(t_lexer *lexer, t_lexer_state *s)
s->lookahead == ' '))
return (lex_skip(188, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(512, lexer, s));
return (lex_advance(500, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(404, lexer, s));
return (lex_advance(408, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(440, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != '{' && s->lookahead \
!= '|'))
return (lex_advance(533, lexer, s));
s->lookahead < '*') && s->lookahead != ';' && s->lookahead \
!= '<'))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
@ -97,12 +88,15 @@ bool lex_normal_s189(t_lexer *lexer, t_lexer_state *s)
s->lookahead == ' '))
return (lex_skip(189, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(508, lexer, s));
return (lex_advance(501, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(404, lexer, s));
return (lex_advance(408, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(440, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '{' && s->lookahead != '|'))
return (lex_advance(533, lexer, s));
s->lookahead < '*') && s->lookahead != ';' && s->lookahead \
!= '<'))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -20,13 +20,12 @@ bool lex_normal_s190(t_lexer *lexer, t_lexer_state *s)
s->lookahead == ' '))
return (lex_skip(190, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(509, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(404, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '{' && s->lookahead != '|'))
return (lex_advance(533, lexer, s));
return (lex_advance(503, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(407, lexer, s));
if ((s->lookahead != 0 && s->lookahead != '{' && \
s->lookahead != '|'))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
@ -38,13 +37,13 @@ bool lex_normal_s191(t_lexer *lexer, t_lexer_state *s)
s->lookahead == ' '))
return (lex_skip(191, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(510, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(404, lexer, s));
return (lex_advance(508, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(407, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && (s->lookahead > '{' && s->lookahead < '}')))
return (lex_advance(533, lexer, s));
s->lookahead < ')') && s->lookahead != '{' && s->lookahead \
!= '|'))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
@ -56,13 +55,13 @@ bool lex_normal_s192(t_lexer *lexer, t_lexer_state *s)
s->lookahead == ' '))
return (lex_skip(192, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(511, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(404, lexer, s));
return (lex_advance(504, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(407, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '{' && s->lookahead != '|'))
return (lex_advance(533, lexer, s));
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
@ -70,23 +69,17 @@ bool lex_normal_s193(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map193(lexer, s))
return (true);
if (s->lookahead == '\\')
return (lex_skip(157, lexer, s));
if (s->lookahead == '^')
return (lex_advance(351, lexer, s));
if (s->lookahead == '`')
return (lex_advance(222, lexer, s));
if (s->lookahead == '|')
return (lex_advance(271, lexer, s));
if (s->lookahead == '}')
return (lex_advance(277, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
return (lex_skip(193, lexer, s));
if (((s->lookahead >= '0' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= '_' && s->lookahead <= 'z')))
return (lex_advance(449, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(505, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(407, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '{' && s->lookahead != '|'))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
@ -94,17 +87,16 @@ bool lex_normal_s194(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map194(lexer, s))
return (true);
if ((s->lookahead == '\n' || s->lookahead == '\r'))
return (lex_skip(194, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
return (lex_advance(396, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(449, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '_' && \
s->lookahead < 'z')))
return (lex_advance(399, lexer, s));
return (lex_skip(194, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(506, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(407, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && (s->lookahead > '{' && s->lookahead < '}')))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -16,22 +16,17 @@ bool lex_normal_s195(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map195(lexer, s))
return (true);
if (s->lookahead == '\\')
return (lex_skip(162, lexer, s));
if (s->lookahead == '`')
return (lex_advance(432, lexer, s));
if (s->lookahead == '|')
return (lex_advance(272, lexer, s));
if (s->lookahead == '~')
return (lex_advance(384, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
return (lex_skip(195, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(507, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(407, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= '_' && s->lookahead <= 'z')))
return (lex_advance(449, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '{' && s->lookahead != '|'))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
@ -39,13 +34,23 @@ bool lex_normal_s196(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map196(lexer, s))
return (true);
if (s->lookahead == '\\')
return (lex_skip(158, lexer, s));
if (s->lookahead == '^')
return (lex_advance(355, lexer, s));
if (s->lookahead == '`')
return (lex_advance(226, lexer, s));
if (s->lookahead == '|')
return (lex_advance(275, lexer, s));
if (s->lookahead == '}')
return (lex_advance(281, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(196, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
if (((s->lookahead >= '0' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(449, lexer, s));
(s->lookahead >= '_' && s->lookahead <= 'z')))
return (lex_advance(445, lexer, s));
return (lex_end_state(lexer, s));
}
@ -53,13 +58,18 @@ bool lex_normal_s197(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map197(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
if ((s->lookahead == '\n' || s->lookahead == '\r'))
return (lex_skip(197, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_advance(400, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(449, lexer, s));
return (lex_advance(445, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '_' && \
s->lookahead < 'z')))
return (lex_advance(403, lexer, s));
return (lex_end_state(lexer, s));
}
@ -67,19 +77,22 @@ bool lex_normal_s198(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map198(lexer, s))
return (true);
if ((s->lookahead == '\n' || s->lookahead == '\r'))
return (lex_skip(198, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
if (s->lookahead == '\\')
return (lex_skip(163, lexer, s));
if (s->lookahead == '`')
return (lex_advance(430, lexer, s));
if (s->lookahead == '|')
return (lex_advance(276, lexer, s));
if (s->lookahead == '~')
return (lex_advance(388, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_advance(397, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(449, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > ' ' && \
s->lookahead < '$') && (s->lookahead > '_' && s->lookahead \
< 'z')))
return (lex_advance(399, lexer, s));
return (lex_skip(198, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(409, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= '_' && s->lookahead <= 'z')))
return (lex_advance(445, lexer, s));
return (lex_end_state(lexer, s));
}
@ -87,18 +100,12 @@ bool lex_normal_s199(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map199(lexer, s))
return (true);
if (s->lookahead == '\\')
return (lex_skip(177, lexer, s));
if (s->lookahead == '_')
return (lex_advance(482, lexer, s));
if (s->lookahead == '}')
return (lex_advance(277, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(199, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(449, lexer, s));
return (lex_advance(445, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -15,57 +15,57 @@
bool lex_normal_s20(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(455, lexer, s));
return (lex_advance(448, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s21(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(455, lexer, s));
return (lex_advance(448, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(20, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(489, lexer, s));
return (lex_advance(481, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(108, lexer, s));
return (lex_skip(94, lexer, s));
if (s->lookahead != 0)
return (lex_advance(533, lexer, s));
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s22(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(455, lexer, s));
return (lex_advance(448, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(20, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(108, lexer, s));
return (lex_skip(94, lexer, s));
if (s->lookahead != 0)
return (lex_advance(533, lexer, s));
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s23(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(457, lexer, s));
return (lex_advance(451, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s24(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(457, lexer, s));
return (lex_advance(451, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(23, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(492, lexer, s));
return (lex_advance(485, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(112, lexer, s));
return (lex_skip(109, lexer, s));
if (s->lookahead != 0)
return (lex_advance(533, lexer, s));
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}

68
parser/static/lex_funcs/lex_normal/state_40.c
View file

@ -22,7 +22,7 @@ bool lex_normal_s200(t_lexer *lexer, t_lexer_state *s)
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(449, lexer, s));
return (lex_advance(445, lexer, s));
return (lex_end_state(lexer, s));
}
@ -30,17 +30,19 @@ bool lex_normal_s201(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map201(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
if ((s->lookahead == '\n' || s->lookahead == '\r'))
return (lex_skip(201, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(513, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(404, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '{' && s->lookahead != '|'))
return (lex_advance(533, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_advance(401, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(445, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > ' ' && \
s->lookahead < '$') && (s->lookahead > '_' && s->lookahead \
< 'z')))
return (lex_advance(403, lexer, s));
return (lex_end_state(lexer, s));
}
@ -48,17 +50,19 @@ bool lex_normal_s202(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map202(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
if (s->lookahead == '\\')
return (lex_skip(180, lexer, s));
if (s->lookahead == '_')
return (lex_advance(478, lexer, s));
if (s->lookahead == '}')
return (lex_advance(281, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(202, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(514, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(404, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<'))
return (lex_advance(533, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(445, lexer, s));
return (lex_end_state(lexer, s));
}
@ -66,17 +70,13 @@ bool lex_normal_s203(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map203(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(203, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(515, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(404, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<'))
return (lex_advance(533, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(445, lexer, s));
return (lex_end_state(lexer, s));
}
@ -88,12 +88,12 @@ bool lex_normal_s204(t_lexer *lexer, t_lexer_state *s)
s->lookahead == ' '))
return (lex_skip(204, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(516, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(404, lexer, s));
return (lex_advance(509, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(407, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '>' && s->lookahead != '|'))
return (lex_advance(533, lexer, s));
!= '<' && s->lookahead != '{' && s->lookahead != '|'))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -14,115 +14,105 @@
bool lex_normal_s205(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '"')
return (lex_advance(391, lexer, s));
if (s->lookahead == '#')
return (lex_advance(437, lexer, s));
if (s->lookahead == '$')
return (lex_advance(216, lexer, s));
if (s->lookahead == ')')
return (lex_advance(273, lexer, s));
if (s->lookahead == '\\')
return (lex_skip(180, lexer, s));
if (s->lookahead == '`')
return (lex_advance(432, lexer, s));
if (s->lookahead == '|')
return (lex_advance(268, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
if (lex_normal_map205(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
return (lex_skip(205, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(510, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(407, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<'))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s206(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '"')
return (lex_advance(391, lexer, s));
if (s->lookahead == '#')
return (lex_advance(437, lexer, s));
if (s->lookahead == '$')
return (lex_advance(390, lexer, s));
if (s->lookahead == '\'')
return (lex_advance(215, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(176, lexer, s));
if (s->lookahead == '`')
return (lex_advance(432, lexer, s));
if (s->lookahead == '}')
return (lex_advance(278, lexer, s));
if (lex_normal_map206(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
return (lex_skip(206, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(518, lexer, s));
return (lex_advance(511, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(407, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '>' && s->lookahead != '|' && \
s->lookahead != '}'))
return (lex_advance(533, lexer, s));
!= '<'))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s207(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '"')
return (lex_advance(391, lexer, s));
if (s->lookahead == '#')
return (lex_advance(437, lexer, s));
if (s->lookahead == '$')
return (lex_advance(390, lexer, s));
if (s->lookahead == '\'')
return (lex_advance(215, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(179, lexer, s));
if (s->lookahead == '`')
return (lex_advance(432, lexer, s));
if (lex_normal_map207(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
return (lex_skip(207, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(519, lexer, s));
return (lex_advance(512, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(407, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '>' && s->lookahead != '|'))
return (lex_advance(533, lexer, s));
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s208(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '"')
return (lex_advance(391, lexer, s));
return (lex_advance(395, lexer, s));
if (s->lookahead == '#')
return (lex_advance(437, lexer, s));
if (s->lookahead == '\'')
return (lex_advance(215, lexer, s));
return (lex_advance(435, lexer, s));
if (s->lookahead == '$')
return (lex_advance(220, lexer, s));
if (s->lookahead == ')')
return (lex_advance(273, lexer, s));
if (s->lookahead == '\\')
return (lex_skip(181, lexer, s));
if (s->lookahead == '}')
return (lex_advance(277, lexer, s));
if (s->lookahead == '\\')
return (lex_skip(183, lexer, s));
if (s->lookahead == '`')
return (lex_advance(430, lexer, s));
if (s->lookahead == '|')
return (lex_advance(272, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_advance(429, lexer, s));
return (lex_skip(208, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s209(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map209(lexer, s))
return (true);
if (s->lookahead == '"')
return (lex_advance(395, lexer, s));
if (s->lookahead == '#')
return (lex_advance(435, lexer, s));
if (s->lookahead == '$')
return (lex_advance(394, lexer, s));
if (s->lookahead == '\'')
return (lex_advance(219, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(178, lexer, s));
if (s->lookahead == '`')
return (lex_advance(430, lexer, s));
if (s->lookahead == '}')
return (lex_advance(282, lexer, s));
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
return (lex_skip(209, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(517, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(404, lexer, s));
return (lex_advance(515, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '>' && s->lookahead != '|'))
return (lex_advance(533, lexer, s));
!= '<' && s->lookahead != '>' && s->lookahead != '|' && \
s->lookahead != '}'))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -15,98 +15,123 @@
bool lex_normal_s210(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '"')
return (lex_advance(391, lexer, s));
return (lex_advance(395, lexer, s));
if (s->lookahead == '#')
return (lex_advance(401, lexer, s));
return (lex_advance(435, lexer, s));
if (s->lookahead == '$')
return (lex_advance(389, lexer, s));
return (lex_advance(394, lexer, s));
if (s->lookahead == '\'')
return (lex_advance(219, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(134, lexer, s));
return (lex_advance(182, lexer, s));
if (s->lookahead == '`')
return (lex_advance(432, lexer, s));
if ((s->lookahead == '\n' || s->lookahead == '\r'))
return (lex_skip(210, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
return (lex_advance(430, lexer, s));
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
return (lex_advance(398, lexer, s));
if (s->lookahead != 0)
return (lex_advance(399, lexer, s));
return (lex_skip(210, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(516, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '>' && s->lookahead != '|'))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s211(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '"')
return (lex_advance(395, lexer, s));
if (s->lookahead == '#')
return (lex_advance(412, lexer, s));
if (s->lookahead == '%')
return (lex_advance(371, lexer, s));
if (s->lookahead == '+')
return (lex_advance(426, lexer, s));
if (s->lookahead == '-')
return (lex_advance(416, lexer, s));
if (s->lookahead == ':')
return (lex_advance(218, lexer, s));
if (s->lookahead == '=')
return (lex_advance(419, lexer, s));
if (s->lookahead == '?')
return (lex_advance(423, lexer, s));
if (s->lookahead == '\\')
return (lex_skip(174, lexer, s));
if (s->lookahead == '}')
return (lex_advance(435, lexer, s));
if (s->lookahead == '\'')
return (lex_advance(219, lexer, s));
if (s->lookahead == ')')
return (lex_advance(277, lexer, s));
if (s->lookahead == '\\')
return (lex_skip(184, lexer, s));
if (s->lookahead == '}')
return (lex_advance(281, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(212, lexer, s));
return (lex_advance(427, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s212(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '"')
return (lex_advance(395, lexer, s));
if (s->lookahead == '#')
return (lex_advance(412, lexer, s));
if (s->lookahead == '%')
return (lex_advance(371, lexer, s));
return (lex_advance(436, lexer, s));
if (s->lookahead == '$')
return (lex_advance(393, lexer, s));
if (s->lookahead == '\'')
return (lex_advance(219, lexer, s));
if (s->lookahead == '\\')
return (lex_skip(174, lexer, s));
if (s->lookahead == '}')
return (lex_advance(277, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
return (lex_advance(172, lexer, s));
if (s->lookahead == '`')
return (lex_advance(431, lexer, s));
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
return (lex_skip(212, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(513, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(407, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '>' && s->lookahead != '|'))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s213(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '"')
return (lex_advance(395, lexer, s));
if (s->lookahead == '#')
return (lex_advance(437, lexer, s));
if (s->lookahead == '&')
return (lex_advance(214, lexer, s));
if (s->lookahead == ')')
return (lex_advance(273, lexer, s));
if (s->lookahead == '<')
return (lex_advance(288, lexer, s));
if (s->lookahead == '>')
return (lex_advance(291, lexer, s));
return (lex_advance(436, lexer, s));
if (s->lookahead == '$')
return (lex_advance(393, lexer, s));
if (s->lookahead == '\'')
return (lex_advance(219, lexer, s));
if (s->lookahead == '\\')
return (lex_skip(169, lexer, s));
return (lex_advance(174, lexer, s));
if (s->lookahead == '`')
return (lex_advance(222, lexer, s));
if (s->lookahead == '|')
return (lex_advance(272, lexer, s));
if (s->lookahead == '}')
return (lex_advance(277, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
return (lex_advance(430, lexer, s));
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
return (lex_skip(213, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(514, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(407, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < ')') && s->lookahead != ';' && s->lookahead \
!= '<' && s->lookahead != '>' && s->lookahead != '|'))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s214(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '&')
return (lex_advance(279, lexer, s));
if (s->lookahead == '>')
return (lex_advance(295, lexer, s));
if (s->lookahead == '"')
return (lex_advance(395, lexer, s));
if (s->lookahead == '#')
return (lex_advance(405, lexer, s));
if (s->lookahead == '$')
return (lex_advance(393, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(135, lexer, s));
if (s->lookahead == '`')
return (lex_advance(430, lexer, s));
if ((s->lookahead == '\n' || s->lookahead == '\r'))
return (lex_skip(214, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_advance(402, lexer, s));
if (s->lookahead != 0)
return (lex_advance(403, lexer, s));
return (lex_end_state(lexer, s));
}

79
parser/static/lex_funcs/lex_normal/state_43.c
View file

@ -14,45 +14,86 @@
bool lex_normal_s215(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\'')
return (lex_advance(402, lexer, s));
if (s->lookahead != 0)
return (lex_advance(215, lexer, s));
if (s->lookahead == '#')
return (lex_advance(410, lexer, s));
if (s->lookahead == '%')
return (lex_advance(375, lexer, s));
if (s->lookahead == '+')
return (lex_advance(424, lexer, s));
if (s->lookahead == '-')
return (lex_advance(414, lexer, s));
if (s->lookahead == ':')
return (lex_advance(222, lexer, s));
if (s->lookahead == '=')
return (lex_advance(417, lexer, s));
if (s->lookahead == '?')
return (lex_advance(421, lexer, s));
if (s->lookahead == '\\')
return (lex_skip(179, lexer, s));
if (s->lookahead == '}')
return (lex_advance(281, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(216, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s216(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '(')
return (lex_advance(430, lexer, s));
if (s->lookahead == '{')
return (lex_advance(414, lexer, s));
if (s->lookahead == '#')
return (lex_advance(410, lexer, s));
if (s->lookahead == '%')
return (lex_advance(375, lexer, s));
if (s->lookahead == '\\')
return (lex_skip(179, lexer, s));
if (s->lookahead == '}')
return (lex_advance(281, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(216, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s217(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '#')
return (lex_advance(435, lexer, s));
if (s->lookahead == '&')
return (lex_advance(218, lexer, s));
if (s->lookahead == ')')
return (lex_advance(335, lexer, s));
return (lex_advance(277, lexer, s));
if (s->lookahead == '<')
return (lex_advance(292, lexer, s));
if (s->lookahead == '>')
return (lex_advance(295, lexer, s));
if (s->lookahead == '\\')
return (lex_skip(170, lexer, s));
if (s->lookahead == '`')
return (lex_advance(226, lexer, s));
if (s->lookahead == '|')
return (lex_advance(276, lexer, s));
if (s->lookahead == '}')
return (lex_advance(281, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(217, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s218(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '+')
return (lex_advance(425, lexer, s));
if (s->lookahead == '-')
return (lex_advance(415, lexer, s));
if (s->lookahead == '=')
return (lex_advance(417, lexer, s));
if (s->lookahead == '?')
return (lex_advance(421, lexer, s));
if (s->lookahead == '&')
return (lex_advance(283, lexer, s));
if (s->lookahead == '>')
return (lex_advance(299, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s219(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == ';')
return (lex_advance(275, lexer, s));
if (s->lookahead == '\'')
return (lex_advance(406, lexer, s));
if (s->lookahead != 0)
return (lex_advance(219, lexer, s));
return (lex_end_state(lexer, s));
}

31
parser/static/lex_funcs/lex_normal/state_44.c
View file

@ -14,38 +14,43 @@
bool lex_normal_s220(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '=')
return (lex_advance(357, lexer, s));
if (s->lookahead == '(')
return (lex_advance(428, lexer, s));
if (s->lookahead == '{')
return (lex_advance(412, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s221(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '>')
return (lex_advance(295, lexer, s));
if (s->lookahead == ')')
return (lex_advance(339, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s222(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '`')
return (lex_advance(387, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_advance(222, lexer, s));
if (s->lookahead == '+')
return (lex_advance(423, lexer, s));
if (s->lookahead == '-')
return (lex_advance(413, lexer, s));
if (s->lookahead == '=')
return (lex_advance(415, lexer, s));
if (s->lookahead == '?')
return (lex_advance(419, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s223(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'a')
return (lex_advance(224, lexer, s));
if (s->lookahead == ';')
return (lex_advance(279, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s224(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'c')
return (lex_advance(263, lexer, s));
if (s->lookahead == '=')
return (lex_advance(361, lexer, s));
return (lex_end_state(lexer, s));
}

27
parser/static/lex_funcs/lex_normal/state_45.c
View file

@ -14,39 +14,38 @@
bool lex_normal_s225(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'e')
return (lex_advance(261, lexer, s));
if (s->lookahead == '>')
return (lex_advance(299, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s226(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'f')
return (lex_advance(259, lexer, s));
if (s->lookahead == '`')
return (lex_advance(391, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_advance(226, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s227(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'i')
return (lex_advance(257, lexer, s));
if (s->lookahead == 'a')
return (lex_advance(228, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s228(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'i')
return (lex_advance(226, lexer, s));
if (s->lookahead == 's')
return (lex_advance(225, lexer, s));
if (s->lookahead == 'c')
return (lex_advance(267, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s229(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'l')
return (lex_advance(228, lexer, s));
if (s->lookahead == 's')
return (lex_advance(223, lexer, s));
if (s->lookahead == 'e')
return (lex_advance(265, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -14,36 +14,39 @@
bool lex_normal_s230(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'n')
return (lex_advance(252, lexer, s));
if (s->lookahead == 'f')
return (lex_advance(263, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s231(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'o')
return (lex_advance(255, lexer, s));
if (s->lookahead == 'i')
return (lex_advance(261, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s232(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'i')
return (lex_advance(230, lexer, s));
if (s->lookahead == 's')
return (lex_advance(223, lexer, s));
return (lex_advance(229, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s233(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '|')
return (lex_advance(280, lexer, s));
if (s->lookahead == 'l')
return (lex_advance(232, lexer, s));
if (s->lookahead == 's')
return (lex_advance(227, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s234(t_lexer *lexer, t_lexer_state *s)
{
if ((s->lookahead != 0 && (s->lookahead > '\t' && \
s->lookahead < '\r')))
return (lex_advance(533, lexer, s));
if (s->lookahead == 'n')
return (lex_advance(256, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -14,65 +14,50 @@
bool lex_normal_s235(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(251, lexer, s));
if (s->lookahead == '\n')
return (lex_skip(250, lexer, s));
if (s->lookahead == 'o')
return (lex_advance(259, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s236(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(251, lexer, s));
if (s->lookahead == '\n')
return (lex_skip(237, lexer, s));
if (s->lookahead == 's')
return (lex_advance(227, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s237(t_lexer *lexer, t_lexer_state *s)
{
bool ret;
if (lex_normal_s237_bis(lexer, s, &ret))
return (ret);
if (s->lookahead == '\\')
return (lex_skip(246, lexer, s));
if (s->lookahead == '`')
return (lex_advance(433, lexer, s));
if (s->lookahead == 'e')
return (lex_advance(232, lexer, s));
if (s->lookahead == '|')
return (lex_advance(272, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(237, lexer, s));
return (lex_advance(284, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s238(t_lexer *lexer, t_lexer_state *s)
{
bool ret;
if (lex_normal_s238_bis(lexer, s, &ret))
return (ret);
if (s->lookahead == '\\')
return (lex_skip(247, lexer, s));
if (s->lookahead == '`')
return (lex_advance(432, lexer, s));
if (s->lookahead == '|')
return (lex_advance(272, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(238, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '\t' && \
s->lookahead < '\r')))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s239(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(251, lexer, s));
if (s->lookahead == '\n')
return (lex_skip(238, lexer, s));
return (lex_advance(255, lexer, s));
if (lex_normal_map239(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(239, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(480, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(408, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(440, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*')))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -15,91 +15,95 @@
bool lex_normal_s240(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(251, lexer, s));
if (lex_normal_map240(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(240, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(487, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(404, lexer, s));
if (s->lookahead != 0)
return (lex_advance(533, lexer, s));
return (lex_advance(255, lexer, s));
if (s->lookahead == '\n')
return (lex_skip(254, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s241(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(251, lexer, s));
return (lex_advance(255, lexer, s));
if (lex_normal_map241(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(241, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(489, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(405, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(443, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*')))
return (lex_advance(533, lexer, s));
return (lex_advance(445, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s242(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(251, lexer, s));
if (lex_normal_map242(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(242, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(494, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(404, lexer, s));
if (s->lookahead != 0)
return (lex_advance(533, lexer, s));
return (lex_advance(255, lexer, s));
if (s->lookahead == '\n')
return (lex_skip(243, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s243(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(251, lexer, s));
if (lex_normal_map243(lexer, s))
return (true);
return (lex_advance(255, lexer, s));
if (s->lookahead == '\n')
return (lex_advance(312, lexer, s));
if (s->lookahead == '#')
return (lex_advance(435, lexer, s));
if (s->lookahead == '&')
return (lex_advance(359, lexer, s));
if (s->lookahead == ')')
return (lex_advance(277, lexer, s));
if (s->lookahead == ';')
return (lex_advance(530, lexer, s));
if (s->lookahead == '<')
return (lex_advance(292, lexer, s));
if (s->lookahead == '>')
return (lex_advance(295, lexer, s));
if (s->lookahead == '\\')
return (lex_skip(250, lexer, s));
if (s->lookahead == '`')
return (lex_advance(431, lexer, s));
if (s->lookahead == 'e')
return (lex_advance(236, lexer, s));
if (s->lookahead == '|')
return (lex_advance(276, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(243, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(449, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s244(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(251, lexer, s));
if (lex_normal_map244(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_advance(255, lexer, s));
if (s->lookahead == '\n')
return (lex_advance(312, lexer, s));
if (s->lookahead == '#')
return (lex_advance(435, lexer, s));
if (s->lookahead == '&')
return (lex_advance(359, lexer, s));
if (s->lookahead == ')')
return (lex_advance(277, lexer, s));
if (s->lookahead == ';')
return (lex_advance(530, lexer, s));
if (s->lookahead == '<')
return (lex_advance(292, lexer, s));
if (s->lookahead == '>')
return (lex_advance(295, lexer, s));
if (s->lookahead == '\\')
return (lex_skip(251, lexer, s));
if (s->lookahead == '`')
return (lex_advance(430, lexer, s));
if (s->lookahead == '|')
return (lex_advance(276, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(244, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(495, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(405, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(443, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*')))
return (lex_advance(533, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -15,70 +15,75 @@
bool lex_normal_s245(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(251, lexer, s));
if (s->lookahead == '\r')
return (lex_skip(235, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(250, lexer, s));
return (lex_advance(255, lexer, s));
if (s->lookahead == '\n')
return (lex_skip(244, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s246(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(251, lexer, s));
if (s->lookahead == '\r')
return (lex_skip(236, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(237, lexer, s));
return (lex_advance(255, lexer, s));
if (lex_normal_map246(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(246, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(483, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(407, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s247(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(251, lexer, s));
if (s->lookahead == '\r')
return (lex_skip(239, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(238, lexer, s));
return (lex_advance(255, lexer, s));
if (lex_normal_map247(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(247, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(490, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(407, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s248(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(251, lexer, s));
return (lex_advance(255, lexer, s));
if (lex_normal_map248(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
if ((s->lookahead == '\t' || s->lookahead == ' '))
return (lex_skip(248, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(503, lexer, s));
if (s->lookahead != 0)
return (lex_advance(533, lexer, s));
return (lex_advance(491, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(408, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(440, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*')))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s249(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(251, lexer, s));
if (lex_normal_map249(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
return (lex_advance(255, lexer, s));
if (s->lookahead == '\r')
return (lex_skip(240, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(249, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(507, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(404, lexer, s));
if ((s->lookahead != 0 && s->lookahead != '{' && \
s->lookahead != '|'))
return (lex_advance(533, lexer, s));
return (lex_skip(254, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -15,56 +15,56 @@
bool lex_normal_s25(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(457, lexer, s));
return (lex_advance(451, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(23, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(112, lexer, s));
return (lex_skip(109, lexer, s));
if (s->lookahead != 0)
return (lex_advance(533, lexer, s));
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s26(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(459, lexer, s));
return (lex_advance(452, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s27(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(459, lexer, s));
return (lex_advance(452, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(26, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(495, lexer, s));
return (lex_advance(488, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(116, lexer, s));
return (lex_skip(112, lexer, s));
if (s->lookahead != 0)
return (lex_advance(533, lexer, s));
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s28(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(459, lexer, s));
return (lex_advance(452, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(26, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(116, lexer, s));
return (lex_skip(112, lexer, s));
if (s->lookahead != 0)
return (lex_advance(533, lexer, s));
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s29(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(453, lexer, s));
return (lex_advance(454, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -14,53 +14,91 @@
bool lex_normal_s250(t_lexer *lexer, t_lexer_state *s)
{
bool ret;
if (lex_normal_s250_bis(lexer, s, &ret))
return (ret);
if (s->lookahead == 'i')
return (lex_advance(230, lexer, s));
if (s->lookahead == '|')
return (lex_advance(271, lexer, s));
if (s->lookahead == '}')
return (lex_advance(277, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
if (s->eof)
return (lex_advance(255, lexer, s));
if (s->lookahead == '\r')
return (lex_skip(242, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(250, lexer, s));
return (lex_skip(243, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s251(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(ts_builtin_sym_end, lexer, s);
if (s->eof)
return (lex_advance(255, lexer, s));
if (s->lookahead == '\r')
return (lex_skip(245, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(244, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s252(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_in, lexer, s);
if (s->eof)
return (lex_advance(255, lexer, s));
if (lex_normal_map252(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
return (lex_skip(252, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(499, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(407, lexer, s));
if (s->lookahead != 0)
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s253(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_in, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(234, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(533, lexer, s));
if (s->eof)
return (lex_advance(255, lexer, s));
if (lex_normal_map253(lexer, s))
return (true);
if ((s->lookahead == '\t' || s->lookahead == '\n' || \
s->lookahead == ' '))
return (lex_skip(253, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(503, lexer, s));
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(407, lexer, s));
if ((s->lookahead != 0 && s->lookahead != '{' && \
s->lookahead != '|'))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s254(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_in, lexer, s);
if (((s->lookahead >= '0' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
s->lookahead == '_' || (s->lookahead >= 'a' && \
s->lookahead <= 'z')))
return (lex_advance(449, lexer, s));
if (s->eof)
return (lex_advance(255, lexer, s));
if (lex_normal_map254(lexer, s))
return (true);
if (s->lookahead == '\\')
return (lex_skip(249, lexer, s));
if (s->lookahead == '^')
return (lex_advance(355, lexer, s));
if (s->lookahead == '`')
return (lex_advance(430, lexer, s));
if (s->lookahead == 'd')
return (lex_advance(235, lexer, s));
if (s->lookahead == 'e')
return (lex_advance(233, lexer, s));
if (s->lookahead == 'f')
return (lex_advance(231, lexer, s));
if (s->lookahead == 'i')
return (lex_advance(234, lexer, s));
if (s->lookahead == '|')
return (lex_advance(275, lexer, s));
if (s->lookahead == '}')
return (lex_advance(281, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(254, lexer, s));
return (lex_end_state(lexer, s));
}

33
parser/static/lex_funcs/lex_normal/state_51.c
View file

@ -14,42 +14,41 @@
bool lex_normal_s255(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_do, lexer, s);
lex_accept_token(ts_builtin_sym_end, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s256(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_do, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(234, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(533, lexer, s));
lex_accept_token(anon_sym_in, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s257(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_fi, lexer, s);
lex_accept_token(anon_sym_in, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(238, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s258(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_fi, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(234, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(533, lexer, s));
lex_accept_token(anon_sym_in, lexer, s);
if (((s->lookahead >= '0' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
s->lookahead == '_' || (s->lookahead >= 'a' && \
s->lookahead <= 'z')))
return (lex_advance(445, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s259(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_elif, lexer, s);
lex_accept_token(anon_sym_do, lexer, s);
return (lex_end_state(lexer, s));
}

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

@ -14,48 +14,48 @@
bool lex_normal_s260(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_elif, lexer, s);
lex_accept_token(anon_sym_do, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(234, lexer, s));
return (lex_advance(238, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(533, lexer, s));
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s261(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_else, lexer, s);
lex_accept_token(anon_sym_fi, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s262(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_else, lexer, s);
lex_accept_token(anon_sym_fi, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(234, lexer, s));
return (lex_advance(238, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(533, lexer, s));
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s263(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_esac, lexer, s);
lex_accept_token(anon_sym_elif, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s264(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_esac, lexer, s);
lex_accept_token(anon_sym_elif, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(234, lexer, s));
return (lex_advance(238, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(533, lexer, s));
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}

75
parser/static/lex_funcs/lex_normal/state_53.c
View file

@ -13,6 +13,42 @@
#include "./lex_normal_funcs.h"
bool lex_normal_s265(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_else, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s266(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_else, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(238, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s267(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_esac, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s268(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_esac, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(238, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s269(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_esac, lexer, s);
if (s->lookahead == '\\')
@ -21,45 +57,10 @@ bool lex_normal_s265(t_lexer *lexer, t_lexer_state *s)
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
s->lookahead == '_' || (s->lookahead >= 'a' && \
s->lookahead <= 'z')))
return (lex_advance(443, lexer, s));
return (lex_advance(440, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(533, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s266(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_esac, lexer, s);
if (((s->lookahead >= '0' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
s->lookahead == '_' || (s->lookahead >= 'a' && \
s->lookahead <= 'z')))
return (lex_advance(449, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s267(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LPAREN, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s268(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PIPE, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s269(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PIPE, lexer, s);
if (s->lookahead == '&')
return (lex_advance(333, lexer, s));
if (s->lookahead == '=')
return (lex_advance(349, lexer, s));
if (s->lookahead == '|')
return (lex_advance(280, lexer, s));
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}

39
parser/static/lex_funcs/lex_normal/state_54.c
View file

@ -14,46 +14,45 @@
bool lex_normal_s270(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PIPE, lexer, s);
if (s->lookahead == '&')
return (lex_advance(333, lexer, s));
if (s->lookahead == '|')
return (lex_advance(280, lexer, s));
lex_accept_token(anon_sym_esac, lexer, s);
if (((s->lookahead >= '0' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
s->lookahead == '_' || (s->lookahead >= 'a' && \
s->lookahead <= 'z')))
return (lex_advance(445, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s271(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PIPE, lexer, s);
if (s->lookahead == '=')
return (lex_advance(349, lexer, s));
if (s->lookahead == '|')
return (lex_advance(280, lexer, s));
lex_accept_token(anon_sym_LPAREN, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s272(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PIPE, lexer, s);
if (s->lookahead == '|')
return (lex_advance(280, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s273(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_RPAREN, lexer, s);
lex_accept_token(anon_sym_PIPE, lexer, s);
if (s->lookahead == '&')
return (lex_advance(337, lexer, s));
if (s->lookahead == '=')
return (lex_advance(353, lexer, s));
if (s->lookahead == '|')
return (lex_advance(284, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s274(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LF, lexer, s);
if (s->lookahead == '\n')
return (lex_advance(274, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(136, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(483, lexer, s));
lex_accept_token(anon_sym_PIPE, lexer, s);
if (s->lookahead == '&')
return (lex_advance(337, lexer, s));
if (s->lookahead == '|')
return (lex_advance(284, lexer, s));
return (lex_end_state(lexer, s));
}

32
parser/static/lex_funcs/lex_normal/state_55.c
View file

@ -14,42 +14,42 @@
bool lex_normal_s275(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_SEMI_SEMI, lexer, s);
lex_accept_token(anon_sym_PIPE, lexer, s);
if (s->lookahead == '=')
return (lex_advance(353, lexer, s));
if (s->lookahead == '|')
return (lex_advance(284, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s276(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LBRACE, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(234, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(533, lexer, s));
lex_accept_token(anon_sym_PIPE, lexer, s);
if (s->lookahead == '|')
return (lex_advance(284, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s277(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_RBRACE, lexer, s);
lex_accept_token(anon_sym_RPAREN, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s278(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_RBRACE, lexer, s);
lex_accept_token(anon_sym_LF, lexer, s);
if (s->lookahead == '\n')
return (lex_advance(278, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(234, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(533, lexer, s));
return (lex_advance(137, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(479, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s279(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_AMP_AMP, lexer, s);
lex_accept_token(anon_sym_SEMI_SEMI, lexer, s);
return (lex_end_state(lexer, s));
}

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

@ -14,38 +14,42 @@
bool lex_normal_s280(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PIPE_PIPE, lexer, s);
lex_accept_token(anon_sym_LBRACE, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(238, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s281(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_BANG, lexer, s);
lex_accept_token(anon_sym_RBRACE, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s282(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_BANG, lexer, s);
lex_accept_token(anon_sym_RBRACE, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(234, lexer, s));
return (lex_advance(238, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(533, lexer, s));
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s283(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_EQ, lexer, s);
lex_accept_token(anon_sym_AMP_AMP, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s284(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_EQ, lexer, s);
if (s->lookahead == '=')
return (lex_advance(356, lexer, s));
lex_accept_token(anon_sym_PIPE_PIPE, lexer, s);
return (lex_end_state(lexer, s));
}

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

@ -14,52 +14,44 @@
bool lex_normal_s285(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_EQ, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(234, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(533, lexer, s));
lex_accept_token(anon_sym_BANG, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s286(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LT, lexer, s);
if (s->lookahead == '&')
return (lex_advance(297, lexer, s));
lex_accept_token(anon_sym_BANG, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(238, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s287(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LT, lexer, s);
if (s->lookahead == '&')
return (lex_advance(297, lexer, s));
if (s->lookahead == '<')
return (lex_advance(303, lexer, s));
if (s->lookahead == '=')
return (lex_advance(358, lexer, s));
lex_accept_token(anon_sym_EQ, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s288(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LT, lexer, s);
if (s->lookahead == '&')
return (lex_advance(297, lexer, s));
if (s->lookahead == '<')
return (lex_advance(302, lexer, s));
lex_accept_token(anon_sym_EQ, lexer, s);
if (s->lookahead == '=')
return (lex_advance(360, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s289(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LT, lexer, s);
if (s->lookahead == '<')
return (lex_advance(304, lexer, s));
if (s->lookahead == '=')
return (lex_advance(358, lexer, s));
lex_accept_token(anon_sym_EQ, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(238, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -14,50 +14,54 @@
bool lex_normal_s290(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_GT, lexer, s);
lex_accept_token(anon_sym_LT, lexer, s);
if (s->lookahead == '&')
return (lex_advance(298, lexer, s));
if (s->lookahead == '=')
return (lex_advance(359, lexer, s));
if (s->lookahead == '>')
return (lex_advance(294, lexer, s));
if (s->lookahead == '|')
return (lex_advance(299, lexer, s));
return (lex_advance(301, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s291(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_GT, lexer, s);
lex_accept_token(anon_sym_LT, lexer, s);
if (s->lookahead == '&')
return (lex_advance(298, lexer, s));
if (s->lookahead == '>')
return (lex_advance(293, lexer, s));
if (s->lookahead == '|')
return (lex_advance(299, lexer, s));
return (lex_advance(301, lexer, s));
if (s->lookahead == '<')
return (lex_advance(307, lexer, s));
if (s->lookahead == '=')
return (lex_advance(362, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s292(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_GT, lexer, s);
if (s->lookahead == '=')
return (lex_advance(359, lexer, s));
if (s->lookahead == '>')
return (lex_advance(294, lexer, s));
lex_accept_token(anon_sym_LT, lexer, s);
if (s->lookahead == '&')
return (lex_advance(301, lexer, s));
if (s->lookahead == '<')
return (lex_advance(306, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s293(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_GT_GT, lexer, s);
lex_accept_token(anon_sym_LT, lexer, s);
if (s->lookahead == '<')
return (lex_advance(308, lexer, s));
if (s->lookahead == '=')
return (lex_advance(362, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s294(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_GT_GT, lexer, s);
lex_accept_token(anon_sym_GT, lexer, s);
if (s->lookahead == '&')
return (lex_advance(302, lexer, s));
if (s->lookahead == '=')
return (lex_advance(345, lexer, s));
return (lex_advance(363, lexer, s));
if (s->lookahead == '>')
return (lex_advance(298, lexer, s));
if (s->lookahead == '|')
return (lex_advance(303, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -14,36 +14,44 @@
bool lex_normal_s295(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_AMP_GT, lexer, s);
lex_accept_token(anon_sym_GT, lexer, s);
if (s->lookahead == '&')
return (lex_advance(302, lexer, s));
if (s->lookahead == '>')
return (lex_advance(296, lexer, s));
return (lex_advance(297, lexer, s));
if (s->lookahead == '|')
return (lex_advance(303, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s296(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_AMP_GT_GT, lexer, s);
lex_accept_token(anon_sym_GT, lexer, s);
if (s->lookahead == '=')
return (lex_advance(363, lexer, s));
if (s->lookahead == '>')
return (lex_advance(298, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s297(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LT_AMP, lexer, s);
if (s->lookahead == '-')
return (lex_advance(300, lexer, s));
lex_accept_token(anon_sym_GT_GT, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s298(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_GT_AMP, lexer, s);
if (s->lookahead == '-')
return (lex_advance(301, lexer, s));
lex_accept_token(anon_sym_GT_GT, lexer, s);
if (s->lookahead == '=')
return (lex_advance(349, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s299(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_GT_PIPE, lexer, s);
lex_accept_token(anon_sym_AMP_GT, lexer, s);
if (s->lookahead == '>')
return (lex_advance(300, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -15,49 +15,49 @@
bool lex_normal_s30(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(453, lexer, s));
return (lex_advance(454, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(29, lexer, s));
if (s->lookahead == ' ')
return (lex_advance(488, lexer, s));
return (lex_advance(491, lexer, s));
if ((s->lookahead >= '\t' && s->lookahead <= '\f'))
return (lex_skip(106, lexer, s));
return (lex_skip(116, lexer, s));
if (s->lookahead != 0)
return (lex_advance(533, lexer, s));
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s31(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(453, lexer, s));
return (lex_advance(454, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(29, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(106, lexer, s));
return (lex_skip(116, lexer, s));
if (s->lookahead != 0)
return (lex_advance(533, lexer, s));
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s32(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(104, lexer, s));
return (lex_skip(105, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s33(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(105, lexer, s));
return (lex_skip(106, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s34(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(461, lexer, s));
return (lex_advance(456, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -14,19 +14,21 @@
bool lex_normal_s300(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LT_AMP_DASH, lexer, s);
lex_accept_token(anon_sym_AMP_GT_GT, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s301(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_GT_AMP_DASH, lexer, s);
lex_accept_token(anon_sym_LT_AMP, lexer, s);
if (s->lookahead == '-')
return (lex_advance(304, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s302(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LT_LT, lexer, s);
lex_accept_token(anon_sym_GT_AMP, lexer, s);
if (s->lookahead == '-')
return (lex_advance(305, lexer, s));
return (lex_end_state(lexer, s));
@ -34,18 +36,12 @@ bool lex_normal_s302(t_lexer *lexer, t_lexer_state *s)
bool lex_normal_s303(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LT_LT, lexer, s);
if (s->lookahead == '-')
return (lex_advance(305, lexer, s));
if (s->lookahead == '=')
return (lex_advance(344, lexer, s));
lex_accept_token(anon_sym_GT_PIPE, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s304(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LT_LT, lexer, s);
if (s->lookahead == '=')
return (lex_advance(344, lexer, s));
lex_accept_token(anon_sym_LT_AMP_DASH, lexer, s);
return (lex_end_state(lexer, s));
}

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

@ -14,52 +14,38 @@
bool lex_normal_s305(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LT_LT_DASH, lexer, s);
lex_accept_token(anon_sym_GT_AMP_DASH, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s306(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(aux_sym_heredoc_redirect_token1, lexer, \
s);
if (s->lookahead == '\n')
return (lex_advance(306, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(13, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(484, lexer, s));
lex_accept_token(anon_sym_LT_LT, lexer, s);
if (s->lookahead == '-')
return (lex_advance(309, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s307(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(aux_sym_heredoc_redirect_token1, lexer, \
s);
if (s->lookahead == '\n')
return (lex_advance(307, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(51, lexer, s));
lex_accept_token(anon_sym_LT_LT, lexer, s);
if (s->lookahead == '-')
return (lex_advance(309, lexer, s));
if (s->lookahead == '=')
return (lex_advance(348, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s308(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(aux_sym_heredoc_redirect_token1, lexer, \
s);
if (s->lookahead == '\n')
return (lex_advance(308, lexer, s));
lex_accept_token(anon_sym_LT_LT, lexer, s);
if (s->lookahead == '=')
return (lex_advance(348, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s309(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(aux_sym_heredoc_redirect_token1, lexer, \
s);
if (s->lookahead == '\n')
return (lex_advance(309, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(19, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(485, lexer, s));
lex_accept_token(anon_sym_LT_LT_DASH, lexer, s);
return (lex_end_state(lexer, s));
}

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

@ -19,9 +19,9 @@ bool lex_normal_s310(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(310, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(146, lexer, s));
return (lex_advance(13, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(486, lexer, s));
return (lex_advance(480, lexer, s));
return (lex_end_state(lexer, s));
}
@ -32,9 +32,7 @@ bool lex_normal_s311(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(311, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(148, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(487, lexer, s));
return (lex_advance(51, lexer, s));
return (lex_end_state(lexer, s));
}
@ -44,10 +42,6 @@ bool lex_normal_s312(t_lexer *lexer, t_lexer_state *s)
s);
if (s->lookahead == '\n')
return (lex_advance(312, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(31, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(488, lexer, s));
return (lex_end_state(lexer, s));
}
@ -58,7 +52,9 @@ bool lex_normal_s313(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(313, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(53, lexer, s));
return (lex_advance(22, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(481, lexer, s));
return (lex_end_state(lexer, s));
}
@ -69,8 +65,8 @@ bool lex_normal_s314(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(314, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(22, lexer, s));
return (lex_advance(147, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(489, lexer, s));
return (lex_advance(482, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -19,9 +19,9 @@ bool lex_normal_s315(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(315, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(154, lexer, s));
return (lex_advance(149, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(490, lexer, s));
return (lex_advance(483, lexer, s));
return (lex_end_state(lexer, s));
}
@ -32,9 +32,9 @@ bool lex_normal_s316(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(316, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(150, lexer, s));
return (lex_advance(19, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(491, lexer, s));
return (lex_advance(484, lexer, s));
return (lex_end_state(lexer, s));
}
@ -45,7 +45,7 @@ bool lex_normal_s317(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(317, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(55, lexer, s));
return (lex_advance(53, lexer, s));
return (lex_end_state(lexer, s));
}
@ -58,7 +58,7 @@ bool lex_normal_s318(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\\')
return (lex_advance(25, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(492, lexer, s));
return (lex_advance(485, lexer, s));
return (lex_end_state(lexer, s));
}
@ -69,8 +69,8 @@ bool lex_normal_s319(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(319, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(164, lexer, s));
return (lex_advance(155, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(493, lexer, s));
return (lex_advance(486, lexer, s));
return (lex_end_state(lexer, s));
}

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

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

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

@ -19,9 +19,9 @@ bool lex_normal_s325(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(325, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(36, lexer, s));
return (lex_advance(31, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(497, lexer, s));
return (lex_advance(491, lexer, s));
return (lex_end_state(lexer, s));
}
@ -32,9 +32,7 @@ bool lex_normal_s326(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(326, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(173, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(498, lexer, s));
return (lex_advance(57, lexer, s));
return (lex_end_state(lexer, s));
}
@ -45,7 +43,9 @@ bool lex_normal_s327(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(327, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(102, lexer, s));
return (lex_advance(169, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(492, lexer, s));
return (lex_end_state(lexer, s));
}
@ -56,9 +56,9 @@ bool lex_normal_s328(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(328, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(39, lexer, s));
return (lex_advance(36, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(499, lexer, s));
return (lex_advance(493, lexer, s));
return (lex_end_state(lexer, s));
}
@ -69,6 +69,6 @@ bool lex_normal_s329(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(329, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(80, lexer, s));
return (lex_advance(63, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -19,9 +19,9 @@ bool lex_normal_s330(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(330, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(99, lexer, s));
return (lex_advance(176, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(500, lexer, s));
return (lex_advance(494, lexer, s));
return (lex_end_state(lexer, s));
}
@ -32,9 +32,9 @@ bool lex_normal_s331(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(331, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(71, lexer, s));
return (lex_advance(42, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(501, lexer, s));
return (lex_advance(495, lexer, s));
return (lex_end_state(lexer, s));
}
@ -45,20 +45,30 @@ bool lex_normal_s332(t_lexer *lexer, t_lexer_state *s)
if (s->lookahead == '\n')
return (lex_advance(332, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(76, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(502, lexer, s));
return (lex_advance(102, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s333(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PIPE_AMP, lexer, s);
lex_accept_token(aux_sym_heredoc_redirect_token1, lexer, \
s);
if (s->lookahead == '\n')
return (lex_advance(333, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(99, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(496, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s334(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_DOLLAR_LPAREN_LPAREN, lexer, s);
lex_accept_token(aux_sym_heredoc_redirect_token1, lexer, \
s);
if (s->lookahead == '\n')
return (lex_advance(334, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(80, lexer, s));
return (lex_end_state(lexer, s));
}

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

@ -14,36 +14,44 @@
bool lex_normal_s335(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_RPAREN_RPAREN, lexer, s);
lex_accept_token(aux_sym_heredoc_redirect_token1, lexer, \
s);
if (s->lookahead == '\n')
return (lex_advance(335, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(71, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(497, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s336(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PLUS_EQ, lexer, s);
lex_accept_token(aux_sym_heredoc_redirect_token1, lexer, \
s);
if (s->lookahead == '\n')
return (lex_advance(336, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(75, lexer, s));
if ((s->lookahead >= 0x0b && s->lookahead <= '\r'))
return (lex_advance(498, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s337(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_DASH_EQ, lexer, s);
lex_accept_token(anon_sym_PIPE_AMP, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s338(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_STAR_EQ, lexer, s);
lex_accept_token(anon_sym_DOLLAR_LPAREN_LPAREN, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s339(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_STAR_EQ, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(234, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(533, lexer, s));
lex_accept_token(anon_sym_RPAREN_RPAREN, lexer, s);
return (lex_end_state(lexer, s));
}

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

@ -14,42 +14,36 @@
bool lex_normal_s340(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_SLASH_EQ, lexer, s);
lex_accept_token(anon_sym_PLUS_EQ, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s341(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_SLASH_EQ, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(234, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(533, lexer, s));
lex_accept_token(anon_sym_DASH_EQ, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s342(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PERCENT_EQ, lexer, s);
lex_accept_token(anon_sym_STAR_EQ, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s343(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PERCENT_EQ, lexer, s);
lex_accept_token(anon_sym_STAR_EQ, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(234, lexer, s));
return (lex_advance(238, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(533, lexer, s));
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s344(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LT_LT_EQ, lexer, s);
lex_accept_token(anon_sym_SLASH_EQ, lexer, s);
return (lex_end_state(lexer, s));
}

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

@ -14,36 +14,42 @@
bool lex_normal_s345(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_GT_GT_EQ, lexer, s);
lex_accept_token(anon_sym_SLASH_EQ, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(238, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s346(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_AMP_EQ, lexer, s);
lex_accept_token(anon_sym_PERCENT_EQ, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s347(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_CARET_EQ, lexer, s);
lex_accept_token(anon_sym_PERCENT_EQ, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(238, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(528, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s348(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_CARET_EQ, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(234, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 10, \
s->lookahead)))
return (lex_advance(533, lexer, s));
lex_accept_token(anon_sym_LT_LT_EQ, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s349(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PIPE_EQ, lexer, s);
lex_accept_token(anon_sym_GT_GT_EQ, lexer, s);
return (lex_end_state(lexer, s));
}

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