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

Started from buttom go to the sky

Browse source
This commit is contained in:
Raphaël 2024-04-28 19:59:01 +02:00
parent 96215449bd
commit f811e55dea
4781 changed files with 10121 additions and 1743 deletions
Download patch file Download diff file Expand all files Collapse all files

73
parser/static/lex_funcs/lex_normal/create_table/lex_normal_array.h Normal file
View file

@ -0,0 +1,73 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lex_normal_array.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 LEX_NORMAL_ARRAY_H
# define LEX_NORMAL_ARRAY_H
# include "../../../types/type_lex_normal.h"
# include "../../../headers/symbols.h"
# include "../../../headers/external_scanner_symbol_identifiers.h"
# include "../../../headers/field_identifiers.h"
# include "../../../headers/constants.h"
# include "../../../char_set/charset_inline.h"
# include "../lex_normal_funcs.h"
void lex_normal_array_0(t_lex_normal_array *v);
void lex_normal_array_1(t_lex_normal_array *v);
void lex_normal_array_2(t_lex_normal_array *v);
void lex_normal_array_3(t_lex_normal_array *v);
void lex_normal_array_4(t_lex_normal_array *v);
void lex_normal_array_5(t_lex_normal_array *v);
void lex_normal_array_6(t_lex_normal_array *v);
void lex_normal_array_7(t_lex_normal_array *v);
void lex_normal_array_8(t_lex_normal_array *v);
void lex_normal_array_9(t_lex_normal_array *v);
void lex_normal_array_10(t_lex_normal_array *v);
void lex_normal_array_11(t_lex_normal_array *v);
void lex_normal_array_12(t_lex_normal_array *v);
void lex_normal_array_13(t_lex_normal_array *v);
void lex_normal_array_14(t_lex_normal_array *v);
void lex_normal_array_15(t_lex_normal_array *v);
void lex_normal_array_16(t_lex_normal_array *v);
void lex_normal_array_17(t_lex_normal_array *v);
void lex_normal_array_18(t_lex_normal_array *v);
void lex_normal_array_19(t_lex_normal_array *v);
void lex_normal_array_20(t_lex_normal_array *v);
void lex_normal_array_21(t_lex_normal_array *v);
void lex_normal_array_22(t_lex_normal_array *v);
void lex_normal_array_23(t_lex_normal_array *v);
void lex_normal_array_24(t_lex_normal_array *v);
void lex_normal_array_25(t_lex_normal_array *v);
void lex_normal_array_26(t_lex_normal_array *v);
void lex_normal_array_27(t_lex_normal_array *v);
void lex_normal_array_28(t_lex_normal_array *v);
void lex_normal_array_29(t_lex_normal_array *v);
void lex_normal_array_30(t_lex_normal_array *v);
void lex_normal_array_31(t_lex_normal_array *v);
void lex_normal_array_32(t_lex_normal_array *v);
void lex_normal_array_33(t_lex_normal_array *v);
void lex_normal_array_34(t_lex_normal_array *v);
void lex_normal_array_35(t_lex_normal_array *v);
void lex_normal_array_36(t_lex_normal_array *v);
void lex_normal_array_37(t_lex_normal_array *v);
void lex_normal_array_38(t_lex_normal_array *v);
void lex_normal_array_39(t_lex_normal_array *v);
void lex_normal_array_40(t_lex_normal_array *v);
void lex_normal_array_41(t_lex_normal_array *v);
void lex_normal_array_42(t_lex_normal_array *v);
void lex_normal_array_43(t_lex_normal_array *v);
void lex_normal_array_44(t_lex_normal_array *v);
void lex_normal_array_45(t_lex_normal_array *v);
void lex_normal_array_46(t_lex_normal_array *v);
void lex_normal_array_47(t_lex_normal_array *v);
#endif // LEX_NORMAL_ARRAY_H

145
parser/static/lex_funcs/lex_normal/create_table/lex_normal_array_0.c Normal file
View file

@ -0,0 +1,145 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lex_normal_array_0.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 "../../../headers/symbols.h"
#include "../../../headers/external_scanner_symbol_identifiers.h"
#include "../../../headers/field_identifiers.h"
#include "../../../headers/constants.h"
#include "../lex_normal_funcs.h"
#include "./lex_normal_array.h"
void lex_normal_array_0(t_lex_normal_array *v)
{
v->a[0] = lex_normal_s0;
v->a[1] = lex_normal_s1;
v->a[2] = lex_normal_s2;
v->a[3] = lex_normal_s3;
v->a[4] = lex_normal_s4;
v->a[5] = lex_normal_s5;
v->a[6] = lex_normal_s6;
v->a[7] = lex_normal_s7;
v->a[8] = lex_normal_s8;
v->a[9] = lex_normal_s9;
v->a[10] = lex_normal_s10;
v->a[11] = lex_normal_s11;
v->a[12] = lex_normal_s12;
v->a[13] = lex_normal_s13;
v->a[14] = lex_normal_s14;
v->a[15] = lex_normal_s15;
v->a[16] = lex_normal_s16;
v->a[17] = lex_normal_s17;
v->a[18] = lex_normal_s18;
v->a[19] = lex_normal_s19;
lex_normal_array_1(v);
}
void lex_normal_array_1(t_lex_normal_array *v)
{
v->a[20] = lex_normal_s20;
v->a[21] = lex_normal_s21;
v->a[22] = lex_normal_s22;
v->a[23] = lex_normal_s23;
v->a[24] = lex_normal_s24;
v->a[25] = lex_normal_s25;
v->a[26] = lex_normal_s26;
v->a[27] = lex_normal_s27;
v->a[28] = lex_normal_s28;
v->a[29] = lex_normal_s29;
v->a[30] = lex_normal_s30;
v->a[31] = lex_normal_s31;
v->a[32] = lex_normal_s32;
v->a[33] = lex_normal_s33;
v->a[34] = lex_normal_s34;
v->a[35] = lex_normal_s35;
v->a[36] = lex_normal_s36;
v->a[37] = lex_normal_s37;
v->a[38] = lex_normal_s38;
v->a[39] = lex_normal_s39;
lex_normal_array_2(v);
}
void lex_normal_array_2(t_lex_normal_array *v)
{
v->a[40] = lex_normal_s40;
v->a[41] = lex_normal_s41;
v->a[42] = lex_normal_s42;
v->a[43] = lex_normal_s43;
v->a[44] = lex_normal_s44;
v->a[45] = lex_normal_s45;
v->a[46] = lex_normal_s46;
v->a[47] = lex_normal_s47;
v->a[48] = lex_normal_s48;
v->a[49] = lex_normal_s49;
v->a[50] = lex_normal_s50;
v->a[51] = lex_normal_s51;
v->a[52] = lex_normal_s52;
v->a[53] = lex_normal_s53;
v->a[54] = lex_normal_s54;
v->a[55] = lex_normal_s55;
v->a[56] = lex_normal_s56;
v->a[57] = lex_normal_s57;
v->a[58] = lex_normal_s58;
v->a[59] = lex_normal_s59;
lex_normal_array_3(v);
}
void lex_normal_array_3(t_lex_normal_array *v)
{
v->a[60] = lex_normal_s60;
v->a[61] = lex_normal_s61;
v->a[62] = lex_normal_s62;
v->a[63] = lex_normal_s63;
v->a[64] = lex_normal_s64;
v->a[65] = lex_normal_s65;
v->a[66] = lex_normal_s66;
v->a[67] = lex_normal_s67;
v->a[68] = lex_normal_s68;
v->a[69] = lex_normal_s69;
v->a[70] = lex_normal_s70;
v->a[71] = lex_normal_s71;
v->a[72] = lex_normal_s72;
v->a[73] = lex_normal_s73;
v->a[74] = lex_normal_s74;
v->a[75] = lex_normal_s75;
v->a[76] = lex_normal_s76;
v->a[77] = lex_normal_s77;
v->a[78] = lex_normal_s78;
v->a[79] = lex_normal_s79;
lex_normal_array_4(v);
}
void lex_normal_array_4(t_lex_normal_array *v)
{
v->a[80] = lex_normal_s80;
v->a[81] = lex_normal_s81;
v->a[82] = lex_normal_s82;
v->a[83] = lex_normal_s83;
v->a[84] = lex_normal_s84;
v->a[85] = lex_normal_s85;
v->a[86] = lex_normal_s86;
v->a[87] = lex_normal_s87;
v->a[88] = lex_normal_s88;
v->a[89] = lex_normal_s89;
v->a[90] = lex_normal_s90;
v->a[91] = lex_normal_s91;
v->a[92] = lex_normal_s92;
v->a[93] = lex_normal_s93;
v->a[94] = lex_normal_s94;
v->a[95] = lex_normal_s95;
v->a[96] = lex_normal_s96;
v->a[97] = lex_normal_s97;
v->a[98] = lex_normal_s98;
v->a[99] = lex_normal_s99;
lex_normal_array_5(v);
}
/* EOF lex_normal_array_0.c */

145
parser/static/lex_funcs/lex_normal/create_table/lex_normal_array_1.c Normal file
View file

@ -0,0 +1,145 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lex_normal_array_1.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 "../../../headers/symbols.h"
#include "../../../headers/external_scanner_symbol_identifiers.h"
#include "../../../headers/field_identifiers.h"
#include "../../../headers/constants.h"
#include "../lex_normal_funcs.h"
#include "./lex_normal_array.h"
void lex_normal_array_5(t_lex_normal_array *v)
{
v->a[100] = lex_normal_s100;
v->a[101] = lex_normal_s101;
v->a[102] = lex_normal_s102;
v->a[103] = lex_normal_s103;
v->a[104] = lex_normal_s104;
v->a[105] = lex_normal_s105;
v->a[106] = lex_normal_s106;
v->a[107] = lex_normal_s107;
v->a[108] = lex_normal_s108;
v->a[109] = lex_normal_s109;
v->a[110] = lex_normal_s110;
v->a[111] = lex_normal_s111;
v->a[112] = lex_normal_s112;
v->a[113] = lex_normal_s113;
v->a[114] = lex_normal_s114;
v->a[115] = lex_normal_s115;
v->a[116] = lex_normal_s116;
v->a[117] = lex_normal_s117;
v->a[118] = lex_normal_s118;
v->a[119] = lex_normal_s119;
lex_normal_array_6(v);
}
void lex_normal_array_6(t_lex_normal_array *v)
{
v->a[120] = lex_normal_s120;
v->a[121] = lex_normal_s121;
v->a[122] = lex_normal_s122;
v->a[123] = lex_normal_s123;
v->a[124] = lex_normal_s124;
v->a[125] = lex_normal_s125;
v->a[126] = lex_normal_s126;
v->a[127] = lex_normal_s127;
v->a[128] = lex_normal_s128;
v->a[129] = lex_normal_s129;
v->a[130] = lex_normal_s130;
v->a[131] = lex_normal_s131;
v->a[132] = lex_normal_s132;
v->a[133] = lex_normal_s133;
v->a[134] = lex_normal_s134;
v->a[135] = lex_normal_s135;
v->a[136] = lex_normal_s136;
v->a[137] = lex_normal_s137;
v->a[138] = lex_normal_s138;
v->a[139] = lex_normal_s139;
lex_normal_array_7(v);
}
void lex_normal_array_7(t_lex_normal_array *v)
{
v->a[140] = lex_normal_s140;
v->a[141] = lex_normal_s141;
v->a[142] = lex_normal_s142;
v->a[143] = lex_normal_s143;
v->a[144] = lex_normal_s144;
v->a[145] = lex_normal_s145;
v->a[146] = lex_normal_s146;
v->a[147] = lex_normal_s147;
v->a[148] = lex_normal_s148;
v->a[149] = lex_normal_s149;
v->a[150] = lex_normal_s150;
v->a[151] = lex_normal_s151;
v->a[152] = lex_normal_s152;
v->a[153] = lex_normal_s153;
v->a[154] = lex_normal_s154;
v->a[155] = lex_normal_s155;
v->a[156] = lex_normal_s156;
v->a[157] = lex_normal_s157;
v->a[158] = lex_normal_s158;
v->a[159] = lex_normal_s159;
lex_normal_array_8(v);
}
void lex_normal_array_8(t_lex_normal_array *v)
{
v->a[160] = lex_normal_s160;
v->a[161] = lex_normal_s161;
v->a[162] = lex_normal_s162;
v->a[163] = lex_normal_s163;
v->a[164] = lex_normal_s164;
v->a[165] = lex_normal_s165;
v->a[166] = lex_normal_s166;
v->a[167] = lex_normal_s167;
v->a[168] = lex_normal_s168;
v->a[169] = lex_normal_s169;
v->a[170] = lex_normal_s170;
v->a[171] = lex_normal_s171;
v->a[172] = lex_normal_s172;
v->a[173] = lex_normal_s173;
v->a[174] = lex_normal_s174;
v->a[175] = lex_normal_s175;
v->a[176] = lex_normal_s176;
v->a[177] = lex_normal_s177;
v->a[178] = lex_normal_s178;
v->a[179] = lex_normal_s179;
lex_normal_array_9(v);
}
void lex_normal_array_9(t_lex_normal_array *v)
{
v->a[180] = lex_normal_s180;
v->a[181] = lex_normal_s181;
v->a[182] = lex_normal_s182;
v->a[183] = lex_normal_s183;
v->a[184] = lex_normal_s184;
v->a[185] = lex_normal_s185;
v->a[186] = lex_normal_s186;
v->a[187] = lex_normal_s187;
v->a[188] = lex_normal_s188;
v->a[189] = lex_normal_s189;
v->a[190] = lex_normal_s190;
v->a[191] = lex_normal_s191;
v->a[192] = lex_normal_s192;
v->a[193] = lex_normal_s193;
v->a[194] = lex_normal_s194;
v->a[195] = lex_normal_s195;
v->a[196] = lex_normal_s196;
v->a[197] = lex_normal_s197;
v->a[198] = lex_normal_s198;
v->a[199] = lex_normal_s199;
lex_normal_array_10(v);
}
/* EOF lex_normal_array_1.c */

145
parser/static/lex_funcs/lex_normal/create_table/lex_normal_array_2.c Normal file
View file

@ -0,0 +1,145 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lex_normal_array_2.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../../headers/symbols.h"
#include "../../../headers/external_scanner_symbol_identifiers.h"
#include "../../../headers/field_identifiers.h"
#include "../../../headers/constants.h"
#include "../lex_normal_funcs.h"
#include "./lex_normal_array.h"
void lex_normal_array_10(t_lex_normal_array *v)
{
v->a[200] = lex_normal_s200;
v->a[201] = lex_normal_s201;
v->a[202] = lex_normal_s202;
v->a[203] = lex_normal_s203;
v->a[204] = lex_normal_s204;
v->a[205] = lex_normal_s205;
v->a[206] = lex_normal_s206;
v->a[207] = lex_normal_s207;
v->a[208] = lex_normal_s208;
v->a[209] = lex_normal_s209;
v->a[210] = lex_normal_s210;
v->a[211] = lex_normal_s211;
v->a[212] = lex_normal_s212;
v->a[213] = lex_normal_s213;
v->a[214] = lex_normal_s214;
v->a[215] = lex_normal_s215;
v->a[216] = lex_normal_s216;
v->a[217] = lex_normal_s217;
v->a[218] = lex_normal_s218;
v->a[219] = lex_normal_s219;
lex_normal_array_11(v);
}
void lex_normal_array_11(t_lex_normal_array *v)
{
v->a[220] = lex_normal_s220;
v->a[221] = lex_normal_s221;
v->a[222] = lex_normal_s222;
v->a[223] = lex_normal_s223;
v->a[224] = lex_normal_s224;
v->a[225] = lex_normal_s225;
v->a[226] = lex_normal_s226;
v->a[227] = lex_normal_s227;
v->a[228] = lex_normal_s228;
v->a[229] = lex_normal_s229;
v->a[230] = lex_normal_s230;
v->a[231] = lex_normal_s231;
v->a[232] = lex_normal_s232;
v->a[233] = lex_normal_s233;
v->a[234] = lex_normal_s234;
v->a[235] = lex_normal_s235;
v->a[236] = lex_normal_s236;
v->a[237] = lex_normal_s237;
v->a[238] = lex_normal_s238;
v->a[239] = lex_normal_s239;
lex_normal_array_12(v);
}
void lex_normal_array_12(t_lex_normal_array *v)
{
v->a[240] = lex_normal_s240;
v->a[241] = lex_normal_s241;
v->a[242] = lex_normal_s242;
v->a[243] = lex_normal_s243;
v->a[244] = lex_normal_s244;
v->a[245] = lex_normal_s245;
v->a[246] = lex_normal_s246;
v->a[247] = lex_normal_s247;
v->a[248] = lex_normal_s248;
v->a[249] = lex_normal_s249;
v->a[250] = lex_normal_s250;
v->a[251] = lex_normal_s251;
v->a[252] = lex_normal_s252;
v->a[253] = lex_normal_s253;
v->a[254] = lex_normal_s254;
v->a[255] = lex_normal_s255;
v->a[256] = lex_normal_s256;
v->a[257] = lex_normal_s257;
v->a[258] = lex_normal_s258;
v->a[259] = lex_normal_s259;
lex_normal_array_13(v);
}
void lex_normal_array_13(t_lex_normal_array *v)
{
v->a[260] = lex_normal_s260;
v->a[261] = lex_normal_s261;
v->a[262] = lex_normal_s262;
v->a[263] = lex_normal_s263;
v->a[264] = lex_normal_s264;
v->a[265] = lex_normal_s265;
v->a[266] = lex_normal_s266;
v->a[267] = lex_normal_s267;
v->a[268] = lex_normal_s268;
v->a[269] = lex_normal_s269;
v->a[270] = lex_normal_s270;
v->a[271] = lex_normal_s271;
v->a[272] = lex_normal_s272;
v->a[273] = lex_normal_s273;
v->a[274] = lex_normal_s274;
v->a[275] = lex_normal_s275;
v->a[276] = lex_normal_s276;
v->a[277] = lex_normal_s277;
v->a[278] = lex_normal_s278;
v->a[279] = lex_normal_s279;
lex_normal_array_14(v);
}
void lex_normal_array_14(t_lex_normal_array *v)
{
v->a[280] = lex_normal_s280;
v->a[281] = lex_normal_s281;
v->a[282] = lex_normal_s282;
v->a[283] = lex_normal_s283;
v->a[284] = lex_normal_s284;
v->a[285] = lex_normal_s285;
v->a[286] = lex_normal_s286;
v->a[287] = lex_normal_s287;
v->a[288] = lex_normal_s288;
v->a[289] = lex_normal_s289;
v->a[290] = lex_normal_s290;
v->a[291] = lex_normal_s291;
v->a[292] = lex_normal_s292;
v->a[293] = lex_normal_s293;
v->a[294] = lex_normal_s294;
v->a[295] = lex_normal_s295;
v->a[296] = lex_normal_s296;
v->a[297] = lex_normal_s297;
v->a[298] = lex_normal_s298;
v->a[299] = lex_normal_s299;
lex_normal_array_15(v);
}
/* EOF lex_normal_array_2.c */

145
parser/static/lex_funcs/lex_normal/create_table/lex_normal_array_3.c Normal file
View file

@ -0,0 +1,145 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lex_normal_array_3.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 "../../../headers/symbols.h"
#include "../../../headers/external_scanner_symbol_identifiers.h"
#include "../../../headers/field_identifiers.h"
#include "../../../headers/constants.h"
#include "../lex_normal_funcs.h"
#include "./lex_normal_array.h"
void lex_normal_array_15(t_lex_normal_array *v)
{
v->a[300] = lex_normal_s300;
v->a[301] = lex_normal_s301;
v->a[302] = lex_normal_s302;
v->a[303] = lex_normal_s303;
v->a[304] = lex_normal_s304;
v->a[305] = lex_normal_s305;
v->a[306] = lex_normal_s306;
v->a[307] = lex_normal_s307;
v->a[308] = lex_normal_s308;
v->a[309] = lex_normal_s309;
v->a[310] = lex_normal_s310;
v->a[311] = lex_normal_s311;
v->a[312] = lex_normal_s312;
v->a[313] = lex_normal_s313;
v->a[314] = lex_normal_s314;
v->a[315] = lex_normal_s315;
v->a[316] = lex_normal_s316;
v->a[317] = lex_normal_s317;
v->a[318] = lex_normal_s318;
v->a[319] = lex_normal_s319;
lex_normal_array_16(v);
}
void lex_normal_array_16(t_lex_normal_array *v)
{
v->a[320] = lex_normal_s320;
v->a[321] = lex_normal_s321;
v->a[322] = lex_normal_s322;
v->a[323] = lex_normal_s323;
v->a[324] = lex_normal_s324;
v->a[325] = lex_normal_s325;
v->a[326] = lex_normal_s326;
v->a[327] = lex_normal_s327;
v->a[328] = lex_normal_s328;
v->a[329] = lex_normal_s329;
v->a[330] = lex_normal_s330;
v->a[331] = lex_normal_s331;
v->a[332] = lex_normal_s332;
v->a[333] = lex_normal_s333;
v->a[334] = lex_normal_s334;
v->a[335] = lex_normal_s335;
v->a[336] = lex_normal_s336;
v->a[337] = lex_normal_s337;
v->a[338] = lex_normal_s338;
v->a[339] = lex_normal_s339;
lex_normal_array_17(v);
}
void lex_normal_array_17(t_lex_normal_array *v)
{
v->a[340] = lex_normal_s340;
v->a[341] = lex_normal_s341;
v->a[342] = lex_normal_s342;
v->a[343] = lex_normal_s343;
v->a[344] = lex_normal_s344;
v->a[345] = lex_normal_s345;
v->a[346] = lex_normal_s346;
v->a[347] = lex_normal_s347;
v->a[348] = lex_normal_s348;
v->a[349] = lex_normal_s349;
v->a[350] = lex_normal_s350;
v->a[351] = lex_normal_s351;
v->a[352] = lex_normal_s352;
v->a[353] = lex_normal_s353;
v->a[354] = lex_normal_s354;
v->a[355] = lex_normal_s355;
v->a[356] = lex_normal_s356;
v->a[357] = lex_normal_s357;
v->a[358] = lex_normal_s358;
v->a[359] = lex_normal_s359;
lex_normal_array_18(v);
}
void lex_normal_array_18(t_lex_normal_array *v)
{
v->a[360] = lex_normal_s360;
v->a[361] = lex_normal_s361;
v->a[362] = lex_normal_s362;
v->a[363] = lex_normal_s363;
v->a[364] = lex_normal_s364;
v->a[365] = lex_normal_s365;
v->a[366] = lex_normal_s366;
v->a[367] = lex_normal_s367;
v->a[368] = lex_normal_s368;
v->a[369] = lex_normal_s369;
v->a[370] = lex_normal_s370;
v->a[371] = lex_normal_s371;
v->a[372] = lex_normal_s372;
v->a[373] = lex_normal_s373;
v->a[374] = lex_normal_s374;
v->a[375] = lex_normal_s375;
v->a[376] = lex_normal_s376;
v->a[377] = lex_normal_s377;
v->a[378] = lex_normal_s378;
v->a[379] = lex_normal_s379;
lex_normal_array_19(v);
}
void lex_normal_array_19(t_lex_normal_array *v)
{
v->a[380] = lex_normal_s380;
v->a[381] = lex_normal_s381;
v->a[382] = lex_normal_s382;
v->a[383] = lex_normal_s383;
v->a[384] = lex_normal_s384;
v->a[385] = lex_normal_s385;
v->a[386] = lex_normal_s386;
v->a[387] = lex_normal_s387;
v->a[388] = lex_normal_s388;
v->a[389] = lex_normal_s389;
v->a[390] = lex_normal_s390;
v->a[391] = lex_normal_s391;
v->a[392] = lex_normal_s392;
v->a[393] = lex_normal_s393;
v->a[394] = lex_normal_s394;
v->a[395] = lex_normal_s395;
v->a[396] = lex_normal_s396;
v->a[397] = lex_normal_s397;
v->a[398] = lex_normal_s398;
v->a[399] = lex_normal_s399;
lex_normal_array_20(v);
}
/* EOF lex_normal_array_3.c */

145
parser/static/lex_funcs/lex_normal/create_table/lex_normal_array_4.c Normal file
View file

@ -0,0 +1,145 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lex_normal_array_4.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 "../../../headers/symbols.h"
#include "../../../headers/external_scanner_symbol_identifiers.h"
#include "../../../headers/field_identifiers.h"
#include "../../../headers/constants.h"
#include "../lex_normal_funcs.h"
#include "./lex_normal_array.h"
void lex_normal_array_20(t_lex_normal_array *v)
{
v->a[400] = lex_normal_s400;
v->a[401] = lex_normal_s401;
v->a[402] = lex_normal_s402;
v->a[403] = lex_normal_s403;
v->a[404] = lex_normal_s404;
v->a[405] = lex_normal_s405;
v->a[406] = lex_normal_s406;
v->a[407] = lex_normal_s407;
v->a[408] = lex_normal_s408;
v->a[409] = lex_normal_s409;
v->a[410] = lex_normal_s410;
v->a[411] = lex_normal_s411;
v->a[412] = lex_normal_s412;
v->a[413] = lex_normal_s413;
v->a[414] = lex_normal_s414;
v->a[415] = lex_normal_s415;
v->a[416] = lex_normal_s416;
v->a[417] = lex_normal_s417;
v->a[418] = lex_normal_s418;
v->a[419] = lex_normal_s419;
lex_normal_array_21(v);
}
void lex_normal_array_21(t_lex_normal_array *v)
{
v->a[420] = lex_normal_s420;
v->a[421] = lex_normal_s421;
v->a[422] = lex_normal_s422;
v->a[423] = lex_normal_s423;
v->a[424] = lex_normal_s424;
v->a[425] = lex_normal_s425;
v->a[426] = lex_normal_s426;
v->a[427] = lex_normal_s427;
v->a[428] = lex_normal_s428;
v->a[429] = lex_normal_s429;
v->a[430] = lex_normal_s430;
v->a[431] = lex_normal_s431;
v->a[432] = lex_normal_s432;
v->a[433] = lex_normal_s433;
v->a[434] = lex_normal_s434;
v->a[435] = lex_normal_s435;
v->a[436] = lex_normal_s436;
v->a[437] = lex_normal_s437;
v->a[438] = lex_normal_s438;
v->a[439] = lex_normal_s439;
lex_normal_array_22(v);
}
void lex_normal_array_22(t_lex_normal_array *v)
{
v->a[440] = lex_normal_s440;
v->a[441] = lex_normal_s441;
v->a[442] = lex_normal_s442;
v->a[443] = lex_normal_s443;
v->a[444] = lex_normal_s444;
v->a[445] = lex_normal_s445;
v->a[446] = lex_normal_s446;
v->a[447] = lex_normal_s447;
v->a[448] = lex_normal_s448;
v->a[449] = lex_normal_s449;
v->a[450] = lex_normal_s450;
v->a[451] = lex_normal_s451;
v->a[452] = lex_normal_s452;
v->a[453] = lex_normal_s453;
v->a[454] = lex_normal_s454;
v->a[455] = lex_normal_s455;
v->a[456] = lex_normal_s456;
v->a[457] = lex_normal_s457;
v->a[458] = lex_normal_s458;
v->a[459] = lex_normal_s459;
lex_normal_array_23(v);
}
void lex_normal_array_23(t_lex_normal_array *v)
{
v->a[460] = lex_normal_s460;
v->a[461] = lex_normal_s461;
v->a[462] = lex_normal_s462;
v->a[463] = lex_normal_s463;
v->a[464] = lex_normal_s464;
v->a[465] = lex_normal_s465;
v->a[466] = lex_normal_s466;
v->a[467] = lex_normal_s467;
v->a[468] = lex_normal_s468;
v->a[469] = lex_normal_s469;
v->a[470] = lex_normal_s470;
v->a[471] = lex_normal_s471;
v->a[472] = lex_normal_s472;
v->a[473] = lex_normal_s473;
v->a[474] = lex_normal_s474;
v->a[475] = lex_normal_s475;
v->a[476] = lex_normal_s476;
v->a[477] = lex_normal_s477;
v->a[478] = lex_normal_s478;
v->a[479] = lex_normal_s479;
lex_normal_array_24(v);
}
void lex_normal_array_24(t_lex_normal_array *v)
{
v->a[480] = lex_normal_s480;
v->a[481] = lex_normal_s481;
v->a[482] = lex_normal_s482;
v->a[483] = lex_normal_s483;
v->a[484] = lex_normal_s484;
v->a[485] = lex_normal_s485;
v->a[486] = lex_normal_s486;
v->a[487] = lex_normal_s487;
v->a[488] = lex_normal_s488;
v->a[489] = lex_normal_s489;
v->a[490] = lex_normal_s490;
v->a[491] = lex_normal_s491;
v->a[492] = lex_normal_s492;
v->a[493] = lex_normal_s493;
v->a[494] = lex_normal_s494;
v->a[495] = lex_normal_s495;
v->a[496] = lex_normal_s496;
v->a[497] = lex_normal_s497;
v->a[498] = lex_normal_s498;
v->a[499] = lex_normal_s499;
lex_normal_array_25(v);
}
/* EOF lex_normal_array_4.c */

145
parser/static/lex_funcs/lex_normal/create_table/lex_normal_array_5.c Normal file
View file

@ -0,0 +1,145 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lex_normal_array_5.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 "../../../headers/symbols.h"
#include "../../../headers/external_scanner_symbol_identifiers.h"
#include "../../../headers/field_identifiers.h"
#include "../../../headers/constants.h"
#include "../lex_normal_funcs.h"
#include "./lex_normal_array.h"
void lex_normal_array_25(t_lex_normal_array *v)
{
v->a[500] = lex_normal_s500;
v->a[501] = lex_normal_s501;
v->a[502] = lex_normal_s502;
v->a[503] = lex_normal_s503;
v->a[504] = lex_normal_s504;
v->a[505] = lex_normal_s505;
v->a[506] = lex_normal_s506;
v->a[507] = lex_normal_s507;
v->a[508] = lex_normal_s508;
v->a[509] = lex_normal_s509;
v->a[510] = lex_normal_s510;
v->a[511] = lex_normal_s511;
v->a[512] = lex_normal_s512;
v->a[513] = lex_normal_s513;
v->a[514] = lex_normal_s514;
v->a[515] = lex_normal_s515;
v->a[516] = lex_normal_s516;
v->a[517] = lex_normal_s517;
v->a[518] = lex_normal_s518;
v->a[519] = lex_normal_s519;
lex_normal_array_26(v);
}
void lex_normal_array_26(t_lex_normal_array *v)
{
v->a[520] = lex_normal_s520;
v->a[521] = lex_normal_s521;
v->a[522] = lex_normal_s522;
v->a[523] = lex_normal_s523;
v->a[524] = lex_normal_s524;
v->a[525] = lex_normal_s525;
v->a[526] = lex_normal_s526;
v->a[527] = lex_normal_s527;
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;
v->a[536] = lex_normal_s536;
v->a[537] = lex_normal_s537;
v->a[538] = lex_normal_s538;
v->a[539] = lex_normal_s539;
lex_normal_array_27(v);
}
void lex_normal_array_27(t_lex_normal_array *v)
{
v->a[540] = lex_normal_s540;
v->a[541] = lex_normal_s541;
v->a[542] = lex_normal_s542;
v->a[543] = lex_normal_s543;
v->a[544] = lex_normal_s544;
v->a[545] = lex_normal_s545;
v->a[546] = lex_normal_s546;
v->a[547] = lex_normal_s547;
v->a[548] = lex_normal_s548;
v->a[549] = lex_normal_s549;
v->a[550] = lex_normal_s550;
v->a[551] = lex_normal_s551;
v->a[552] = lex_normal_s552;
v->a[553] = lex_normal_s553;
v->a[554] = lex_normal_s554;
v->a[555] = lex_normal_s555;
v->a[556] = lex_normal_s556;
v->a[557] = lex_normal_s557;
v->a[558] = lex_normal_s558;
v->a[559] = lex_normal_s559;
lex_normal_array_28(v);
}
void lex_normal_array_28(t_lex_normal_array *v)
{
v->a[560] = lex_normal_s560;
v->a[561] = lex_normal_s561;
v->a[562] = lex_normal_s562;
v->a[563] = lex_normal_s563;
v->a[564] = lex_normal_s564;
v->a[565] = lex_normal_s565;
v->a[566] = lex_normal_s566;
v->a[567] = lex_normal_s567;
v->a[568] = lex_normal_s568;
v->a[569] = lex_normal_s569;
v->a[570] = lex_normal_s570;
v->a[571] = lex_normal_s571;
v->a[572] = lex_normal_s572;
v->a[573] = lex_normal_s573;
v->a[574] = lex_normal_s574;
v->a[575] = lex_normal_s575;
v->a[576] = lex_normal_s576;
v->a[577] = lex_normal_s577;
v->a[578] = lex_normal_s578;
v->a[579] = lex_normal_s579;
lex_normal_array_29(v);
}
void lex_normal_array_29(t_lex_normal_array *v)
{
v->a[580] = lex_normal_s580;
v->a[581] = lex_normal_s581;
v->a[582] = lex_normal_s582;
v->a[583] = lex_normal_s583;
v->a[584] = lex_normal_s584;
v->a[585] = lex_normal_s585;
v->a[586] = lex_normal_s586;
v->a[587] = lex_normal_s587;
v->a[588] = lex_normal_s588;
v->a[589] = lex_normal_s589;
v->a[590] = lex_normal_s590;
v->a[591] = lex_normal_s591;
v->a[592] = lex_normal_s592;
v->a[593] = lex_normal_s593;
v->a[594] = lex_normal_s594;
v->a[595] = lex_normal_s595;
v->a[596] = lex_normal_s596;
v->a[597] = lex_normal_s597;
v->a[598] = lex_normal_s598;
v->a[599] = lex_normal_s599;
lex_normal_array_30(v);
}
/* EOF lex_normal_array_5.c */

145
parser/static/lex_funcs/lex_normal/create_table/lex_normal_array_6.c Normal file
View file

@ -0,0 +1,145 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lex_normal_array_6.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 "../../../headers/symbols.h"
#include "../../../headers/external_scanner_symbol_identifiers.h"
#include "../../../headers/field_identifiers.h"
#include "../../../headers/constants.h"
#include "../lex_normal_funcs.h"
#include "./lex_normal_array.h"
void lex_normal_array_30(t_lex_normal_array *v)
{
v->a[600] = lex_normal_s600;
v->a[601] = lex_normal_s601;
v->a[602] = lex_normal_s602;
v->a[603] = lex_normal_s603;
v->a[604] = lex_normal_s604;
v->a[605] = lex_normal_s605;
v->a[606] = lex_normal_s606;
v->a[607] = lex_normal_s607;
v->a[608] = lex_normal_s608;
v->a[609] = lex_normal_s609;
v->a[610] = lex_normal_s610;
v->a[611] = lex_normal_s611;
v->a[612] = lex_normal_s612;
v->a[613] = lex_normal_s613;
v->a[614] = lex_normal_s614;
v->a[615] = lex_normal_s615;
v->a[616] = lex_normal_s616;
v->a[617] = lex_normal_s617;
v->a[618] = lex_normal_s618;
v->a[619] = lex_normal_s619;
lex_normal_array_31(v);
}
void lex_normal_array_31(t_lex_normal_array *v)
{
v->a[620] = lex_normal_s620;
v->a[621] = lex_normal_s621;
v->a[622] = lex_normal_s622;
v->a[623] = lex_normal_s623;
v->a[624] = lex_normal_s624;
v->a[625] = lex_normal_s625;
v->a[626] = lex_normal_s626;
v->a[627] = lex_normal_s627;
v->a[628] = lex_normal_s628;
v->a[629] = lex_normal_s629;
v->a[630] = lex_normal_s630;
v->a[631] = lex_normal_s631;
v->a[632] = lex_normal_s632;
v->a[633] = lex_normal_s633;
v->a[634] = lex_normal_s634;
v->a[635] = lex_normal_s635;
v->a[636] = lex_normal_s636;
v->a[637] = lex_normal_s637;
v->a[638] = lex_normal_s638;
v->a[639] = lex_normal_s639;
lex_normal_array_32(v);
}
void lex_normal_array_32(t_lex_normal_array *v)
{
v->a[640] = lex_normal_s640;
v->a[641] = lex_normal_s641;
v->a[642] = lex_normal_s642;
v->a[643] = lex_normal_s643;
v->a[644] = lex_normal_s644;
v->a[645] = lex_normal_s645;
v->a[646] = lex_normal_s646;
v->a[647] = lex_normal_s647;
v->a[648] = lex_normal_s648;
v->a[649] = lex_normal_s649;
v->a[650] = lex_normal_s650;
v->a[651] = lex_normal_s651;
v->a[652] = lex_normal_s652;
v->a[653] = lex_normal_s653;
v->a[654] = lex_normal_s654;
v->a[655] = lex_normal_s655;
v->a[656] = lex_normal_s656;
v->a[657] = lex_normal_s657;
v->a[658] = lex_normal_s658;
v->a[659] = lex_normal_s659;
lex_normal_array_33(v);
}
void lex_normal_array_33(t_lex_normal_array *v)
{
v->a[660] = lex_normal_s660;
v->a[661] = lex_normal_s661;
v->a[662] = lex_normal_s662;
v->a[663] = lex_normal_s663;
v->a[664] = lex_normal_s664;
v->a[665] = lex_normal_s665;
v->a[666] = lex_normal_s666;
v->a[667] = lex_normal_s667;
v->a[668] = lex_normal_s668;
v->a[669] = lex_normal_s669;
v->a[670] = lex_normal_s670;
v->a[671] = lex_normal_s671;
v->a[672] = lex_normal_s672;
v->a[673] = lex_normal_s673;
v->a[674] = lex_normal_s674;
v->a[675] = lex_normal_s675;
v->a[676] = lex_normal_s676;
v->a[677] = lex_normal_s677;
v->a[678] = lex_normal_s678;
v->a[679] = lex_normal_s679;
lex_normal_array_34(v);
}
void lex_normal_array_34(t_lex_normal_array *v)
{
v->a[680] = lex_normal_s680;
v->a[681] = lex_normal_s681;
v->a[682] = lex_normal_s682;
v->a[683] = lex_normal_s683;
v->a[684] = lex_normal_s684;
v->a[685] = lex_normal_s685;
v->a[686] = lex_normal_s686;
v->a[687] = lex_normal_s687;
v->a[688] = lex_normal_s688;
v->a[689] = lex_normal_s689;
v->a[690] = lex_normal_s690;
v->a[691] = lex_normal_s691;
v->a[692] = lex_normal_s692;
v->a[693] = lex_normal_s693;
v->a[694] = lex_normal_s694;
v->a[695] = lex_normal_s695;
v->a[696] = lex_normal_s696;
v->a[697] = lex_normal_s697;
v->a[698] = lex_normal_s698;
v->a[699] = lex_normal_s699;
lex_normal_array_35(v);
}
/* EOF lex_normal_array_6.c */

145
parser/static/lex_funcs/lex_normal/create_table/lex_normal_array_7.c Normal file
View file

@ -0,0 +1,145 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lex_normal_array_7.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 "../../../headers/symbols.h"
#include "../../../headers/external_scanner_symbol_identifiers.h"
#include "../../../headers/field_identifiers.h"
#include "../../../headers/constants.h"
#include "../lex_normal_funcs.h"
#include "./lex_normal_array.h"
void lex_normal_array_35(t_lex_normal_array *v)
{
v->a[700] = lex_normal_s700;
v->a[701] = lex_normal_s701;
v->a[702] = lex_normal_s702;
v->a[703] = lex_normal_s703;
v->a[704] = lex_normal_s704;
v->a[705] = lex_normal_s705;
v->a[706] = lex_normal_s706;
v->a[707] = lex_normal_s707;
v->a[708] = lex_normal_s708;
v->a[709] = lex_normal_s709;
v->a[710] = lex_normal_s710;
v->a[711] = lex_normal_s711;
v->a[712] = lex_normal_s712;
v->a[713] = lex_normal_s713;
v->a[714] = lex_normal_s714;
v->a[715] = lex_normal_s715;
v->a[716] = lex_normal_s716;
v->a[717] = lex_normal_s717;
v->a[718] = lex_normal_s718;
v->a[719] = lex_normal_s719;
lex_normal_array_36(v);
}
void lex_normal_array_36(t_lex_normal_array *v)
{
v->a[720] = lex_normal_s720;
v->a[721] = lex_normal_s721;
v->a[722] = lex_normal_s722;
v->a[723] = lex_normal_s723;
v->a[724] = lex_normal_s724;
v->a[725] = lex_normal_s725;
v->a[726] = lex_normal_s726;
v->a[727] = lex_normal_s727;
v->a[728] = lex_normal_s728;
v->a[729] = lex_normal_s729;
v->a[730] = lex_normal_s730;
v->a[731] = lex_normal_s731;
v->a[732] = lex_normal_s732;
v->a[733] = lex_normal_s733;
v->a[734] = lex_normal_s734;
v->a[735] = lex_normal_s735;
v->a[736] = lex_normal_s736;
v->a[737] = lex_normal_s737;
v->a[738] = lex_normal_s738;
v->a[739] = lex_normal_s739;
lex_normal_array_37(v);
}
void lex_normal_array_37(t_lex_normal_array *v)
{
v->a[740] = lex_normal_s740;
v->a[741] = lex_normal_s741;
v->a[742] = lex_normal_s742;
v->a[743] = lex_normal_s743;
v->a[744] = lex_normal_s744;
v->a[745] = lex_normal_s745;
v->a[746] = lex_normal_s746;
v->a[747] = lex_normal_s747;
v->a[748] = lex_normal_s748;
v->a[749] = lex_normal_s749;
v->a[750] = lex_normal_s750;
v->a[751] = lex_normal_s751;
v->a[752] = lex_normal_s752;
v->a[753] = lex_normal_s753;
v->a[754] = lex_normal_s754;
v->a[755] = lex_normal_s755;
v->a[756] = lex_normal_s756;
v->a[757] = lex_normal_s757;
v->a[758] = lex_normal_s758;
v->a[759] = lex_normal_s759;
lex_normal_array_38(v);
}
void lex_normal_array_38(t_lex_normal_array *v)
{
v->a[760] = lex_normal_s760;
v->a[761] = lex_normal_s761;
v->a[762] = lex_normal_s762;
v->a[763] = lex_normal_s763;
v->a[764] = lex_normal_s764;
v->a[765] = lex_normal_s765;
v->a[766] = lex_normal_s766;
v->a[767] = lex_normal_s767;
v->a[768] = lex_normal_s768;
v->a[769] = lex_normal_s769;
v->a[770] = lex_normal_s770;
v->a[771] = lex_normal_s771;
v->a[772] = lex_normal_s772;
v->a[773] = lex_normal_s773;
v->a[774] = lex_normal_s774;
v->a[775] = lex_normal_s775;
v->a[776] = lex_normal_s776;
v->a[777] = lex_normal_s777;
v->a[778] = lex_normal_s778;
v->a[779] = lex_normal_s779;
lex_normal_array_39(v);
}
void lex_normal_array_39(t_lex_normal_array *v)
{
v->a[780] = lex_normal_s780;
v->a[781] = lex_normal_s781;
v->a[782] = lex_normal_s782;
v->a[783] = lex_normal_s783;
v->a[784] = lex_normal_s784;
v->a[785] = lex_normal_s785;
v->a[786] = lex_normal_s786;
v->a[787] = lex_normal_s787;
v->a[788] = lex_normal_s788;
v->a[789] = lex_normal_s789;
v->a[790] = lex_normal_s790;
v->a[791] = lex_normal_s791;
v->a[792] = lex_normal_s792;
v->a[793] = lex_normal_s793;
v->a[794] = lex_normal_s794;
v->a[795] = lex_normal_s795;
v->a[796] = lex_normal_s796;
v->a[797] = lex_normal_s797;
v->a[798] = lex_normal_s798;
v->a[799] = lex_normal_s799;
lex_normal_array_40(v);
}
/* EOF lex_normal_array_7.c */

145
parser/static/lex_funcs/lex_normal/create_table/lex_normal_array_8.c Normal file
View file

@ -0,0 +1,145 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lex_normal_array_8.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 "../../../headers/symbols.h"
#include "../../../headers/external_scanner_symbol_identifiers.h"
#include "../../../headers/field_identifiers.h"
#include "../../../headers/constants.h"
#include "../lex_normal_funcs.h"
#include "./lex_normal_array.h"
void lex_normal_array_40(t_lex_normal_array *v)
{
v->a[800] = lex_normal_s800;
v->a[801] = lex_normal_s801;
v->a[802] = lex_normal_s802;
v->a[803] = lex_normal_s803;
v->a[804] = lex_normal_s804;
v->a[805] = lex_normal_s805;
v->a[806] = lex_normal_s806;
v->a[807] = lex_normal_s807;
v->a[808] = lex_normal_s808;
v->a[809] = lex_normal_s809;
v->a[810] = lex_normal_s810;
v->a[811] = lex_normal_s811;
v->a[812] = lex_normal_s812;
v->a[813] = lex_normal_s813;
v->a[814] = lex_normal_s814;
v->a[815] = lex_normal_s815;
v->a[816] = lex_normal_s816;
v->a[817] = lex_normal_s817;
v->a[818] = lex_normal_s818;
v->a[819] = lex_normal_s819;
lex_normal_array_41(v);
}
void lex_normal_array_41(t_lex_normal_array *v)
{
v->a[820] = lex_normal_s820;
v->a[821] = lex_normal_s821;
v->a[822] = lex_normal_s822;
v->a[823] = lex_normal_s823;
v->a[824] = lex_normal_s824;
v->a[825] = lex_normal_s825;
v->a[826] = lex_normal_s826;
v->a[827] = lex_normal_s827;
v->a[828] = lex_normal_s828;
v->a[829] = lex_normal_s829;
v->a[830] = lex_normal_s830;
v->a[831] = lex_normal_s831;
v->a[832] = lex_normal_s832;
v->a[833] = lex_normal_s833;
v->a[834] = lex_normal_s834;
v->a[835] = lex_normal_s835;
v->a[836] = lex_normal_s836;
v->a[837] = lex_normal_s837;
v->a[838] = lex_normal_s838;
v->a[839] = lex_normal_s839;
lex_normal_array_42(v);
}
void lex_normal_array_42(t_lex_normal_array *v)
{
v->a[840] = lex_normal_s840;
v->a[841] = lex_normal_s841;
v->a[842] = lex_normal_s842;
v->a[843] = lex_normal_s843;
v->a[844] = lex_normal_s844;
v->a[845] = lex_normal_s845;
v->a[846] = lex_normal_s846;
v->a[847] = lex_normal_s847;
v->a[848] = lex_normal_s848;
v->a[849] = lex_normal_s849;
v->a[850] = lex_normal_s850;
v->a[851] = lex_normal_s851;
v->a[852] = lex_normal_s852;
v->a[853] = lex_normal_s853;
v->a[854] = lex_normal_s854;
v->a[855] = lex_normal_s855;
v->a[856] = lex_normal_s856;
v->a[857] = lex_normal_s857;
v->a[858] = lex_normal_s858;
v->a[859] = lex_normal_s859;
lex_normal_array_43(v);
}
void lex_normal_array_43(t_lex_normal_array *v)
{
v->a[860] = lex_normal_s860;
v->a[861] = lex_normal_s861;
v->a[862] = lex_normal_s862;
v->a[863] = lex_normal_s863;
v->a[864] = lex_normal_s864;
v->a[865] = lex_normal_s865;
v->a[866] = lex_normal_s866;
v->a[867] = lex_normal_s867;
v->a[868] = lex_normal_s868;
v->a[869] = lex_normal_s869;
v->a[870] = lex_normal_s870;
v->a[871] = lex_normal_s871;
v->a[872] = lex_normal_s872;
v->a[873] = lex_normal_s873;
v->a[874] = lex_normal_s874;
v->a[875] = lex_normal_s875;
v->a[876] = lex_normal_s876;
v->a[877] = lex_normal_s877;
v->a[878] = lex_normal_s878;
v->a[879] = lex_normal_s879;
lex_normal_array_44(v);
}
void lex_normal_array_44(t_lex_normal_array *v)
{
v->a[880] = lex_normal_s880;
v->a[881] = lex_normal_s881;
v->a[882] = lex_normal_s882;
v->a[883] = lex_normal_s883;
v->a[884] = lex_normal_s884;
v->a[885] = lex_normal_s885;
v->a[886] = lex_normal_s886;
v->a[887] = lex_normal_s887;
v->a[888] = lex_normal_s888;
v->a[889] = lex_normal_s889;
v->a[890] = lex_normal_s890;
v->a[891] = lex_normal_s891;
v->a[892] = lex_normal_s892;
v->a[893] = lex_normal_s893;
v->a[894] = lex_normal_s894;
v->a[895] = lex_normal_s895;
v->a[896] = lex_normal_s896;
v->a[897] = lex_normal_s897;
v->a[898] = lex_normal_s898;
v->a[899] = lex_normal_s899;
lex_normal_array_45(v);
}
/* EOF lex_normal_array_8.c */

92
parser/static/lex_funcs/lex_normal/create_table/lex_normal_array_9.c Normal file
View file

@ -0,0 +1,92 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lex_normal_array_9.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 "../../../headers/symbols.h"
#include "../../../headers/external_scanner_symbol_identifiers.h"
#include "../../../headers/field_identifiers.h"
#include "../../../headers/constants.h"
#include "../lex_normal_funcs.h"
#include "./lex_normal_array.h"
void lex_normal_array_45(t_lex_normal_array *v)
{
v->a[900] = lex_normal_s900;
v->a[901] = lex_normal_s901;
v->a[902] = lex_normal_s902;
v->a[903] = lex_normal_s903;
v->a[904] = lex_normal_s904;
v->a[905] = lex_normal_s905;
v->a[906] = lex_normal_s906;
v->a[907] = lex_normal_s907;
v->a[908] = lex_normal_s908;
v->a[909] = lex_normal_s909;
v->a[910] = lex_normal_s910;
v->a[911] = lex_normal_s911;
v->a[912] = lex_normal_s912;
v->a[913] = lex_normal_s913;
v->a[914] = lex_normal_s914;
v->a[915] = lex_normal_s915;
v->a[916] = lex_normal_s916;
v->a[917] = lex_normal_s917;
v->a[918] = lex_normal_s918;
v->a[919] = lex_normal_s919;
lex_normal_array_46(v);
}
void lex_normal_array_46(t_lex_normal_array *v)
{
v->a[920] = lex_normal_s920;
v->a[921] = lex_normal_s921;
v->a[922] = lex_normal_s922;
v->a[923] = lex_normal_s923;
v->a[924] = lex_normal_s924;
v->a[925] = lex_normal_s925;
v->a[926] = lex_normal_s926;
v->a[927] = lex_normal_s927;
v->a[928] = lex_normal_s928;
v->a[929] = lex_normal_s929;
v->a[930] = lex_normal_s930;
v->a[931] = lex_normal_s931;
v->a[932] = lex_normal_s932;
v->a[933] = lex_normal_s933;
v->a[934] = lex_normal_s934;
v->a[935] = lex_normal_s935;
v->a[936] = lex_normal_s936;
v->a[937] = lex_normal_s937;
v->a[938] = lex_normal_s938;
v->a[939] = lex_normal_s939;
lex_normal_array_47(v);
}
void lex_normal_array_47(t_lex_normal_array *v)
{
v->a[940] = lex_normal_s940;
v->a[941] = lex_normal_s941;
v->a[942] = lex_normal_s942;
v->a[943] = lex_normal_s943;
v->a[944] = lex_normal_s944;
v->a[945] = lex_normal_s945;
v->a[946] = lex_normal_s946;
v->a[947] = lex_normal_s947;
v->a[948] = lex_normal_s948;
v->a[949] = lex_normal_s949;
v->a[950] = lex_normal_s950;
v->a[951] = lex_normal_s951;
v->a[952] = lex_normal_s952;
v->a[953] = lex_normal_s953;
v->a[954] = lex_normal_s954;
v->a[955] = lex_normal_s955;
v->a[956] = lex_normal_s956;
v->a[957] = lex_normal_s957;
v->a[958] = lex_normal_s958;
}
/* EOF lex_normal_array_9.c */

69
parser/static/lex_funcs/lex_normal/inline.h Normal file
View file

@ -0,0 +1,69 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline.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_H
# define INLINE_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"
# include "./inline/inline_impl0.h"
# include "./inline/inline_impl1.h"
# include "./inline/inline_impl2.h"
# include "./inline/inline_impl3.h"
# include "./inline/inline_impl4.h"
# include "./inline/inline_impl5.h"
# include "./inline/inline_impl6.h"
# include "./inline/inline_impl7.h"
# include "./inline/inline_impl8.h"
# include "./inline/inline_impl9.h"
# include "./inline/inline_impl10.h"
# include "./inline/inline_impl11.h"
# include "./inline/inline_impl12.h"
# include "./inline/inline_impl13.h"
# include "./inline/inline_impl14.h"
# include "./inline/inline_impl15.h"
# include "./inline/inline_impl16.h"
# include "./inline/inline_impl17.h"
# include "./inline/inline_impl18.h"
# include "./inline/inline_impl19.h"
# include "./inline/inline_impl20.h"
# include "./inline/inline_impl21.h"
# include "./inline/inline_impl22.h"
# include "./inline/inline_impl23.h"
# include "./inline/inline_impl24.h"
# include "./inline/inline_impl25.h"
# include "./inline/inline_impl26.h"
# include "./inline/inline_impl27.h"
# include "./inline/inline_impl28.h"
# include "./inline/inline_impl29.h"
# include "./inline/inline_impl30.h"
# include "./inline/inline_impl31.h"
# include "./inline/inline_impl32.h"
# include "./inline/inline_impl33.h"
# include "./inline/inline_impl34.h"
# include "./inline/inline_impl35.h"
# include "./inline/inline_impl36.h"
# include "./inline/inline_impl37.h"
# include "./inline/inline_impl38.h"
# include "./inline/inline_impl39.h"
# include "./inline/inline_impl40.h"
# include "./inline/inline_impl41.h"
# include "./inline/inline_impl42.h"
# include "./inline/inline_impl43.h"
# include "./inline/inline_impl44.h"
# include "./inline/inline_impl45.h"
# include "./inline/inline_impl46.h"
#endif // INLINE_H

86
parser/static/lex_funcs/lex_normal/inline/inline_impl0.h Normal file
View file

@ -0,0 +1,86 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl0.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_IMPL0_H
# define INLINE_IMPL0_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_map0(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 820, '"', 788, '#', 825, \
'$', 781, '%', 647, '&', 601, '\'', 491, '(', 654, ')', \
655, '*', 824, '+', 770, ',', 557, '-', 768, '.', 949, \
'/', 642, '0', 944, ':', 763, ';', 554, '<', 607, '=', \
827, '>', 616, '?', 837, '@', 822, '[', 674, '\\', 301, \
']', 675, '^', 595, '_', 946, '`', 856, 'e', 956, 'i', \
955, '{', 666, '|', 592, '}', 778, '~', 772};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map6(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 688, '!', 670, '"', 788, \
'#', 862, '$', 781, '%', 649, '&', 601, '\'', 491, '(', \
654, ')', 655, '*', 638, '+', 771, '-', 769, '/', 644, \
'0', 803, ';', 555, '<', 607, '=', 560, '>', 616, '?', \
761, '\\', 307, '^', 596, '`', 856, '|', 592, '~', 772, \
'[', 786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map12(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 689, '!', 670, '"', 788, \
'#', 816, '$', 781, '%', 649, '&', 601, '\'', 491, '(', \
654, ')', 655, '*', 638, '+', 630, '-', 633, '/', 644, \
'0', 943, ';', 555, '<', 607, '=', 560, '>', 616, '?', \
761, '@', 942, '\\', 14, '^', 596, '_', 947, '`', 855, \
'|', 592, '[', 786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map83(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 690, '!', 506, '#', 862, \
'%', 650, '&', 600, '*', 639, '+', 631, ',', 556, '-', \
635, '/', 645, ';', 553, '<', 615, '=', 561, '>', 620};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map84(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 690, '"', 788, '#', 862, \
'$', 785, '&', 599, '(', 653, '+', 500, ',', 556, '-', \
502, '0', 809, ';', 553};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif // INLINE_IMPL0_H

86
parser/static/lex_funcs/lex_normal/inline/inline_impl1.h Normal file
View file

@ -0,0 +1,86 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl1.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_IMPL1_H
# define INLINE_IMPL1_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_map85(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 690, '#', 862, '$', 783, \
'&', 489, '(', 654, '-', 504, '0', 808, ':', 762, '<', \
611, '>', 618};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map146(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 691, '!', 951, '"', 788, \
'#', 862, '$', 781, '%', 649, '&', 601, '\'', 491, '(', \
654, ')', 655, '*', 638, '+', 630, '-', 633, '/', 644, \
'0', 803, ';', 555, '<', 607, '=', 560, '>', 616, '?', \
761, '\\', 316, '^', 596, '`', 856, '|', 592, '[', 786, \
']', 786, '{', 786, '}', 786};
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[] = {'\n', 692, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
945, ';', 554, '<', 612, '>', 618, '?', 760, '@', 941, \
'\\', 81, '_', 948, 'e', 877, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map219(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 693, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 654, '*', \
640, '-', 636, '0', 943, ';', 554, '<', 609, '=', 952, \
'>', 617, '?', 761, '@', 942, '\\', 27, '_', 947, '`', \
855, 'e', 871, '|', 593, '[', 786, ']', 786, '{', 786, \
'}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map236(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 694, '!', 951, '"', 788, \
'#', 862, '$', 781, '%', 649, '&', 601, '\'', 491, '(', \
654, ')', 655, '*', 638, '+', 630, '-', 633, '/', 644, \
'0', 803, ';', 555, '<', 607, '=', 560, '>', 616, '?', \
761, '\\', 317, '^', 596, '`', 855, '|', 592, '[', 786, \
']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif // INLINE_IMPL1_H

86
parser/static/lex_funcs/lex_normal/inline/inline_impl10.h Normal file
View file

@ -0,0 +1,86 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl10.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_IMPL10_H
# define INLINE_IMPL10_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_map277(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 735, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 654, '-', 950, '0', \
803, ';', 554, '<', 609, '=', 952, '>', 617, '\\', 335, \
'`', 856, 'e', 956, '|', 593, '[', 786, ']', 786, '{', \
786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map278(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 736, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, ')', \
655, '*', 640, '-', 636, '0', 943, ';', 555, '<', 610, \
'>', 617, '?', 761, '@', 942, '\\', 228, '_', 947, '`', \
855, '|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map279(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 737, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 654, '-', 950, '0', \
803, ';', 554, '<', 609, '=', 952, '>', 617, '\\', 337, \
'`', 856, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map280(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 738, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, ';', 555, '<', 610, '>', 617, \
'?', 761, '@', 942, '\\', 207, '_', 947, '`', 855, '|', \
593, '[', 786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map281(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 739, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 654, ')', 655, '-', \
950, '0', 803, ';', 555, '<', 609, '=', 952, '>', 617, \
'\\', 339, '`', 856, '|', 593, '[', 786, ']', 786, '{', \
786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif // INLINE_IMPL10_H

86
parser/static/lex_funcs/lex_normal/inline/inline_impl11.h Normal file
View file

@ -0,0 +1,86 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl11.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_IMPL11_H
# define INLINE_IMPL11_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_map282(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 740, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 489, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, '<', 609, '=', 952, '>', 617, \
'?', 761, '@', 942, '\\', 168, '_', 947, '`', 855, '|', \
593, '[', 786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map283(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 741, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
804, ';', 554, '<', 610, '>', 617, '\\', 341, '`', 856, \
'e', 866, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map284(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 742, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 489, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, '<', 609, '>', 617, '?', 761, \
'@', 942, '\\', 58, '_', 947, '`', 855, '|', 593, '[', \
786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map285(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 743, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
803, ';', 554, '<', 609, '>', 617, '\\', 343, '`', 856, \
'e', 956, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map286(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 744, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 489, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, '<', 610, '>', 617, '?', 761, \
'@', 942, '\\', 233, '_', 947, '`', 855, '|', 593, '[', \
786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif // INLINE_IMPL11_H

84
parser/static/lex_funcs/lex_normal/inline/inline_impl12.h Normal file
View file

@ -0,0 +1,84 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl12.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_IMPL12_H
# define INLINE_IMPL12_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_map287(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 745, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
804, ';', 554, '<', 610, '>', 617, '\\', 344, '`', 856, \
'|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map288(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 746, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 489, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, '<', 608, '>', 617, '?', 761, \
'@', 942, '\\', 176, '_', 947, '`', 855, '|', 516, '[', \
786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map289(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 747, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
803, ';', 554, '<', 609, '>', 617, '\\', 346, '`', 856, \
'|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map290(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 748, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 599, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, ';', 555, '<', 495, '>', 496, \
'?', 761, '@', 942, '\\', 100, '_', 947, '`', 855, '[', \
786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map291(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 749, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
803, ';', 554, '<', 610, '>', 617, '\\', 347, '`', 856, \
'e', 956, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif // INLINE_IMPL12_H

85
parser/static/lex_funcs/lex_normal/inline/inline_impl13.h Normal file
View file

@ -0,0 +1,85 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl13.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_IMPL13_H
# define INLINE_IMPL13_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_map292(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 750, '!', 672, '"', 788, \
'#', 816, '$', 781, '\'', 491, '(', 494, '*', 640, '-', \
636, '0', 943, '<', 495, '>', 496, '?', 761, '@', 942, \
'\\', 112, '_', 947, '`', 855, '[', 786, ']', 786, '{', \
786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map293(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 751, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, ')', 655, '-', \
950, '0', 804, ';', 555, '<', 610, '>', 617, '\\', 349, \
'`', 856, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map294(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 752, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, ')', 655, '-', \
950, '0', 803, ';', 555, '<', 609, '>', 617, '\\', 350, \
'`', 856, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map295(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 753, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
803, ';', 554, '<', 610, '>', 617, '\\', 351, '`', 856, \
'|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map296(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 754, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, ')', 655, '-', \
950, '0', 803, ';', 555, '<', 610, '>', 617, '\\', 354, \
'`', 856, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif // INLINE_IMPL13_H

84
parser/static/lex_funcs/lex_normal/inline/inline_impl14.h Normal file
View file

@ -0,0 +1,84 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl14.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_IMPL14_H
# define INLINE_IMPL14_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_map297(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 755, '"', 788, '#', 862, \
'$', 781, '&', 599, '\'', 491, '(', 654, '-', 950, '0', \
803, ';', 555, '<', 495, '>', 496, '\\', 357, '`', 855, \
'e', 956, '[', 786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map298(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 756, '"', 788, '#', 862, \
'$', 781, '&', 489, '\'', 491, '(', 494, '-', 950, '0', \
803, '<', 608, '>', 617, '\\', 370, '`', 856, '|', 516, \
'[', 786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map299(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 757, '"', 788, '#', 862, \
'$', 781, '&', 599, '\'', 491, '(', 494, '-', 950, '0', \
803, ';', 555, '<', 495, '>', 496, '\\', 372, '`', 855, \
'[', 786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map300(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 758, '"', 788, '#', 862, \
'$', 781, '&', 599, '\'', 491, '(', 494, '-', 950, '0', \
803, ';', 555, '<', 495, '>', 496, '\\', 381, '`', 856, \
'[', 786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map401(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 670, '"', 788, '#', 816, \
'$', 781, '%', 647, '&', 601, '\'', 491, '(', 654, ')', \
655, '*', 638, '+', 770, ',', 557, '-', 768, '/', 642, \
'0', 944, ':', 765, ';', 554, '<', 607, '=', 563, '>', \
616, '?', 761, '@', 942, '[', 674, '\\', 301, ']', 675, \
'^', 595, '_', 946, '`', 856, 'e', 956, 'i', 955, '{', \
666, '|', 592, '}', 818, '~', 772};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif // INLINE_IMPL14_H

91
parser/static/lex_funcs/lex_normal/inline/inline_impl15.h Normal file
View file

@ -0,0 +1,91 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl15.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_IMPL15_H
# define INLINE_IMPL15_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_map402(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 670, '"', 788, '#', 816, \
'$', 781, '%', 649, '&', 601, '\'', 491, '(', 654, '*', \
638, '+', 630, '-', 633, '/', 644, '0', 943, '<', 607, \
'=', 560, '>', 616, '?', 761, '@', 942, '\\', 19, ']', \
675, '^', 596, '_', 947, '`', 855, '|', 592, '[', 786, \
'{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map403(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 670, '"', 788, '#', 862, \
'$', 781, '%', 649, '&', 601, '\'', 491, '(', 654, '*', \
638, '+', 771, '-', 769, '/', 644, '0', 803, '<', 607, \
'=', 560, '>', 616, '?', 761, '\\', 308, ']', 675, '^', \
596, '`', 856, '|', 592, '~', 772, '[', 786, '{', 786, \
'}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map404(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 670, '"', 788, '#', 862, \
'$', 781, '%', 649, '&', 600, '\'', 491, '(', 654, ')', \
655, '*', 638, '+', 771, '-', 769, '/', 644, '0', 803, \
'<', 614, '=', 560, '>', 619, '?', 761, '\\', 311, '^', \
596, '`', 856, '|', 594, '~', 772, '[', 786, ']', 786, \
'{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map405(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 670, '"', 788, '#', 862, \
'$', 781, '%', 649, '&', 600, '\'', 491, '(', 654, ')', \
499, '*', 638, '+', 771, '-', 769, '/', 644, '0', 803, \
'<', 614, '=', 560, '>', 619, '?', 761, '\\', 314, '^', \
596, '`', 856, '|', 594, '~', 772, '[', 786, ']', 786, \
'{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map406(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 670, '"', 788, '#', 862, \
'$', 781, '%', 649, '&', 600, '\'', 491, '(', 654, '*', \
638, '+', 771, '-', 769, '/', 644, '0', 803, ':', 765, \
'<', 614, '=', 560, '>', 619, '?', 761, '\\', 313, '^', \
596, '`', 856, '|', 594, '~', 772, '[', 786, ']', 786, \
'{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif // INLINE_IMPL15_H

88
parser/static/lex_funcs/lex_normal/inline/inline_impl16.h Normal file
View file

@ -0,0 +1,88 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl16.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_IMPL16_H
# define INLINE_IMPL16_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_map407(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 670, '"', 788, '#', 862, \
'$', 781, '%', 649, '&', 600, '\'', 491, '(', 654, '*', \
638, '+', 771, '-', 769, '/', 644, '0', 803, '<', 614, \
'=', 560, '>', 619, '?', 761, '\\', 312, ']', 675, '^', \
596, '`', 856, '|', 594, '~', 772, '[', 786, '{', 786, \
'}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map408(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 670, '"', 788, '#', 862, \
'$', 781, '%', 649, '&', 600, '\'', 491, '(', 654, '*', \
638, '+', 771, '-', 769, '/', 644, '0', 803, '<', 614, \
'=', 560, '>', 619, '?', 761, '\\', 315, ']', 787, '^', \
596, '`', 856, '|', 594, '~', 772, '[', 786, '{', 786, \
'}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map409(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
'$', 781, '&', 508, '\'', 491, '(', 494, '*', 640, '-', \
636, '0', 943, '<', 608, '>', 617, '?', 761, '@', 942, \
'\\', 74, '_', 947, '`', 855, '[', 786, ']', 786, '{', \
786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map410(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
'$', 781, '&', 489, '\'', 491, '(', 654, '*', 640, '-', \
636, '0', 943, '<', 609, '=', 952, '>', 617, '?', 761, \
'@', 942, '\\', 51, '_', 947, '`', 855, '|', 593, '[', \
786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map411(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
'$', 781, '&', 489, '\'', 491, '(', 494, '*', 640, '-', \
636, '0', 943, '<', 609, '=', 952, '>', 617, '?', 761, \
'@', 942, '\\', 171, '_', 947, '`', 855, '|', 593, '[', \
786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif // INLINE_IMPL16_H

86
parser/static/lex_funcs/lex_normal/inline/inline_impl17.h Normal file
View file

@ -0,0 +1,86 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl17.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_IMPL17_H
# define INLINE_IMPL17_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_map412(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
'$', 781, '&', 489, '\'', 491, '(', 494, '*', 640, '-', \
636, '0', 943, '<', 609, '>', 617, '?', 761, '@', 942, \
'\\', 55, ']', 675, '_', 947, '`', 855, '|', 593, '[', \
786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map413(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
'$', 781, '&', 489, '\'', 491, '(', 494, '*', 640, '-', \
636, '0', 943, '<', 609, '>', 617, '?', 761, '@', 942, \
'\\', 62, '_', 947, '`', 855, '|', 593, '[', 786, ']', \
786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map414(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
'$', 781, '&', 489, '\'', 491, '(', 494, '*', 640, '-', \
636, '0', 943, '<', 610, '>', 617, '?', 761, '@', 942, \
'\\', 231, ']', 675, '_', 947, '`', 855, '|', 593, '[', \
786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map415(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
'$', 781, '&', 489, '\'', 491, '(', 494, '*', 640, '-', \
636, '0', 943, '<', 610, '>', 617, '?', 761, '@', 942, \
'\\', 235, '_', 947, '`', 855, '|', 593, '[', 786, ']', \
786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map416(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
'$', 781, '\'', 491, '(', 494, ')', 655, '*', 640, '-', \
636, '0', 943, '<', 495, '>', 496, '?', 761, '@', 942, \
'\\', 110, '_', 947, '`', 855, '[', 786, ']', 786, '{', \
786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif // INLINE_IMPL17_H

83
parser/static/lex_funcs/lex_normal/inline/inline_impl18.h Normal file
View file

@ -0,0 +1,83 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl18.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_IMPL18_H
# define INLINE_IMPL18_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_map417(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 862, \
'$', 781, '&', 508, '\'', 491, '(', 654, ')', 655, '-', \
950, '0', 803, ';', 490, '<', 608, '>', 617, '[', 674, \
'\\', 304, '`', 855, '{', 666, '|', 590, ']', 786, '}', \
786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map418(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 862, \
'$', 781, '&', 508, '\'', 491, '(', 654, ')', 499, '+', \
771, '-', 769, '0', 803, '<', 608, '>', 617, '[', 674, \
'\\', 305, '`', 855, '{', 666, '|', 591, '~', 772, ']', \
786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map419(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 862, \
'$', 781, '&', 508, '\'', 491, '(', 654, '+', 771, '-', \
769, '0', 803, '<', 608, '>', 617, '[', 674, '\\', 306, \
']', 675, '`', 855, '{', 666, '}', 786, '~', 772};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map420(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 862, \
'$', 781, '&', 508, '\'', 491, '(', 654, '+', 771, '-', \
769, '0', 803, '<', 608, '>', 617, '[', 674, '\\', 320, \
'`', 855, '~', 772, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map421(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 862, \
'$', 781, '&', 508, '\'', 491, '(', 654, '-', 950, '0', \
803, ';', 490, '<', 608, '>', 617, '[', 674, '\\', 309, \
'`', 855, 'e', 956, '{', 666, ']', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif // INLINE_IMPL18_H

83
parser/static/lex_funcs/lex_normal/inline/inline_impl19.h Normal file
View file

@ -0,0 +1,83 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl19.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_IMPL19_H
# define INLINE_IMPL19_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_map422(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 862, \
'$', 781, '&', 508, '\'', 491, '(', 654, '-', 950, '0', \
803, '<', 608, '>', 617, '[', 674, '\\', 310, ']', 786, \
'`', 855, '{', 666, '}', 667};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map423(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 862, \
'$', 781, '\'', 491, '(', 654, ')', 499, '+', 771, '-', \
769, '0', 803, '<', 495, '>', 496, '\\', 352, '`', 855, \
'~', 772, '[', 786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map424(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 672, '"', 788, '#', 862, \
'$', 781, '\'', 491, '(', 654, ')', 499, '+', 771, '-', \
769, '0', 804, '<', 495, '>', 496, '\\', 332, '`', 855, \
'~', 772, '[', 786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map425(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 951, '"', 788, '#', 862, \
'$', 781, '%', 649, '&', 601, '\'', 491, '(', 654, '*', \
638, '+', 630, '-', 633, '/', 644, '0', 803, '<', 607, \
'=', 560, '>', 616, '?', 761, '\\', 318, ']', 675, '^', \
596, '`', 856, '|', 592, '[', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map426(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'!', 951, '"', 788, '#', 862, \
'$', 781, '%', 649, '&', 601, '\'', 491, '(', 654, '*', \
638, '+', 630, '-', 633, '/', 644, '0', 803, '<', 607, \
'=', 560, '>', 616, '?', 761, '\\', 319, ']', 675, '^', \
596, '`', 855, '|', 592, '[', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif // INLINE_IMPL19_H

85
parser/static/lex_funcs/lex_normal/inline/inline_impl2.h Normal file
View file

@ -0,0 +1,85 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl2.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_IMPL2_H
# define INLINE_IMPL2_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_map237(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 695, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
945, ';', 554, '<', 612, '>', 618, '?', 760, '@', 941, \
'\\', 91, '_', 948, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map238(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 696, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 654, '*', \
640, '-', 636, '0', 943, ';', 554, '<', 609, '=', 952, \
'>', 617, '?', 761, '@', 942, '\\', 30, '_', 947, '`', \
855, '|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map239(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 697, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 654, '-', 950, '0', \
803, ';', 554, '<', 609, '=', 952, '>', 617, '\\', 321, \
'`', 855, 'e', 956, '|', 593, '[', 786, ']', 786, '{', \
786, '}', 786};
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', 698, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
945, ';', 554, '<', 613, '>', 618, '?', 760, '@', 941, \
'\\', 183, '_', 948, 'e', 877, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map241(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 699, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, ';', 554, '<', 609, '=', 952, \
'>', 617, '?', 761, '@', 942, '\\', 153, '_', 947, '`', \
855, 'e', 871, '|', 593, '[', 786, ']', 786, '{', 786, \
'}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif // INLINE_IMPL2_H

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

85
parser/static/lex_funcs/lex_normal/inline/inline_impl3.h Normal file
View file

@ -0,0 +1,85 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl3.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_IMPL3_H
# define INLINE_IMPL3_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_map242(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 700, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 654, '-', 950, '0', \
803, ';', 554, '<', 609, '=', 952, '>', 617, '\\', 322, \
'`', 855, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map243(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 701, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
945, ';', 554, '<', 613, '>', 618, '?', 760, '@', 941, \
'\\', 185, '_', 948, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map244(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 702, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 654, ')', \
655, '*', 640, '-', 636, '0', 943, ';', 555, '<', 609, \
'=', 952, '>', 617, '?', 761, '@', 942, '\\', 32, '_', \
947, '`', 855, '|', 593, '[', 786, ']', 786, '{', 786, \
'}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map245(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 703, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 654, ')', 655, '-', \
950, '0', 803, ';', 555, '<', 609, '=', 952, '>', 617, \
'\\', 323, '`', 855, '|', 593, '[', 786, ']', 786, '{', \
786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map246(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 704, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
945, ';', 555, '<', 612, '>', 618, '?', 760, '@', 941, \
'\\', 96, '_', 948, '`', 855, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif // INLINE_IMPL3_H

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

84
parser/static/lex_funcs/lex_normal/inline/inline_impl4.h Normal file
View file

@ -0,0 +1,84 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl4.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_IMPL4_H
# define INLINE_IMPL4_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_map247(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 705, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 654, '*', \
640, '-', 636, '0', 943, ';', 555, '<', 609, '=', 952, \
'>', 617, '?', 761, '@', 942, '\\', 156, '_', 947, '`', \
855, '|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map248(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 706, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
804, ';', 554, '<', 610, '>', 617, '\\', 324, '`', 855, \
'e', 866, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map249(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 707, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 602, ')', 655, '*', 637, '-', \
632, '0', 945, ';', 555, '<', 612, '>', 618, '?', 760, \
'@', 941, '\\', 98, '_', 948, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map250(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 708, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, ';', 554, '<', 609, '=', 952, \
'>', 617, '?', 761, '@', 942, '\\', 202, '_', 947, '`', \
855, '|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map251(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 709, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
804, ';', 554, '<', 610, '>', 617, '\\', 325, '`', 855, \
'|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif // INLINE_IMPL4_H

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

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

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

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

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

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

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

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

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

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

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

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

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

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

85
parser/static/lex_funcs/lex_normal/inline/inline_impl5.h Normal file
View file

@ -0,0 +1,85 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl5.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_IMPL5_H
# define INLINE_IMPL5_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_map252(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 710, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
945, ';', 555, '<', 612, '>', 618, '?', 760, '@', 941, \
'\\', 211, '_', 948, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map253(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 711, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, ')', \
655, '*', 640, '-', 636, '0', 943, ';', 555, '<', 609, \
'=', 952, '>', 617, '?', 761, '@', 942, '\\', 158, '_', \
947, '`', 855, '|', 593, '[', 786, ']', 786, '{', 786, \
'}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map254(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 712, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, ')', 655, '-', \
950, '0', 804, ';', 555, '<', 610, '>', 617, '\\', 326, \
'`', 855, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map255(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 713, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
945, ';', 555, '<', 613, '>', 618, '?', 760, '@', 941, \
'\\', 188, '_', 948, '`', 855, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map256(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 714, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, ';', 555, '<', 609, '=', 952, \
'>', 617, '?', 761, '@', 942, '\\', 215, '_', 947, '`', \
855, '|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif // INLINE_IMPL5_H

83
parser/static/lex_funcs/lex_normal/inline/inline_impl6.h Normal file
View file

@ -0,0 +1,83 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl6.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_IMPL6_H
# define INLINE_IMPL6_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_map257(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 715, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
803, ';', 554, '<', 609, '>', 617, '\\', 327, '`', 855, \
'e', 956, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map258(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 716, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
945, ';', 555, '<', 613, '>', 618, '?', 760, '@', 941, \
'\\', 218, '_', 948, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map259(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 717, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, ';', 554, '<', 609, '>', 617, \
'?', 761, '@', 942, '\\', 37, '_', 947, '`', 855, 'e', \
871, '|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map260(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 718, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
803, ';', 554, '<', 609, '>', 617, '\\', 328, '`', 855, \
'|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map261(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 719, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 602, ')', 655, '*', 637, '-', \
632, '0', 945, ';', 555, '<', 613, '>', 618, '?', 760, \
'@', 941, '\\', 190, '_', 948, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif // INLINE_IMPL6_H

85
parser/static/lex_funcs/lex_normal/inline/inline_impl7.h Normal file
View file

@ -0,0 +1,85 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl7.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_IMPL7_H
# define INLINE_IMPL7_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_map262(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 720, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, ';', 554, '<', 610, '>', 617, \
'?', 761, '@', 942, '\\', 222, '_', 947, '`', 855, 'e', \
871, '|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map263(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 721, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
803, ';', 554, '<', 610, '>', 617, '\\', 397, '`', 855, \
'e', 956, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map264(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 722, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 489, '*', 637, '-', 632, '0', \
945, '<', 612, '>', 618, '?', 760, '@', 941, '\\', 106, \
'_', 948, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map265(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 723, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, ';', 554, '<', 609, '>', 617, \
'?', 761, '@', 942, '\\', 43, '_', 947, '`', 855, '|', \
593, '[', 786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map266(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 724, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, ')', 655, '-', \
950, '0', 803, ';', 555, '<', 609, '>', 617, '\\', 331, \
'`', 855, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif // INLINE_IMPL7_H

83
parser/static/lex_funcs/lex_normal/inline/inline_impl8.h Normal file
View file

@ -0,0 +1,83 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl8.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_IMPL8_H
# define INLINE_IMPL8_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_map267(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 725, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 489, '*', 637, '-', 632, '0', \
945, '<', 613, '>', 618, '?', 760, '@', 941, '\\', 193, \
'_', 948, '|', 593};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map268(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 726, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, ')', \
655, '*', 640, '-', 636, '0', 943, ';', 555, '<', 609, \
'>', 617, '?', 761, '@', 942, '\\', 46, '_', 947, '`', \
855, '|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map269(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 727, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
803, ';', 554, '<', 610, '>', 617, '\\', 398, '`', 855, \
'|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map270(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 728, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 489, '*', 637, '-', 632, '0', \
945, '<', 611, '>', 618, '?', 760, '@', 941, '\\', 213, \
'_', 948, '|', 516};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map271(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 729, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, ';', 554, '<', 610, '>', 617, \
'?', 761, '@', 942, '\\', 226, '_', 947, '`', 855, '|', \
593, '[', 786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif // INLINE_IMPL8_H

84
parser/static/lex_funcs/lex_normal/inline/inline_impl9.h Normal file
View file

@ -0,0 +1,84 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* inline_impl9.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_IMPL9_H
# define INLINE_IMPL9_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_map272(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 730, '"', 788, '#', 862, \
'$', 781, '&', 602, '\'', 491, '(', 494, ')', 655, '-', \
950, '0', 803, ';', 555, '<', 610, '>', 617, '\\', 399, \
'`', 855, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map273(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 731, '!', 669, '"', 788, \
'#', 816, '$', 780, '&', 599, '*', 637, '-', 632, '0', \
945, ';', 555, '?', 760, '@', 941, '\\', 128, '_', 948, \
'i', 876};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map274(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 732, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
640, '-', 636, '0', 943, ';', 555, '<', 609, '>', 617, \
'?', 761, '@', 942, '\\', 166, '_', 947, '`', 855, '|', \
593, '[', 786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map275(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 733, '"', 788, '#', 862, \
'$', 781, '&', 489, '\'', 491, '(', 494, '-', 950, '0', \
803, '<', 608, '>', 617, '\\', 333, '`', 855, '|', 593, \
'[', 786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
static inline bool lex_normal_map276(t_lexer *lexer, \
t_lexer_state *s)
{
static uint32_t map[] = {'\n', 734, '!', 672, '"', 788, \
'#', 816, '$', 781, '&', 489, '\'', 491, '(', 654, '*', \
640, '-', 636, '0', 943, '<', 609, '=', 952, '>', 617, \
'?', 761, '@', 942, '\\', 48, '_', 947, '`', 855, '|', \
593, '[', 786, ']', 786, '{', 786, '}', 786};
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
lexer, s));
}
#endif // INLINE_IMPL9_H

993
parser/static/lex_funcs/lex_normal/lex_normal_funcs.h Normal file
View file

@ -0,0 +1,993 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lex_normal_funcs.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
/* Updated: 2024/04/28 18:56:16 by rparodi ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef LEX_NORMAL_FUNCS_H
# define LEX_NORMAL_FUNCS_H
# include "../../types/type_lex_normal.h"
# include "../../headers/symbols.h"
# include "../../headers/external_scanner_symbol_identifiers.h"
# include "../../headers/field_identifiers.h"
# include "../../headers/constants.h"
# include "../../char_set/charset_inline.h"
# include "./inline.h"
# include "../../../parse_types.h"
bool lex_helper_s86(t_lexer *lexer, t_lexer_state *s);
bool lex_helper_s87(t_lexer *lexer, t_lexer_state *s);
bool lex_helper_s519(t_lexer *lexer, t_lexer_state *s);
bool lex_helper_s520(t_lexer *lexer, t_lexer_state *s);
bool lex_helper_s521(t_lexer *lexer, t_lexer_state *s);
bool lex_helper_s522(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s0(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s1(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s2(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s3(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s4(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s5(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s6(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s7(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s8(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s9(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s10(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s11(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s12(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s13(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s14(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s15(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s16(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s17(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s18(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s19(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s20(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s21(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s22(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s23(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s24(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s25(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s26(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s27(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s28(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s29(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s30(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s31(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s32(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s33(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s34(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s35(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s36(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s37(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s38(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s39(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s40(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s41(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s42(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s43(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s44(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s45(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s46(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s47(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s48(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s49(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s50(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s51(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s52(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s53(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s54(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s55(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s56(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s57(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s58(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s59(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s60(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s61(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s62(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s63(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s64(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s65(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s66(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s67(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s68(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s69(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s70(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s71(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s72(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s73(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s74(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s75(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s76(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s77(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s78(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s79(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s80(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s81(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s82(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s83(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s84(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s85(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s86(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s87(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s88(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s89(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s90(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s91(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s92(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s93(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s94(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s95(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s96(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s97(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s98(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s99(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s100(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s101(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s102(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s103(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s104(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s105(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s106(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s107(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s108(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s109(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s110(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s111(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s112(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s113(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s114(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s115(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s116(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s117(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s118(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s119(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s120(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s121(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s122(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s123(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s124(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s125(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s126(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s127(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s128(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s129(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s130(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s131(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s132(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s133(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s134(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s135(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s136(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s137(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s138(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s139(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s140(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s141(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s142(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s143(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s144(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s145(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s146(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s147(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s148(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s149(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s150(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s151(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s152(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s153(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s154(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s155(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s156(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s157(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s158(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s159(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s160(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s161(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s162(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s163(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s164(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s165(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s166(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s167(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s168(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s169(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s170(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s171(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s172(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s173(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s174(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s175(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s176(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s177(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s178(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s179(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s180(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s181(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s182(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s183(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s184(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s185(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s186(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s187(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s188(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s189(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s190(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s191(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s192(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s193(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s194(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s195(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s196(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s197(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s198(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s199(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s200(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s201(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s202(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s203(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s204(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s205(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s206(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s207(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s208(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s209(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s210(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s211(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s212(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s213(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s214(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s215(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s216(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s217(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s218(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s219(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s220(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s221(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s222(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s223(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s224(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s225(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s226(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s227(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s228(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s229(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s230(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s231(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s232(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s233(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s234(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s235(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s236(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s237(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s238(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s239(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s240(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s241(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s242(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s243(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s244(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s245(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s246(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s247(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s248(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s249(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s250(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s251(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s252(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s253(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s254(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s255(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s256(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s257(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s258(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s259(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s260(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s261(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s262(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s263(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s264(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s265(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s266(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s267(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s268(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s269(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s270(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s271(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s272(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s273(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s274(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s275(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s276(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s277(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s278(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s279(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s280(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s281(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s282(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s283(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s284(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s285(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s286(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s287(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s288(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s289(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s290(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s291(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s292(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s293(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s294(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s295(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s296(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s297(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s298(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s299(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s300(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s301(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s302(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s303(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s304(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s305(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s306(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s307(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s308(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s309(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s310(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s311(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s312(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s313(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s314(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s315(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s316(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s317(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s318(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s319(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s320(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s321(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s322(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s323(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s324(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s325(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s326(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s327(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s328(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s329(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s330(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s331(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s332(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s333(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s334(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s335(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s336(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s337(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s338(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s339(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s340(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s341(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s342(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s343(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s344(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s345(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s346(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s347(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s348(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s349(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s350(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s351(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s352(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s353(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s354(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s355(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s356(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s357(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s358(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s359(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s360(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s361(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s362(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s363(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s364(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s365(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s366(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s367(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s368(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s369(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s370(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s371(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s372(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s373(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s374(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s375(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s376(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s377(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s378(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s379(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s380(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s381(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s382(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s383(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s384(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s385(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s386(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s387(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s388(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s389(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s390(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s391(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s392(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s393(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s394(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s395(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s396(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s397(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s398(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s399(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s400(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s401(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s402(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s403(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s404(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s405(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s406(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s407(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s408(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s409(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s410(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s411(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s412(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s413(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s414(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s415(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s416(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s417(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s418(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s419(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s420(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s421(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s422(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s423(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s424(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s425(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s426(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s427(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s428(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s429(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s430(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s431(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s432(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s433(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s434(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s435(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s436(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s437(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s438(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s439(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s440(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s441(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s442(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s443(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s444(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s445(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s446(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s447(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s448(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s449(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s450(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s451(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s452(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s453(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s454(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s455(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s456(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s457(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s458(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s459(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s460(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s461(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s462(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s463(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s464(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s465(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s466(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s467(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s468(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s469(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s470(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s471(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s472(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s473(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s474(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s475(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s476(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s477(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s478(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s479(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s480(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s481(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s482(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s483(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s484(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s485(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s486(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s487(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s488(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s489(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s490(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s491(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s492(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s493(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s494(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s495(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s496(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s497(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s498(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s499(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s500(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s501(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s502(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s503(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s504(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s505(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s506(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s507(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s508(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s509(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s510(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s511(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s512(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s513(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s514(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s515(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s516(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s517(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s518(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s519(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s520(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s521(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s522(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s523(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s524(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s525(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s526(t_lexer *lexer, t_lexer_state *s);
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_s536(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s537(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s538(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s539(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s540(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s541(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s542(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s543(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s544(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s545(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s546(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s547(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s548(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s549(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s550(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s551(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s552(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s553(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s554(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s555(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s556(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s557(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s558(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s559(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s560(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s561(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s562(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s563(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s564(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s565(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s566(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s567(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s568(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s569(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s570(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s571(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s572(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s573(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s574(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s575(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s576(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s577(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s578(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s579(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s580(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s581(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s582(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s583(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s584(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s585(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s586(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s587(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s588(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s589(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s590(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s591(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s592(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s593(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s594(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s595(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s596(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s597(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s598(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s599(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s600(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s601(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s602(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s603(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s604(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s605(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s606(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s607(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s608(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s609(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s610(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s611(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s612(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s613(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s614(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s615(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s616(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s617(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s618(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s619(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s620(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s621(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s622(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s623(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s624(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s625(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s626(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s627(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s628(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s629(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s630(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s631(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s632(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s633(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s634(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s635(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s636(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s637(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s638(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s639(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s640(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s641(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s642(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s643(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s644(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s645(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s646(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s647(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s648(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s649(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s650(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s651(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s652(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s653(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s654(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s655(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s656(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s657(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s658(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s659(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s660(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s661(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s662(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s663(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s664(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s665(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s666(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s667(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s668(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s669(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s670(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s671(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s672(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s673(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s674(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s675(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s676(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s677(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s678(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s679(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s680(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s681(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s682(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s683(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s684(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s685(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s686(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s687(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s688(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s689(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s690(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s691(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s692(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s693(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s694(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s695(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s696(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s697(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s698(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s699(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s700(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s701(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s702(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s703(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s704(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s705(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s706(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s707(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s708(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s709(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s710(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s711(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s712(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s713(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s714(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s715(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s716(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s717(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s718(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s719(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s720(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s721(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s722(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s723(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s724(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s725(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s726(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s727(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s728(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s729(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s730(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s731(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s732(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s733(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s734(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s735(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s736(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s737(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s738(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s739(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s740(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s741(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s742(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s743(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s744(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s745(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s746(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s747(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s748(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s749(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s750(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s751(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s752(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s753(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s754(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s755(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s756(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s757(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s758(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s759(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s760(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s761(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s762(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s763(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s764(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s765(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s766(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s767(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s768(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s769(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s770(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s771(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s772(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s773(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s774(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s775(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s776(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s777(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s778(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s779(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s780(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s781(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s782(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s783(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s784(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s785(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s786(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s787(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s788(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s789(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s790(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s791(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s792(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s793(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s794(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s795(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s796(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s797(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s798(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s799(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s800(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s801(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s802(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s803(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s804(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s805(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s806(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s807(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s808(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s809(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s810(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s811(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s812(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s813(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s814(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s815(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s816(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s817(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s818(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s819(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s820(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s821(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s822(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s823(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s824(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s825(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s826(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s827(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s828(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s829(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s830(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s831(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s832(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s833(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s834(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s835(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s836(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s837(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s838(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s839(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s840(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s841(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s842(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s843(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s844(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s845(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s846(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s847(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s848(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s849(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s850(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s851(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s852(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s853(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s854(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s855(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s856(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s857(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s858(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s859(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s860(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s861(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s862(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s863(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s864(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s865(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s866(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s867(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s868(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s869(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s870(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s871(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s872(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s873(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s874(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s875(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s876(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s877(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s878(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s879(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s880(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s881(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s882(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s883(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s884(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s885(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s886(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s887(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s888(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s889(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s890(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s891(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s892(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s893(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s894(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s895(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s896(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s897(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s898(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s899(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s900(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s901(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s902(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s903(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s904(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s905(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s906(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s907(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s908(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s909(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s910(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s911(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s912(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s913(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s914(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s915(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s916(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s917(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s918(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s919(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s920(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s921(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s922(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s923(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s924(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s925(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s926(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s927(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s928(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s929(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s930(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s931(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s932(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s933(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s934(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s935(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s936(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s937(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s938(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s939(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s940(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s941(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s942(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s943(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s944(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s945(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s946(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s947(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s948(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s949(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s950(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s951(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s952(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s953(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s954(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s955(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s956(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s957(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_s958(t_lexer *lexer, t_lexer_state *s);
bool lex_normal_default(t_lexer *lexer, t_lexer_state *s);
#endif // LEX_NORMAL_FUNCS_H

49
parser/static/lex_funcs/lex_normal/main_func.c Normal file
View file

@ -0,0 +1,49 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* main_func.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"
t_lex_normal_array *create_lex_normal(void);
bool lex_normal_call(t_lexer *lexer, t_lexer_state *s)
{
t_lex_normal_array *t;
t = create_lex_normal();
if (s->state < 959)
{
return (((bool (*)(t_lexer *, t_lexer_state \
*))(t->a[s->state]))(lexer, s));
}
return (lex_normal_default(lexer, s));
}
bool lex_normal_main(t_lexer *lexer, t_state_id state)
{
t_lexer_state s;
s = (t_lexer_state){.result = false, .skip = false, .eof = \
false};
s.state = state;
s.skip = false;
s.lookahead = lexer->lookahead;
s.eof = lexer->eof(lexer);
while (lex_normal_call(lexer, &s))
{
lexer->advance(lexer, s.skip);
s.skip = false;
s.lookahead = lexer->lookahead;
s.eof = lexer->eof(lexer);
}
return (s.result);
}
/* main_func.c */

55
parser/static/lex_funcs/lex_normal/state_0.c Normal file
View file

@ -0,0 +1,55 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_0.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_s0(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(547, lexer, s));
if (lex_normal_map0(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(545, lexer, s));
if (s->lookahead != 0)
return (lex_advance(958, 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(401, 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(417, 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(418, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s4(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(419, lexer, s));
return (lex_end_state(lexer, s));
}

55
parser/static/lex_funcs/lex_normal/state_1.c Normal file
View file

@ -0,0 +1,55 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_1.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_s5(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(6, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s6(t_lexer *lexer, t_lexer_state *s)
{
if (lex_normal_map6(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(6, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(805, lexer, s));
if (s->lookahead != 0)
return (lex_advance(958, 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(403, 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(421, 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(422, lexer, s));
return (lex_end_state(lexer, s));
}

55
parser/static/lex_funcs/lex_normal/state_10.c Normal file
View file

@ -0,0 +1,55 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_10.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_s50(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(920, 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(920, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(50, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(410, lexer, s));
if (s->lookahead != 0)
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s52(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(470, 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_skip(464, 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(922, lexer, s));
return (lex_end_state(lexer, s));
}

56
parser/static/lex_funcs/lex_normal/state_100.c Normal file
View file

@ -0,0 +1,56 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_100.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_s500(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '+')
return (lex_advance(564, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s501(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '+')
return (lex_advance(564, lexer, s));
if (s->lookahead == '=')
return (lex_advance(568, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s502(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '-')
return (lex_advance(566, lexer, s));
if (s->lookahead == '0')
return (lex_advance(809, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(811, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s503(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '.')
return (lex_advance(776, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s504(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '0')
return (lex_advance(809, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(811, lexer, s));
return (lex_end_state(lexer, s));
}

48
parser/static/lex_funcs/lex_normal/state_101.c Normal file
View file

@ -0,0 +1,48 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_101.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_s505(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '<')
return (lex_advance(759, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s506(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '=')
return (lex_advance(605, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s507(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '=')
return (lex_advance(568, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s508(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '>')
return (lex_advance(680, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s509(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == ']')
return (lex_advance(677, lexer, s));
return (lex_end_state(lexer, s));
}

51
parser/static/lex_funcs/lex_normal/state_102.c Normal file
View file

@ -0,0 +1,51 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_102.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_s510(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '`')
return (lex_advance(779, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_advance(510, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s511(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'a')
return (lex_advance(512, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s512(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'c')
return (lex_advance(657, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s513(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 'n')
return (lex_advance(548, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s514(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == 's')
return (lex_advance(511, lexer, s));
return (lex_end_state(lexer, s));
}

67
parser/static/lex_funcs/lex_normal/state_103.c Normal file
View file

@ -0,0 +1,67 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_103.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
/* Updated: 2024/04/28 18:42:09 by rparodi ### ########.fr */
/* */
/* ************************************************************************** */
#include "./lex_normal_funcs.h"
bool lex_normal_s515(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '{')
return (lex_advance(817, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s516(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '|')
return (lex_advance(586, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s517(t_lexer *lexer, t_lexer_state *s)
{
if ((s->lookahead >= '0' && s->lookahead <= '9'))
return (lex_advance(811, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s518(t_lexer *lexer, t_lexer_state *s)
{
if ((s->lookahead != 0 && (s->lookahead > '\t' && \
s->lookahead < '\r')))
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s519(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(547, lexer, s));
if (s->lookahead == '\n')
return (lex_advance(690, lexer, s));
if (s->lookahead == '#')
return (lex_advance(862, lexer, s));
if (s->lookahead == '&')
return (lex_advance(602, lexer, s));
if (s->lookahead == ')')
return (lex_advance(655, lexer, s));
if (s->lookahead == ';')
return (lex_advance(555, lexer, s));
if (lex_helper_s519(lexer, s))
return (true);
if (((s->lookahead >= '[' && s->lookahead <= ']') || \
(s->lookahead >= '{' && s->lookahead <= '}')))
return (lex_advance(786, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(519, lexer, s));
return (lex_end_state(lexer, s));
}

106
parser/static/lex_funcs/lex_normal/state_104.c Normal file
View file

@ -0,0 +1,106 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_104.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
/* Updated: 2024/04/28 18:52:19 by rparodi ### ########.fr */
/* */
/* ************************************************************************** */
#include "./lex_normal_funcs.h"
bool lex_normal_s520(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(547, lexer, s));
if (s->lookahead == '\n')
return (lex_advance(690, lexer, s));
if (s->lookahead == '#')
return (lex_advance(862, lexer, s));
if (s->lookahead == '&')
return (lex_advance(602, lexer, s));
if (s->lookahead == ')')
return (lex_advance(655, lexer, s));
if (s->lookahead == ';')
return (lex_advance(555, lexer, s));
if (lex_helper_s520(lexer, s))
return (true);
if (((s->lookahead >= '[' && s->lookahead <= ']') || \
(s->lookahead >= '{' && s->lookahead <= '}')))
return (lex_advance(786, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(520, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s521(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(547, lexer, s));
if (s->lookahead == '\n')
return (lex_advance(690, lexer, s));
if (s->lookahead == '#')
return (lex_advance(862, lexer, s));
if (s->lookahead == '&')
return (lex_advance(602, lexer, s));
if (s->lookahead == ')')
return (lex_advance(655, lexer, s));
if (s->lookahead == ';')
return (lex_advance(555, lexer, s));
if (lex_helper_s521(lexer, s))
return (true);
if (((s->lookahead >= '[' && s->lookahead <= ']') || \
(s->lookahead >= '{' && s->lookahead <= '}')))
return (lex_advance(786, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(521, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s522(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(547, lexer, s));
if (s->lookahead == '\n')
return (lex_advance(690, lexer, s));
if (s->lookahead == '#')
return (lex_advance(862, lexer, s));
if (s->lookahead == '&')
return (lex_advance(602, lexer, s));
if (s->lookahead == ')')
return (lex_advance(655, lexer, s));
if (s->lookahead == ';')
return (lex_advance(555, lexer, s));
if (lex_helper_s522(lexer, s))
return (true);
if (((s->lookahead >= '[' && s->lookahead <= ']') || \
(s->lookahead >= '{' && s->lookahead <= '}')))
return (lex_advance(786, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(522, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s523(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(547, lexer, s));
if (s->lookahead == '\n')
return (lex_skip(521, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s524(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(547, lexer, s));
if (s->lookahead == '\n')
return (lex_skip(519, lexer, s));
return (lex_end_state(lexer, s));
}

83
parser/static/lex_funcs/lex_normal/state_105.c Normal file
View file

@ -0,0 +1,83 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_105.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_s525(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(547, lexer, s));
if (s->lookahead == '\n')
return (lex_skip(522, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s526(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(547, lexer, s));
if (s->lookahead == '\n')
return (lex_skip(520, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s527(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(547, lexer, s));
if (lex_normal_map527(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(527, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(805, lexer, s));
if (s->lookahead != 0)
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s528(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(547, lexer, s));
if (lex_normal_map528(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(528, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(807, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(873, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*')))
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s529(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(547, lexer, s));
if (lex_normal_map529(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(529, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(879, lexer, s));
return (lex_end_state(lexer, s));
}

100
parser/static/lex_funcs/lex_normal/state_106.c Normal file
View file

@ -0,0 +1,100 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_106.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_s530(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(547, lexer, s));
if (lex_normal_map530(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(530, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(806, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= '_' && s->lookahead <= 'z')))
return (lex_advance(868, lexer, s));
if (s->lookahead != 0)
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s531(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(547, lexer, s));
if (lex_normal_map531(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(531, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(807, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(873, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*')))
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s532(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(547, lexer, s));
if (lex_normal_map532(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(532, lexer, s));
if (((s->lookahead >= '1' && s->lookahead <= '9') || \
(s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(879, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s533(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(547, lexer, s));
if (lex_normal_map533(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(533, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(805, lexer, s));
if (s->lookahead != 0)
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s534(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(547, lexer, s));
if (lex_normal_map534(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(534, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(805, lexer, s));
if (s->lookahead != 0)
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}

104
parser/static/lex_funcs/lex_normal/state_107.c Normal file
View file

@ -0,0 +1,104 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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)
{
if (s->eof)
return (lex_advance(547, lexer, s));
if (lex_normal_map535(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(535, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(807, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(873, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*')))
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s536(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(547, lexer, s));
if (lex_normal_map536(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(536, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(807, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= 'a' && s->lookahead <= 'z')))
return (lex_advance(873, lexer, s));
if ((s->lookahead != 0 && (s->lookahead > '&' && \
s->lookahead < '*')))
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s537(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(547, lexer, s));
if (lex_normal_map537(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(537, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(805, lexer, s));
if (s->lookahead != 0)
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s538(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(547, lexer, s));
if (lex_normal_map538(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(538, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(806, lexer, s));
if (((s->lookahead >= 'A' && s->lookahead <= 'Z') || \
(s->lookahead >= '_' && s->lookahead <= 'z')))
return (lex_advance(868, lexer, s));
if (s->lookahead != 0)
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s539(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(547, lexer, s));
if (lex_normal_map539(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(539, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(805, lexer, s));
if (s->lookahead != 0)
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}

77
parser/static/lex_funcs/lex_normal/state_108.c Normal file
View file

@ -0,0 +1,77 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_108.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_s540(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(547, lexer, s));
if (lex_normal_map540(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(540, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(805, lexer, s));
if (s->lookahead != 0)
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s541(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(547, lexer, s));
if (s->lookahead == '\r')
return (lex_skip(523, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(521, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s542(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(547, lexer, s));
if (s->lookahead == '\r')
return (lex_skip(524, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(519, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s543(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(547, lexer, s));
if (s->lookahead == '\r')
return (lex_skip(525, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(522, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s544(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(547, lexer, s));
if (s->lookahead == '\r')
return (lex_skip(526, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(520, lexer, s));
return (lex_end_state(lexer, s));
}

67
parser/static/lex_funcs/lex_normal/state_109.c Normal file
View file

@ -0,0 +1,67 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_109.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_s545(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(547, lexer, s));
if (lex_normal_map545(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(545, lexer, s));
if (s->lookahead != 0)
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s546(t_lexer *lexer, t_lexer_state *s)
{
if (s->eof)
return (lex_advance(547, lexer, s));
if (lex_normal_map546(lexer, s))
return (true);
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
s->lookahead == ' '))
return (lex_skip(546, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(805, lexer, s));
if (s->lookahead != 0)
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s547(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(ts_builtin_sym_end, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s548(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_in, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s549(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_in, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(518, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 12, \
s->lookahead)))
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}

62
parser/static/lex_funcs/lex_normal/state_11.c Normal file
View file

@ -0,0 +1,62 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_11.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_s55(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(922, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(54, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(412, lexer, s));
if (s->lookahead != 0)
return (lex_advance(958, 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_skip(460, 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(913, 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(913, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(57, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(284, lexer, s));
if (s->lookahead != 0)
return (lex_advance(958, 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(930, lexer, s));
return (lex_end_state(lexer, s));
}

52
parser/static/lex_funcs/lex_normal/state_110.c Normal file
View file

@ -0,0 +1,52 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_110.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_s550(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(879, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s551(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LPAREN_LPAREN, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s552(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_RPAREN_RPAREN, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s553(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_SEMI, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s554(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_SEMI, lexer, s);
if (s->lookahead == '&')
return (lex_advance(664, lexer, s));
if (s->lookahead == ';')
return (lex_advance(663, lexer, s));
return (lex_end_state(lexer, s));
}

55
parser/static/lex_funcs/lex_normal/state_111.c Normal file
View file

@ -0,0 +1,55 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_111.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_s555(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_SEMI, lexer, s);
if (s->lookahead == ';')
return (lex_advance(662, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s556(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_COMMA, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s557(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_COMMA, lexer, s);
if (s->lookahead == ',')
return (lex_advance(850, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(518, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 12, \
s->lookahead)))
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s558(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_COMMA, lexer, s);
if (s->lookahead == ',')
return (lex_advance(849, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s559(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_EQ, lexer, s);
return (lex_end_state(lexer, s));
}

65
parser/static/lex_funcs/lex_normal/state_112.c Normal file
View file

@ -0,0 +1,65 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_112.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_s560(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_EQ, lexer, s);
if (s->lookahead == '=')
return (lex_advance(604, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(518, lexer, s));
if (s->lookahead == '~')
return (lex_advance(679, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 12, \
s->lookahead)))
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s561(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_EQ, lexer, s);
if (s->lookahead == '=')
return (lex_advance(603, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s562(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_EQ, lexer, s);
if (s->lookahead == '=')
return (lex_advance(603, lexer, s));
if (s->lookahead == '~')
return (lex_advance(678, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s563(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_EQ, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(518, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 12, \
s->lookahead)))
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s564(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PLUS_PLUS, lexer, s);
return (lex_end_state(lexer, s));
}

61
parser/static/lex_funcs/lex_normal/state_113.c Normal file
View file

@ -0,0 +1,61 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_113.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_s565(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PLUS_PLUS, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(518, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 12, \
s->lookahead)))
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s566(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_DASH_DASH, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s567(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_DASH_DASH, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(518, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 12, \
s->lookahead)))
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s568(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PLUS_EQ, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s569(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PLUS_EQ, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(518, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 12, \
s->lookahead)))
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}

55
parser/static/lex_funcs/lex_normal/state_114.c Normal file
View file

@ -0,0 +1,55 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_114.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_s570(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_DASH_EQ, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s571(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_DASH_EQ, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(518, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 12, \
s->lookahead)))
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s572(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_STAR_EQ, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s573(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_STAR_EQ, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(518, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 12, \
s->lookahead)))
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s574(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_SLASH_EQ, lexer, s);
return (lex_end_state(lexer, s));
}

61
parser/static/lex_funcs/lex_normal/state_115.c Normal file
View file

@ -0,0 +1,61 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_115.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_s575(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_SLASH_EQ, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(518, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 12, \
s->lookahead)))
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s576(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PERCENT_EQ, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s577(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PERCENT_EQ, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(518, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 12, \
s->lookahead)))
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s578(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_STAR_STAR_EQ, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s579(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_STAR_STAR_EQ, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(518, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 12, \
s->lookahead)))
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}

49
parser/static/lex_funcs/lex_normal/state_116.c Normal file
View file

@ -0,0 +1,49 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_116.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_s580(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LT_LT_EQ, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s581(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_GT_GT_EQ, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s582(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_AMP_EQ, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s583(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_CARET_EQ, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s584(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_CARET_EQ, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(518, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 12, \
s->lookahead)))
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}

43
parser/static/lex_funcs/lex_normal/state_117.c Normal file
View file

@ -0,0 +1,43 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_117.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_s585(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PIPE_EQ, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s586(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PIPE_PIPE, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s587(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_DASHo, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s588(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_AMP_AMP, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s589(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_DASHa, lexer, s);
return (lex_end_state(lexer, s));
}

59
parser/static/lex_funcs/lex_normal/state_118.c Normal file
View file

@ -0,0 +1,59 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_118.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_s590(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PIPE, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s591(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PIPE, lexer, s);
if (s->lookahead == '&')
return (lex_advance(668, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s592(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PIPE, lexer, s);
if (s->lookahead == '&')
return (lex_advance(668, lexer, s));
if (s->lookahead == '=')
return (lex_advance(585, lexer, s));
if (s->lookahead == '|')
return (lex_advance(586, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s593(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PIPE, lexer, s);
if (s->lookahead == '&')
return (lex_advance(668, lexer, s));
if (s->lookahead == '|')
return (lex_advance(586, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s594(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PIPE, lexer, s);
if (s->lookahead == '=')
return (lex_advance(585, lexer, s));
if (s->lookahead == '|')
return (lex_advance(586, lexer, s));
return (lex_end_state(lexer, s));
}

65
parser/static/lex_funcs/lex_normal/state_119.c Normal file
View file

@ -0,0 +1,65 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_119.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_s595(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_CARET, lexer, s);
if (s->lookahead == '=')
return (lex_advance(584, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(518, lexer, s));
if (s->lookahead == '^')
return (lex_advance(852, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 12, \
s->lookahead)))
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s596(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_CARET, lexer, s);
if (s->lookahead == '=')
return (lex_advance(584, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(518, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 12, \
s->lookahead)))
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s597(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_CARET, lexer, s);
if (s->lookahead == '=')
return (lex_advance(583, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s598(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_CARET, lexer, s);
if (s->lookahead == '^')
return (lex_advance(851, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s599(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_AMP, lexer, s);
return (lex_end_state(lexer, s));
}

65
parser/static/lex_funcs/lex_normal/state_12.c Normal file
View file

@ -0,0 +1,65 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_12.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_s60(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(930, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(59, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(430, 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_advance(923, 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_advance(923, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(61, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(413, lexer, s));
if (s->lookahead != 0)
return (lex_advance(958, 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(929, 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(929, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(63, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(429, lexer, s));
return (lex_end_state(lexer, s));
}

63
parser/static/lex_funcs/lex_normal/state_120.c Normal file
View file

@ -0,0 +1,63 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_120.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_s600(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_AMP, lexer, s);
if (s->lookahead == '&')
return (lex_advance(588, lexer, s));
if (s->lookahead == '=')
return (lex_advance(582, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s601(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_AMP, lexer, s);
if (s->lookahead == '&')
return (lex_advance(588, lexer, s));
if (s->lookahead == '=')
return (lex_advance(582, lexer, s));
if (s->lookahead == '>')
return (lex_advance(680, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s602(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_AMP, lexer, s);
if (s->lookahead == '&')
return (lex_advance(588, lexer, s));
if (s->lookahead == '>')
return (lex_advance(680, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s603(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_EQ_EQ, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s604(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_EQ_EQ, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(518, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 12, \
s->lookahead)))
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}

69
parser/static/lex_funcs/lex_normal/state_121.c Normal file
View file

@ -0,0 +1,69 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_121.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_s605(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_BANG_EQ, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s606(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_BANG_EQ, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(518, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 12, \
s->lookahead)))
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s607(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LT, lexer, s);
if (s->lookahead == '&')
return (lex_advance(682, lexer, s));
if (s->lookahead == '(')
return (lex_advance(858, lexer, s));
if (s->lookahead == '<')
return (lex_advance(625, lexer, s));
if (s->lookahead == '=')
return (lex_advance(621, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s608(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LT, lexer, s);
if (s->lookahead == '&')
return (lex_advance(682, lexer, s));
if (s->lookahead == '(')
return (lex_advance(858, lexer, s));
if (s->lookahead == '<')
return (lex_advance(505, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s609(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LT, lexer, s);
if (s->lookahead == '&')
return (lex_advance(682, lexer, s));
if (s->lookahead == '(')
return (lex_advance(858, lexer, s));
if (s->lookahead == '<')
return (lex_advance(624, lexer, s));
return (lex_end_state(lexer, s));
}

67
parser/static/lex_funcs/lex_normal/state_122.c Normal file
View file

@ -0,0 +1,67 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_122.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_s610(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LT, lexer, s);
if (s->lookahead == '&')
return (lex_advance(682, lexer, s));
if (s->lookahead == '(')
return (lex_advance(858, lexer, s));
if (s->lookahead == '<')
return (lex_advance(623, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s611(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LT, lexer, s);
if (s->lookahead == '&')
return (lex_advance(682, lexer, s));
if (s->lookahead == '<')
return (lex_advance(505, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s612(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LT, lexer, s);
if (s->lookahead == '&')
return (lex_advance(682, lexer, s));
if (s->lookahead == '<')
return (lex_advance(624, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s613(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LT, lexer, s);
if (s->lookahead == '&')
return (lex_advance(682, lexer, s));
if (s->lookahead == '<')
return (lex_advance(623, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s614(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LT, lexer, s);
if (s->lookahead == '(')
return (lex_advance(858, lexer, s));
if (s->lookahead == '<')
return (lex_advance(626, lexer, s));
if (s->lookahead == '=')
return (lex_advance(621, lexer, s));
return (lex_end_state(lexer, s));
}

77
parser/static/lex_funcs/lex_normal/state_123.c Normal file
View file

@ -0,0 +1,77 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_123.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_s615(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LT, lexer, s);
if (s->lookahead == '<')
return (lex_advance(626, lexer, s));
if (s->lookahead == '=')
return (lex_advance(621, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s616(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_GT, lexer, s);
if (s->lookahead == '&')
return (lex_advance(683, lexer, s));
if (s->lookahead == '(')
return (lex_advance(859, lexer, s));
if (s->lookahead == '=')
return (lex_advance(622, lexer, s));
if (s->lookahead == '>')
return (lex_advance(628, lexer, s));
if (s->lookahead == '|')
return (lex_advance(684, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s617(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_GT, lexer, s);
if (s->lookahead == '&')
return (lex_advance(683, lexer, s));
if (s->lookahead == '(')
return (lex_advance(859, lexer, s));
if (s->lookahead == '>')
return (lex_advance(627, lexer, s));
if (s->lookahead == '|')
return (lex_advance(684, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s618(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_GT, lexer, s);
if (s->lookahead == '&')
return (lex_advance(683, lexer, s));
if (s->lookahead == '>')
return (lex_advance(627, lexer, s));
if (s->lookahead == '|')
return (lex_advance(684, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s619(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_GT, lexer, s);
if (s->lookahead == '(')
return (lex_advance(859, lexer, s));
if (s->lookahead == '=')
return (lex_advance(622, lexer, s));
if (s->lookahead == '>')
return (lex_advance(628, lexer, s));
return (lex_end_state(lexer, s));
}

53
parser/static/lex_funcs/lex_normal/state_124.c Normal file
View file

@ -0,0 +1,53 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_124.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_s620(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_GT, lexer, s);
if (s->lookahead == '=')
return (lex_advance(622, lexer, s));
if (s->lookahead == '>')
return (lex_advance(628, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s621(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LT_EQ, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s622(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_GT_EQ, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s623(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LT_LT, lexer, s);
if (s->lookahead == '-')
return (lex_advance(687, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s624(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LT_LT, lexer, s);
if (s->lookahead == '-')
return (lex_advance(687, lexer, s));
if (s->lookahead == '<')
return (lex_advance(759, lexer, s));
return (lex_end_state(lexer, s));
}

53
parser/static/lex_funcs/lex_normal/state_125.c Normal file
View file

@ -0,0 +1,53 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_125.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_s625(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LT_LT, lexer, s);
if (s->lookahead == '-')
return (lex_advance(687, lexer, s));
if (s->lookahead == '<')
return (lex_advance(759, lexer, s));
if (s->lookahead == '=')
return (lex_advance(580, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s626(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LT_LT, lexer, s);
if (s->lookahead == '=')
return (lex_advance(580, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s627(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_GT_GT, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s628(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_GT_GT, lexer, s);
if (s->lookahead == '=')
return (lex_advance(581, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s629(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PLUS, lexer, s);
return (lex_end_state(lexer, s));
}

75
parser/static/lex_funcs/lex_normal/state_126.c Normal file
View file

@ -0,0 +1,75 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_126.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_s630(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PLUS, lexer, s);
if (s->lookahead == '+')
return (lex_advance(565, lexer, s));
if (s->lookahead == '=')
return (lex_advance(569, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(518, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 12, \
s->lookahead)))
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s631(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PLUS, lexer, s);
if (s->lookahead == '+')
return (lex_advance(564, lexer, s));
if (s->lookahead == '=')
return (lex_advance(568, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s632(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_DASH, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s633(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_DASH, lexer, s);
if (s->lookahead == '-')
return (lex_advance(567, lexer, s));
if (s->lookahead == '0')
return (lex_advance(803, lexer, s));
if (s->lookahead == '=')
return (lex_advance(571, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(518, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(805, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 12, \
s->lookahead)))
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s634(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_DASH, lexer, s);
if (s->lookahead == '-')
return (lex_advance(566, lexer, s));
if (s->lookahead == '=')
return (lex_advance(570, lexer, s));
return (lex_end_state(lexer, s));
}

75
parser/static/lex_funcs/lex_normal/state_127.c Normal file
View file

@ -0,0 +1,75 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_127.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_s635(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_DASH, lexer, s);
if (s->lookahead == '-')
return (lex_advance(566, lexer, s));
if (s->lookahead == '=')
return (lex_advance(570, lexer, s));
if (s->lookahead == 'a')
return (lex_advance(589, lexer, s));
if (s->lookahead == 'o')
return (lex_advance(587, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s636(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_DASH, lexer, s);
if (s->lookahead == '0')
return (lex_advance(803, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(518, lexer, s));
if ((s->lookahead >= '1' && s->lookahead <= '9'))
return (lex_advance(805, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 12, \
s->lookahead)))
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s637(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_STAR, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s638(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_STAR, lexer, s);
if (s->lookahead == '*')
return (lex_advance(651, lexer, s));
if (s->lookahead == '=')
return (lex_advance(573, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(518, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 12, \
s->lookahead)))
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s639(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_STAR, lexer, s);
if (s->lookahead == '*')
return (lex_advance(652, lexer, s));
if (s->lookahead == '=')
return (lex_advance(572, lexer, s));
return (lex_end_state(lexer, s));
}

76
parser/static/lex_funcs/lex_normal/state_128.c Normal file
View file

@ -0,0 +1,76 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_128.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_s640(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_STAR, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(518, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 12, \
s->lookahead)))
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s641(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_SLASH, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s642(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_SLASH, lexer, s);
if (s->lookahead == '#')
return (lex_advance(846, lexer, s));
if (s->lookahead == '%')
return (lex_advance(848, lexer, s));
if (s->lookahead == '/')
return (lex_advance(844, lexer, s));
if (s->lookahead == '=')
return (lex_advance(575, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(518, lexer, s));
if ((!s->eof && set_contains(sym_word_character_set_1(), \
11, s->lookahead)))
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s643(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_SLASH, lexer, s);
if (s->lookahead == '#')
return (lex_advance(845, lexer, s));
if (s->lookahead == '%')
return (lex_advance(847, lexer, s));
if (s->lookahead == '/')
return (lex_advance(843, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s644(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_SLASH, lexer, s);
if (s->lookahead == '=')
return (lex_advance(575, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(518, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 12, \
s->lookahead)))
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}

65
parser/static/lex_funcs/lex_normal/state_129.c Normal file
View file

@ -0,0 +1,65 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_129.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_s645(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_SLASH, lexer, s);
if (s->lookahead == '=')
return (lex_advance(574, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s646(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PERCENT, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s647(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PERCENT, lexer, s);
if (s->lookahead == '%')
return (lex_advance(841, lexer, s));
if (s->lookahead == '=')
return (lex_advance(577, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(518, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 12, \
s->lookahead)))
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s648(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PERCENT, lexer, s);
if (s->lookahead == '%')
return (lex_advance(840, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s649(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PERCENT, lexer, s);
if (s->lookahead == '=')
return (lex_advance(577, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(518, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 12, \
s->lookahead)))
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}

58
parser/static/lex_funcs/lex_normal/state_13.c Normal file
View file

@ -0,0 +1,58 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_13.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_s65(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_skip(466, 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(927, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s67(t_lexer *lexer, t_lexer_state *s)
{
if (s->lookahead == '\n')
return (lex_advance(927, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(66, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(427, 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(932, 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(932, lexer, s));
if (s->lookahead == '\r')
return (lex_advance(68, lexer, s));
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
s->lookahead == ' '))
return (lex_skip(432, lexer, s));
return (lex_end_state(lexer, s));
}

57
parser/static/lex_funcs/lex_normal/state_130.c Normal file
View file

@ -0,0 +1,57 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_130.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_s650(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_PERCENT, lexer, s);
if (s->lookahead == '=')
return (lex_advance(576, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s651(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_STAR_STAR, lexer, s);
if (s->lookahead == '=')
return (lex_advance(579, lexer, s));
if (s->lookahead == '\\')
return (lex_advance(518, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 12, \
s->lookahead)))
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s652(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_STAR_STAR, lexer, s);
if (s->lookahead == '=')
return (lex_advance(578, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s653(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LPAREN, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s654(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_LPAREN, lexer, s);
if (s->lookahead == '(')
return (lex_advance(551, lexer, s));
return (lex_end_state(lexer, s));
}

65
parser/static/lex_funcs/lex_normal/state_131.c Normal file
View file

@ -0,0 +1,65 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_131.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_s655(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_RPAREN, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s656(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(aux_sym__c_word_token1, 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(656, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s657(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_esac, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s658(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_esac, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(518, 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(868, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 12, \
s->lookahead)))
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s659(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_esac, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(518, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 12, \
s->lookahead)))
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}

61
parser/static/lex_funcs/lex_normal/state_132.c Normal file
View file

@ -0,0 +1,61 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_132.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_s660(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_esac, lexer, s);
if (s->lookahead == '\\')
return (lex_advance(17, 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(873, lexer, s));
if ((!s->eof && \
set_contains(sym__comment_word_character_set_1(), 12, \
s->lookahead)))
return (lex_advance(958, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s661(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(879, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s662(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_SEMI_SEMI, lexer, s);
return (lex_end_state(lexer, s));
}
bool lex_normal_s663(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_SEMI_SEMI, lexer, s);
if (s->lookahead == '&')
return (lex_advance(665, lexer, s));
return (lex_end_state(lexer, s));
}
bool lex_normal_s664(t_lexer *lexer, t_lexer_state *s)
{
lex_accept_token(anon_sym_SEMI_AMP, lexer, s);
return (lex_end_state(lexer, s));
}

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