Updated syntax with a simpler one
This commit is contained in:
Maieul BOYER
parent
38fa2d2e84
commit
aeb576024f
4465 changed files with 195554 additions and 526060 deletions
|
|
@ -46,28 +46,5 @@ 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
|
||||
#endif // LEX_NORMAL_ARRAY_H
|
||||
|
|
|
|||
|
|
@ -125,21 +125,5 @@ void lex_normal_array_24(t_lex_normal_array *v)
|
|||
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 */
|
||||
|
|
|
|||
|
|
@ -1,145 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* 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 */
|
||||
|
|
@ -1,145 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* 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 */
|
||||
|
|
@ -1,145 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* 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 */
|
||||
|
|
@ -1,145 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* 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 */
|
||||
|
|
@ -1,92 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* 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 */
|
||||
|
|
@ -38,32 +38,5 @@
|
|||
# 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
|
||||
#endif // INLINE_H
|
||||
|
|
|
|||
|
|
@ -22,13 +22,13 @@
|
|||
static inline bool lex_normal_map0(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 820, '"', 788, '#', 825, \
|
||||
'$', 781, '%', 647, '&', 601, '\'', 491, '(', 654, ')', \
|
||||
655, '*', 824, '+', 770, ',', 557, '-', 768, '.', 949, \
|
||||
'/', 642, '0', 944, ':', 763, ';', 554, '<', 607, '=', \
|
||||
827, '>', 616, '?', 837, '@', 822, '[', 674, '\\', 301, \
|
||||
']', 675, '^', 595, '_', 946, '`', 856, 'e', 956, 'i', \
|
||||
955, '{', 666, '|', 592, '}', 778, '~', 772};
|
||||
static uint32_t map[] = {'!', 248, '"', 373, '#', 396, \
|
||||
'$', 370, '%', 351, '&', 335, '\'', 201, '(', 232, ')', \
|
||||
237, '*', 346, '+', 363, ',', 311, '-', 361, '.', 475, \
|
||||
'/', 349, '0', 470, ':', 357, ';', 483, '<', 253, '=', \
|
||||
404, '>', 256, '?', 408, '@', 468, '[', 372, '\\', 133, \
|
||||
']', 485, '^', 331, '_', 472, '`', 417, 'e', 480, 'i', \
|
||||
479, '{', 242, '|', 234, '}', 316, '~', 365};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
|
|
@ -37,50 +37,52 @@ static inline bool lex_normal_map0(t_lexer *lexer, \
|
|||
static inline bool lex_normal_map6(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 688, '!', 670, '"', 788, \
|
||||
'#', 862, '$', 781, '%', 649, '&', 601, '\'', 491, '(', \
|
||||
654, ')', 655, '*', 638, '+', 771, '-', 769, '/', 644, \
|
||||
'0', 803, ';', 555, '<', 607, '=', 560, '>', 616, '?', \
|
||||
761, '\\', 307, '^', 596, '`', 856, '|', 592, '~', 772, \
|
||||
'[', 786, ']', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'\n', 272, '"', 373, '#', 421, \
|
||||
'$', 370, '&', 336, '\'', 201, '(', 232, '-', 476, '0', \
|
||||
385, ';', 483, '<', 254, '>', 257, '\\', 139, '`', 416, \
|
||||
'e', 480, '|', 235, '[', 372, ']', 372, '{', 372, '}', \
|
||||
372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map12(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map80(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 689, '!', 670, '"', 788, \
|
||||
'#', 816, '$', 781, '%', 649, '&', 601, '\'', 491, '(', \
|
||||
654, ')', 655, '*', 638, '+', 630, '-', 633, '/', 644, \
|
||||
'0', 943, ';', 555, '<', 607, '=', 560, '>', 616, '?', \
|
||||
761, '@', 942, '\\', 14, '^', 596, '_', 947, '`', 855, \
|
||||
'|', 592, '[', 786, ']', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'\n', 274, '!', 248, '"', 373, \
|
||||
'#', 396, '$', 370, '&', 336, '\'', 201, '(', 232, '*', \
|
||||
348, '-', 344, '0', 469, ';', 483, '<', 254, '>', 257, \
|
||||
'?', 355, '@', 468, '\\', 9, '_', 473, '`', 416, 'e', 430, \
|
||||
'|', 235, '[', 372, ']', 372, '{', 372, '}', 372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map83(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map99(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 690, '!', 506, '#', 862, \
|
||||
'%', 650, '&', 600, '*', 639, '+', 631, ',', 556, '-', \
|
||||
635, '/', 645, ';', 553, '<', 615, '=', 561, '>', 620};
|
||||
static uint32_t map[] = {'\n', 275, '!', 248, '"', 373, \
|
||||
'#', 396, '$', 370, '&', 336, '\'', 201, '(', 232, '*', \
|
||||
348, '-', 344, '0', 469, ';', 483, '<', 254, '>', 257, \
|
||||
'?', 355, '@', 468, '\\', 14, '_', 473, '`', 416, '|', \
|
||||
235, '[', 372, ']', 372, '{', 372, '}', 372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map84(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map100(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 690, '"', 788, '#', 862, \
|
||||
'$', 785, '&', 599, '(', 653, '+', 500, ',', 556, '-', \
|
||||
502, '0', 809, ';', 553};
|
||||
static uint32_t map[] = {'\n', 276, '!', 248, '"', 373, \
|
||||
'#', 396, '$', 370, '&', 336, '\'', 201, '*', 348, '-', \
|
||||
344, '0', 469, ';', 483, '<', 254, '>', 257, '?', 355, \
|
||||
'@', 468, '\\', 16, '_', 473, '`', 416, 'e', 430, '|', \
|
||||
235, '[', 372, ']', 372, '{', 372, '}', 372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
#endif // INLINE_IMPL0_H
|
||||
|
|
|
|||
|
|
@ -19,68 +19,68 @@
|
|||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map85(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map101(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 690, '#', 862, '$', 783, \
|
||||
'&', 489, '(', 654, '-', 504, '0', 808, ':', 762, '<', \
|
||||
611, '>', 618};
|
||||
static uint32_t map[] = {'\n', 277, '!', 248, '"', 373, \
|
||||
'#', 396, '$', 370, '&', 336, '\'', 201, '(', 232, ')', \
|
||||
237, '*', 348, '-', 344, '0', 469, ';', 484, '<', 254, \
|
||||
'>', 257, '?', 355, '@', 468, '\\', 22, '_', 473, '`', \
|
||||
416, '|', 235, '[', 372, ']', 372, '{', 372, '}', 372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map146(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map102(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 691, '!', 951, '"', 788, \
|
||||
'#', 862, '$', 781, '%', 649, '&', 601, '\'', 491, '(', \
|
||||
654, ')', 655, '*', 638, '+', 630, '-', 633, '/', 644, \
|
||||
'0', 803, ';', 555, '<', 607, '=', 560, '>', 616, '?', \
|
||||
761, '\\', 316, '^', 596, '`', 856, '|', 592, '[', 786, \
|
||||
']', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'\n', 278, '!', 248, '"', 373, \
|
||||
'#', 396, '$', 370, '&', 336, '\'', 201, '(', 232, '*', \
|
||||
348, '-', 344, '0', 469, ';', 484, '<', 254, '>', 257, \
|
||||
'?', 355, '@', 468, '\\', 83, '_', 473, '`', 416, '|', \
|
||||
235, '[', 372, ']', 372, '{', 372, '}', 372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map200(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map103(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 692, '!', 669, '"', 788, \
|
||||
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
|
||||
945, ';', 554, '<', 612, '>', 618, '?', 760, '@', 941, \
|
||||
'\\', 81, '_', 948, 'e', 877, '|', 593};
|
||||
static uint32_t map[] = {'\n', 279, '!', 248, '"', 373, \
|
||||
'#', 396, '$', 370, '&', 336, '\'', 201, '*', 348, '-', \
|
||||
344, '0', 469, ';', 483, '<', 254, '>', 257, '?', 355, \
|
||||
'@', 468, '\\', 24, '_', 473, '`', 416, '|', 235, '[', \
|
||||
372, ']', 372, '{', 372, '}', 372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map219(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map104(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 693, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 654, '*', \
|
||||
640, '-', 636, '0', 943, ';', 554, '<', 609, '=', 952, \
|
||||
'>', 617, '?', 761, '@', 942, '\\', 27, '_', 947, '`', \
|
||||
855, 'e', 871, '|', 593, '[', 786, ']', 786, '{', 786, \
|
||||
'}', 786};
|
||||
static uint32_t map[] = {'\n', 280, '!', 248, '"', 373, \
|
||||
'#', 396, '$', 370, '&', 336, '\'', 201, ')', 237, '*', \
|
||||
348, '-', 344, '0', 469, ';', 484, '<', 254, '>', 257, \
|
||||
'?', 355, '@', 468, '\\', 26, '_', 473, '`', 416, '|', \
|
||||
235, '[', 372, ']', 372, '{', 372, '}', 372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map236(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map105(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 694, '!', 951, '"', 788, \
|
||||
'#', 862, '$', 781, '%', 649, '&', 601, '\'', 491, '(', \
|
||||
654, ')', 655, '*', 638, '+', 630, '-', 633, '/', 644, \
|
||||
'0', 803, ';', 555, '<', 607, '=', 560, '>', 616, '?', \
|
||||
761, '\\', 317, '^', 596, '`', 855, '|', 592, '[', 786, \
|
||||
']', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'\n', 281, '!', 248, '"', 373, \
|
||||
'#', 396, '$', 370, '&', 336, '\'', 201, '*', 348, '-', \
|
||||
344, '0', 469, ';', 484, '<', 254, '>', 257, '?', 355, \
|
||||
'@', 468, '\\', 89, '_', 473, '`', 416, '|', 235, '[', \
|
||||
372, ']', 372, '{', 372, '}', 372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
#endif // INLINE_IMPL1_H
|
||||
|
|
|
|||
|
|
@ -19,68 +19,61 @@
|
|||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map277(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map183(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 735, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 602, '\'', 491, '(', 654, '-', 950, '0', \
|
||||
803, ';', 554, '<', 609, '=', 952, '>', 617, '\\', 335, \
|
||||
'`', 856, 'e', 956, '|', 593, '[', 786, ']', 786, '{', \
|
||||
786, '}', 786};
|
||||
static uint32_t map[] = {'!', 247, '#', 396, '$', 369, \
|
||||
'*', 345, '-', 342, '0', 471, '?', 354, '@', 467, '\\', \
|
||||
75, '_', 474};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map278(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map184(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 736, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, ')', \
|
||||
655, '*', 640, '-', 636, '0', 943, ';', 555, '<', 610, \
|
||||
'>', 617, '?', 761, '@', 942, '\\', 228, '_', 947, '`', \
|
||||
855, '|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'!', 205, '#', 421, '$', 371, \
|
||||
'%', 353, '&', 334, ')', 202, '*', 347, '+', 341, ',', \
|
||||
310, '-', 343, '.', 204, '/', 350, ':', 356, ';', 200, \
|
||||
'<', 255, '=', 250, '>', 258, '?', 354};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map279(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map185(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 737, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 602, '\'', 491, '(', 654, '-', 950, '0', \
|
||||
803, ';', 554, '<', 609, '=', 952, '>', 617, '\\', 337, \
|
||||
'`', 856, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
|
||||
786};
|
||||
static uint32_t map[] = {'!', 205, '#', 421, '$', 371, \
|
||||
'%', 353, '&', 334, ')', 202, '*', 347, '+', 341, ',', \
|
||||
310, '-', 343, '/', 350, ':', 356, ';', 200, '<', 255, \
|
||||
'=', 250, '>', 258, '?', 354};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map280(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map186(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 738, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
|
||||
640, '-', 636, '0', 943, ';', 555, '<', 610, '>', 617, \
|
||||
'?', 761, '@', 942, '\\', 207, '_', 947, '`', 855, '|', \
|
||||
593, '[', 786, ']', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'!', 205, '#', 421, '%', 353, \
|
||||
'&', 334, ')', 237, '*', 347, '+', 341, '-', 343, '/', \
|
||||
350, '<', 255, '=', 250, '>', 258, '?', 354};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map281(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map187(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 739, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 602, '\'', 491, '(', 654, ')', 655, '-', \
|
||||
950, '0', 803, ';', 555, '<', 609, '=', 952, '>', 617, \
|
||||
'\\', 339, '`', 856, '|', 593, '[', 786, ']', 786, '{', \
|
||||
786, '}', 786};
|
||||
static uint32_t map[] = {'"', 373, '#', 421, '$', 370, \
|
||||
'&', 199, '\'', 201, '(', 232, '-', 476, '0', 385, '<', \
|
||||
254, '>', 257, '\\', 145, '`', 416, '|', 235, '[', 372, \
|
||||
']', 372, '{', 372, '}', 372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
#endif // INLINE_IMPL10_H
|
||||
|
|
|
|||
|
|
@ -19,68 +19,62 @@
|
|||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map282(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map188(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 740, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 489, '\'', 491, '(', 494, '*', \
|
||||
640, '-', 636, '0', 943, '<', 609, '=', 952, '>', 617, \
|
||||
'?', 761, '@', 942, '\\', 168, '_', 947, '`', 855, '|', \
|
||||
593, '[', 786, ']', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'"', 373, '#', 421, '$', 370, \
|
||||
'&', 199, '\'', 201, '(', 232, '-', 476, '0', 385, '<', \
|
||||
254, '>', 257, '\\', 153, '`', 417, '|', 235, '[', 372, \
|
||||
']', 372, '{', 372, '}', 372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map283(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map189(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 741, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
|
||||
804, ';', 554, '<', 610, '>', 617, '\\', 341, '`', 856, \
|
||||
'e', 866, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
|
||||
786};
|
||||
static uint32_t map[] = {'"', 373, '#', 421, '$', 370, \
|
||||
'&', 199, '\'', 201, '-', 476, '0', 386, '<', 254, '>', \
|
||||
257, '\\', 146, '`', 416, '|', 235, '[', 372, ']', 372, \
|
||||
'{', 372, '}', 372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map284(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map190(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 742, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 489, '\'', 491, '(', 494, '*', \
|
||||
640, '-', 636, '0', 943, '<', 609, '>', 617, '?', 761, \
|
||||
'@', 942, '\\', 58, '_', 947, '`', 855, '|', 593, '[', \
|
||||
786, ']', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'"', 373, '#', 421, '$', 370, \
|
||||
'&', 199, '\'', 201, '-', 476, '0', 386, '<', 254, '>', \
|
||||
257, '\\', 154, '`', 417, '|', 235, '[', 372, ']', 372, \
|
||||
'{', 372, '}', 372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map285(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map191(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 743, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
|
||||
803, ';', 554, '<', 609, '>', 617, '\\', 343, '`', 856, \
|
||||
'e', 956, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
|
||||
786};
|
||||
static uint32_t map[] = {'"', 373, '#', 421, '$', 370, \
|
||||
'\'', 201, '(', 232, ')', 237, '-', 476, '0', 385, '\\', \
|
||||
158, '`', 416, 'e', 480, '|', 233, '[', 372, ']', 372, \
|
||||
'{', 372, '}', 372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map286(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map192(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 744, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 489, '\'', 491, '(', 494, '*', \
|
||||
640, '-', 636, '0', 943, '<', 610, '>', 617, '?', 761, \
|
||||
'@', 942, '\\', 233, '_', 947, '`', 855, '|', 593, '[', \
|
||||
786, ']', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'"', 373, '#', 421, '$', 371, \
|
||||
'\'', 201, '(', 232, '\\', 164, '`', 416, '{', 242, '}', \
|
||||
398};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
#endif // INLINE_IMPL11_H
|
||||
|
|
|
|||
|
|
@ -19,66 +19,64 @@
|
|||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map287(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map194(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 745, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
|
||||
804, ';', 554, '<', 610, '>', 617, '\\', 344, '`', 856, \
|
||||
'|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'"', 373, '#', 422, '$', 370, \
|
||||
'\'', 201, '-', 476, '0', 385, '\\', 162, '`', 416, '[', \
|
||||
372, ']', 372, '{', 372, '}', 372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map288(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map214(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 746, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 489, '\'', 491, '(', 494, '*', \
|
||||
640, '-', 636, '0', 943, '<', 608, '>', 617, '?', 761, \
|
||||
'@', 942, '\\', 176, '_', 947, '`', 855, '|', 516, '[', \
|
||||
786, ']', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'\n', 278, '!', 248, '"', 373, \
|
||||
'#', 396, '$', 370, '&', 336, '\'', 201, '(', 232, '*', \
|
||||
348, '-', 344, '0', 469, ';', 484, '<', 254, '>', 257, \
|
||||
'?', 355, '@', 468, '\\', 83, '_', 473, '`', 416, '|', \
|
||||
235, '[', 372, ']', 372, '{', 372, '}', 372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map289(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map215(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 747, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
|
||||
803, ';', 554, '<', 609, '>', 617, '\\', 346, '`', 856, \
|
||||
'|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'\n', 281, '!', 248, '"', 373, \
|
||||
'#', 396, '$', 370, '&', 336, '\'', 201, '*', 348, '-', \
|
||||
344, '0', 469, ';', 484, '<', 254, '>', 257, '?', 355, \
|
||||
'@', 468, '\\', 89, '_', 473, '`', 416, '|', 235, '[', \
|
||||
372, ']', 372, '{', 372, '}', 372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map290(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map216(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 748, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 599, '\'', 491, '(', 494, '*', \
|
||||
640, '-', 636, '0', 943, ';', 555, '<', 495, '>', 496, \
|
||||
'?', 761, '@', 942, '\\', 100, '_', 947, '`', 855, '[', \
|
||||
786, ']', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'\n', 288, '!', 247, '#', 396, \
|
||||
'$', 369, '&', 336, '*', 345, '-', 342, '0', 471, ';', \
|
||||
484, '<', 254, '>', 257, '?', 354, '@', 467, '\\', 95, \
|
||||
'_', 474, '|', 235};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map291(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map217(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 749, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
|
||||
803, ';', 554, '<', 610, '>', 617, '\\', 347, '`', 856, \
|
||||
'e', 956, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
|
||||
786};
|
||||
static uint32_t map[] = {'\n', 298, '"', 373, '#', 421, \
|
||||
'$', 370, '&', 336, '\'', 201, ')', 237, '-', 476, '0', \
|
||||
386, ';', 484, '<', 254, '>', 257, '\\', 143, '`', 416, \
|
||||
'|', 235, '[', 372, ']', 372, '{', 372, '}', 372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
#endif // INLINE_IMPL12_H
|
||||
|
|
|
|||
|
|
@ -19,67 +19,69 @@
|
|||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map292(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map218(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 750, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '\'', 491, '(', 494, '*', 640, '-', \
|
||||
636, '0', 943, '<', 495, '>', 496, '?', 761, '@', 942, \
|
||||
'\\', 112, '_', 947, '`', 855, '[', 786, ']', 786, '{', \
|
||||
786, '}', 786};
|
||||
static uint32_t map[] = {'\n', 299, '"', 373, '#', 421, \
|
||||
'$', 370, '&', 336, '\'', 201, '(', 232, ')', 237, '-', \
|
||||
476, '0', 385, ';', 484, '<', 254, '>', 257, '\\', 144, \
|
||||
'`', 416, '|', 235, '[', 372, ']', 372, '{', 372, '}', \
|
||||
372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map293(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map219(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 751, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 602, '\'', 491, '(', 494, ')', 655, '-', \
|
||||
950, '0', 804, ';', 555, '<', 610, '>', 617, '\\', 349, \
|
||||
'`', 856, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
|
||||
786};
|
||||
static uint32_t map[] = {'\n', 304, '"', 373, '#', 421, \
|
||||
'$', 370, '&', 336, '\'', 201, ')', 237, '-', 476, '0', \
|
||||
386, ';', 484, '<', 254, '>', 257, '\\', 151, '`', 417, \
|
||||
'|', 235, '[', 372, ']', 372, '{', 372, '}', 372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map294(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map220(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 752, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 602, '\'', 491, '(', 494, ')', 655, '-', \
|
||||
950, '0', 803, ';', 555, '<', 609, '>', 617, '\\', 350, \
|
||||
'`', 856, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
|
||||
786};
|
||||
static uint32_t map[] = {'\n', 305, '"', 373, '#', 421, \
|
||||
'$', 370, '&', 336, '\'', 201, '(', 232, ')', 237, '-', \
|
||||
476, '0', 385, ';', 484, '<', 254, '>', 257, '\\', 152, \
|
||||
'`', 417, '|', 235, '[', 372, ']', 372, '{', 372, '}', \
|
||||
372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map295(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map221(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 753, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
|
||||
803, ';', 554, '<', 610, '>', 617, '\\', 351, '`', 856, \
|
||||
'|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'!', 248, '"', 373, '#', 396, \
|
||||
'$', 370, '%', 351, '&', 335, '\'', 201, '(', 232, ')', \
|
||||
237, '*', 346, '+', 363, ',', 311, '-', 361, '/', 349, \
|
||||
'0', 470, ':', 358, ';', 483, '<', 253, '=', 251, '>', \
|
||||
256, '?', 355, '@', 468, '[', 372, '\\', 133, ']', 485, \
|
||||
'^', 331, '_', 472, '`', 417, 'e', 480, 'i', 479, '{', \
|
||||
242, '|', 234, '}', 398, '~', 365};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map296(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map222(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 754, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 602, '\'', 491, '(', 494, ')', 655, '-', \
|
||||
950, '0', 803, ';', 555, '<', 610, '>', 617, '\\', 354, \
|
||||
'`', 856, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
|
||||
786};
|
||||
static uint32_t map[] = {'!', 248, '"', 373, '#', 421, \
|
||||
'$', 370, '&', 199, '\'', 201, '(', 232, ')', 237, '-', \
|
||||
476, '0', 385, ';', 200, '<', 254, '>', 257, '\\', 135, \
|
||||
'`', 416, '{', 242, '|', 235, '[', 372, ']', 372, '}', \
|
||||
372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
#endif // INLINE_IMPL13_H
|
||||
|
|
|
|||
|
|
@ -19,66 +19,64 @@
|
|||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map297(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map378(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 755, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 599, '\'', 491, '(', 654, '-', 950, '0', \
|
||||
803, ';', 555, '<', 495, '>', 496, '\\', 357, '`', 855, \
|
||||
'e', 956, '[', 786, ']', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'!', 247, '"', 373, '#', 396, \
|
||||
'$', 369, '*', 345, '-', 342, '0', 471, '?', 354, '@', \
|
||||
467, '\\', 69, '_', 474};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map298(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map379(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 756, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 489, '\'', 491, '(', 494, '-', 950, '0', \
|
||||
803, '<', 608, '>', 617, '\\', 370, '`', 856, '|', 516, \
|
||||
'[', 786, ']', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'!', 247, '#', 396, '$', 369, \
|
||||
'*', 345, '-', 342, '0', 471, '?', 354, '@', 467, '\\', \
|
||||
73, '_', 474};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map299(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map439(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 757, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 599, '\'', 491, '(', 494, '-', 950, '0', \
|
||||
803, ';', 555, '<', 495, '>', 496, '\\', 372, '`', 855, \
|
||||
'[', 786, ']', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'\n', 274, '!', 248, '"', 373, \
|
||||
'#', 396, '$', 370, '&', 336, '\'', 201, '(', 232, '*', \
|
||||
348, '-', 344, '0', 469, ';', 483, '<', 254, '>', 257, \
|
||||
'?', 355, '@', 468, '\\', 9, '_', 473, '`', 416, 'e', 430, \
|
||||
'|', 235};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map300(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map440(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 758, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 599, '\'', 491, '(', 494, '-', 950, '0', \
|
||||
803, ';', 555, '<', 495, '>', 496, '\\', 381, '`', 856, \
|
||||
'[', 786, ']', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'\n', 275, '!', 248, '"', 373, \
|
||||
'#', 396, '$', 370, '&', 336, '\'', 201, '(', 232, '*', \
|
||||
348, '-', 344, '0', 469, ';', 483, '<', 254, '>', 257, \
|
||||
'?', 355, '@', 468, '\\', 14, '_', 473, '`', 416, '|', \
|
||||
235};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map401(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map441(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 670, '"', 788, '#', 816, \
|
||||
'$', 781, '%', 647, '&', 601, '\'', 491, '(', 654, ')', \
|
||||
655, '*', 638, '+', 770, ',', 557, '-', 768, '/', 642, \
|
||||
'0', 944, ':', 765, ';', 554, '<', 607, '=', 563, '>', \
|
||||
616, '?', 761, '@', 942, '[', 674, '\\', 301, ']', 675, \
|
||||
'^', 595, '_', 946, '`', 856, 'e', 956, 'i', 955, '{', \
|
||||
666, '|', 592, '}', 818, '~', 772};
|
||||
static uint32_t map[] = {'\n', 276, '!', 248, '"', 373, \
|
||||
'#', 396, '$', 370, '&', 336, '\'', 201, '*', 348, '-', \
|
||||
344, '0', 469, ';', 483, '<', 254, '>', 257, '?', 355, \
|
||||
'@', 468, '\\', 16, '_', 473, '`', 416, 'e', 430, '|', \
|
||||
235};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
#endif // INLINE_IMPL14_H
|
||||
|
|
|
|||
|
|
@ -19,73 +19,66 @@
|
|||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map402(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map442(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 670, '"', 788, '#', 816, \
|
||||
'$', 781, '%', 649, '&', 601, '\'', 491, '(', 654, '*', \
|
||||
638, '+', 630, '-', 633, '/', 644, '0', 943, '<', 607, \
|
||||
'=', 560, '>', 616, '?', 761, '@', 942, '\\', 19, ']', \
|
||||
675, '^', 596, '_', 947, '`', 855, '|', 592, '[', 786, \
|
||||
'{', 786, '}', 786};
|
||||
static uint32_t map[] = {'\n', 277, '!', 248, '"', 373, \
|
||||
'#', 396, '$', 370, '&', 336, '\'', 201, '(', 232, ')', \
|
||||
237, '*', 348, '-', 344, '0', 469, ';', 484, '<', 254, \
|
||||
'>', 257, '?', 355, '@', 468, '\\', 22, '_', 473, '`', \
|
||||
416, '|', 235};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map403(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map443(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 670, '"', 788, '#', 862, \
|
||||
'$', 781, '%', 649, '&', 601, '\'', 491, '(', 654, '*', \
|
||||
638, '+', 771, '-', 769, '/', 644, '0', 803, '<', 607, \
|
||||
'=', 560, '>', 616, '?', 761, '\\', 308, ']', 675, '^', \
|
||||
596, '`', 856, '|', 592, '~', 772, '[', 786, '{', 786, \
|
||||
'}', 786};
|
||||
static uint32_t map[] = {'\n', 278, '!', 248, '"', 373, \
|
||||
'#', 396, '$', 370, '&', 336, '\'', 201, '(', 232, '*', \
|
||||
348, '-', 344, '0', 469, ';', 484, '<', 254, '>', 257, \
|
||||
'?', 355, '@', 468, '\\', 83, '_', 473, '`', 416, '|', \
|
||||
235};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map404(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map444(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 670, '"', 788, '#', 862, \
|
||||
'$', 781, '%', 649, '&', 600, '\'', 491, '(', 654, ')', \
|
||||
655, '*', 638, '+', 771, '-', 769, '/', 644, '0', 803, \
|
||||
'<', 614, '=', 560, '>', 619, '?', 761, '\\', 311, '^', \
|
||||
596, '`', 856, '|', 594, '~', 772, '[', 786, ']', 786, \
|
||||
'{', 786, '}', 786};
|
||||
static uint32_t map[] = {'\n', 279, '!', 248, '"', 373, \
|
||||
'#', 396, '$', 370, '&', 336, '\'', 201, '*', 348, '-', \
|
||||
344, '0', 469, ';', 483, '<', 254, '>', 257, '?', 355, \
|
||||
'@', 468, '\\', 24, '_', 473, '`', 416, '|', 235};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map405(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map445(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 670, '"', 788, '#', 862, \
|
||||
'$', 781, '%', 649, '&', 600, '\'', 491, '(', 654, ')', \
|
||||
499, '*', 638, '+', 771, '-', 769, '/', 644, '0', 803, \
|
||||
'<', 614, '=', 560, '>', 619, '?', 761, '\\', 314, '^', \
|
||||
596, '`', 856, '|', 594, '~', 772, '[', 786, ']', 786, \
|
||||
'{', 786, '}', 786};
|
||||
static uint32_t map[] = {'\n', 280, '!', 248, '"', 373, \
|
||||
'#', 396, '$', 370, '&', 336, '\'', 201, ')', 237, '*', \
|
||||
348, '-', 344, '0', 469, ';', 484, '<', 254, '>', 257, \
|
||||
'?', 355, '@', 468, '\\', 26, '_', 473, '`', 416, '|', \
|
||||
235};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map406(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map446(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 670, '"', 788, '#', 862, \
|
||||
'$', 781, '%', 649, '&', 600, '\'', 491, '(', 654, '*', \
|
||||
638, '+', 771, '-', 769, '/', 644, '0', 803, ':', 765, \
|
||||
'<', 614, '=', 560, '>', 619, '?', 761, '\\', 313, '^', \
|
||||
596, '`', 856, '|', 594, '~', 772, '[', 786, ']', 786, \
|
||||
'{', 786, '}', 786};
|
||||
static uint32_t map[] = {'\n', 281, '!', 248, '"', 373, \
|
||||
'#', 396, '$', 370, '&', 336, '\'', 201, '*', 348, '-', \
|
||||
344, '0', 469, ';', 484, '<', 254, '>', 257, '?', 355, \
|
||||
'@', 468, '\\', 89, '_', 473, '`', 416, '|', 235};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
#endif // INLINE_IMPL15_H
|
||||
|
|
|
|||
|
|
@ -19,70 +19,63 @@
|
|||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map407(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map447(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 670, '"', 788, '#', 862, \
|
||||
'$', 781, '%', 649, '&', 600, '\'', 491, '(', 654, '*', \
|
||||
638, '+', 771, '-', 769, '/', 644, '0', 803, '<', 614, \
|
||||
'=', 560, '>', 619, '?', 761, '\\', 312, ']', 675, '^', \
|
||||
596, '`', 856, '|', 594, '~', 772, '[', 786, '{', 786, \
|
||||
'}', 786};
|
||||
static uint32_t map[] = {'\n', 282, '!', 248, '"', 373, \
|
||||
'#', 396, '$', 370, '&', 199, '\'', 201, '(', 232, '*', \
|
||||
348, '-', 344, '0', 469, '<', 254, '>', 257, '?', 355, \
|
||||
'@', 468, '\\', 28, '_', 473, '`', 416, '|', 235};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map408(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map448(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 670, '"', 788, '#', 862, \
|
||||
'$', 781, '%', 649, '&', 600, '\'', 491, '(', 654, '*', \
|
||||
638, '+', 771, '-', 769, '/', 644, '0', 803, '<', 614, \
|
||||
'=', 560, '>', 619, '?', 761, '\\', 315, ']', 787, '^', \
|
||||
596, '`', 856, '|', 594, '~', 772, '[', 786, '{', 786, \
|
||||
'}', 786};
|
||||
static uint32_t map[] = {'\n', 283, '!', 248, '"', 373, \
|
||||
'#', 396, '$', 370, '&', 199, '\'', 201, '*', 348, '-', \
|
||||
344, '0', 469, '<', 254, '>', 257, '?', 355, '@', 468, \
|
||||
'\\', 34, '_', 473, '`', 416, '|', 235};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map409(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map449(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
|
||||
'$', 781, '&', 508, '\'', 491, '(', 494, '*', 640, '-', \
|
||||
636, '0', 943, '<', 608, '>', 617, '?', 761, '@', 942, \
|
||||
'\\', 74, '_', 947, '`', 855, '[', 786, ']', 786, '{', \
|
||||
786, '}', 786};
|
||||
static uint32_t map[] = {'\n', 284, '!', 247, '#', 396, \
|
||||
'$', 369, '&', 336, '*', 345, '-', 342, '0', 471, ';', \
|
||||
483, '<', 254, '>', 257, '?', 354, '@', 467, '\\', 40, \
|
||||
'_', 474, 'e', 436, '|', 235};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map410(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map450(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
|
||||
'$', 781, '&', 489, '\'', 491, '(', 654, '*', 640, '-', \
|
||||
636, '0', 943, '<', 609, '=', 952, '>', 617, '?', 761, \
|
||||
'@', 942, '\\', 51, '_', 947, '`', 855, '|', 593, '[', \
|
||||
786, ']', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'\n', 285, '!', 247, '#', 396, \
|
||||
'$', 369, '&', 336, '*', 345, '-', 342, '0', 471, ';', \
|
||||
483, '<', 254, '>', 257, '?', 354, '@', 467, '\\', 43, \
|
||||
'_', 474, '|', 235};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map411(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map451(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
|
||||
'$', 781, '&', 489, '\'', 491, '(', 494, '*', 640, '-', \
|
||||
636, '0', 943, '<', 609, '=', 952, '>', 617, '?', 761, \
|
||||
'@', 942, '\\', 171, '_', 947, '`', 855, '|', 593, '[', \
|
||||
786, ']', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'\n', 286, '!', 247, '#', 396, \
|
||||
'$', 369, '&', 336, '*', 345, '-', 342, '0', 471, ';', \
|
||||
484, '<', 254, '>', 257, '?', 354, '@', 467, '\\', 45, \
|
||||
'_', 474, '`', 416, '|', 235};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
#endif // INLINE_IMPL16_H
|
||||
|
|
|
|||
|
|
@ -19,68 +19,62 @@
|
|||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map412(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map452(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
|
||||
'$', 781, '&', 489, '\'', 491, '(', 494, '*', 640, '-', \
|
||||
636, '0', 943, '<', 609, '>', 617, '?', 761, '@', 942, \
|
||||
'\\', 55, ']', 675, '_', 947, '`', 855, '|', 593, '[', \
|
||||
786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'\n', 287, '!', 247, '#', 396, \
|
||||
'$', 369, '&', 336, ')', 237, '*', 345, '-', 342, '0', \
|
||||
471, ';', 484, '<', 254, '>', 257, '?', 354, '@', 467, \
|
||||
'\\', 48, '_', 474, '|', 235};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map413(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map453(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
|
||||
'$', 781, '&', 489, '\'', 491, '(', 494, '*', 640, '-', \
|
||||
636, '0', 943, '<', 609, '>', 617, '?', 761, '@', 942, \
|
||||
'\\', 62, '_', 947, '`', 855, '|', 593, '[', 786, ']', \
|
||||
786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'\n', 288, '!', 247, '#', 396, \
|
||||
'$', 369, '&', 336, '*', 345, '-', 342, '0', 471, ';', \
|
||||
484, '<', 254, '>', 257, '?', 354, '@', 467, '\\', 95, \
|
||||
'_', 474, '|', 235};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map414(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map454(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
|
||||
'$', 781, '&', 489, '\'', 491, '(', 494, '*', 640, '-', \
|
||||
636, '0', 943, '<', 610, '>', 617, '?', 761, '@', 942, \
|
||||
'\\', 231, ']', 675, '_', 947, '`', 855, '|', 593, '[', \
|
||||
786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'\n', 289, '!', 247, '#', 396, \
|
||||
'$', 369, '&', 199, '*', 345, '-', 342, '0', 471, '<', \
|
||||
254, '>', 257, '?', 354, '@', 467, '\\', 51, '_', 474, \
|
||||
'|', 235};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map415(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map455(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
|
||||
'$', 781, '&', 489, '\'', 491, '(', 494, '*', 640, '-', \
|
||||
636, '0', 943, '<', 610, '>', 617, '?', 761, '@', 942, \
|
||||
'\\', 235, '_', 947, '`', 855, '|', 593, '[', 786, ']', \
|
||||
786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'\n', 290, '!', 247, '#', 396, \
|
||||
'$', 369, '&', 199, '*', 345, '-', 342, '0', 471, '<', \
|
||||
252, '>', 257, '?', 354, '@', 467, '\\', 97, '_', 474, \
|
||||
'|', 212};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map416(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map456(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
|
||||
'$', 781, '\'', 491, '(', 494, ')', 655, '*', 640, '-', \
|
||||
636, '0', 943, '<', 495, '>', 496, '?', 761, '@', 942, \
|
||||
'\\', 110, '_', 947, '`', 855, '[', 786, ']', 786, '{', \
|
||||
786, '}', 786};
|
||||
static uint32_t map[] = {'\n', 291, '!', 247, '#', 396, \
|
||||
'$', 369, '&', 333, '*', 345, '-', 342, '0', 471, ';', \
|
||||
484, '?', 354, '@', 467, '\\', 66, '_', 474, 'i', 435};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
#endif // INLINE_IMPL17_H
|
||||
|
|
|
|||
|
|
@ -19,65 +19,62 @@
|
|||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map417(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map457(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 672, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 508, '\'', 491, '(', 654, ')', 655, '-', \
|
||||
950, '0', 803, ';', 490, '<', 608, '>', 617, '[', 674, \
|
||||
'\\', 304, '`', 855, '{', 666, '|', 590, ']', 786, '}', \
|
||||
786};
|
||||
static uint32_t map[] = {'\n', 293, '!', 248, '"', 373, \
|
||||
'#', 396, '$', 370, '&', 199, '\'', 201, '*', 348, '-', \
|
||||
344, '0', 469, '<', 252, '>', 257, '?', 355, '@', 468, \
|
||||
'\\', 93, '_', 473, '`', 416, '|', 212};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map418(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map458(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 672, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 508, '\'', 491, '(', 654, ')', 499, '+', \
|
||||
771, '-', 769, '0', 803, '<', 608, '>', 617, '[', 674, \
|
||||
'\\', 305, '`', 855, '{', 666, '|', 591, '~', 772, ']', \
|
||||
786, '}', 786};
|
||||
static uint32_t map[] = {'\n', 295, '!', 248, '"', 373, \
|
||||
'#', 396, '$', 370, '&', 333, '\'', 201, '*', 348, '-', \
|
||||
344, '0', 469, ';', 484, '?', 355, '@', 468, '\\', 57, \
|
||||
'_', 473, '`', 416};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map419(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map459(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 672, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 508, '\'', 491, '(', 654, '+', 771, '-', \
|
||||
769, '0', 803, '<', 608, '>', 617, '[', 674, '\\', 306, \
|
||||
']', 675, '`', 855, '{', 666, '}', 786, '~', 772};
|
||||
static uint32_t map[] = {'\n', 297, '!', 248, '"', 373, \
|
||||
'#', 396, '$', 370, '\'', 201, '*', 348, '-', 344, '0', \
|
||||
469, '?', 355, '@', 468, '\\', 63, '_', 473, '`', 416};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map420(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map460(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 672, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 508, '\'', 491, '(', 654, '+', 771, '-', \
|
||||
769, '0', 803, '<', 608, '>', 617, '[', 674, '\\', 320, \
|
||||
'`', 855, '~', 772, ']', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'!', 248, '"', 373, '#', 396, \
|
||||
'$', 370, '&', 199, '\'', 201, '(', 232, '*', 348, '-', \
|
||||
344, '0', 469, '<', 254, '>', 257, '?', 355, '@', 468, \
|
||||
'\\', 31, '_', 473, '`', 416, '|', 235};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map421(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map461(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 672, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 508, '\'', 491, '(', 654, '-', 950, '0', \
|
||||
803, ';', 490, '<', 608, '>', 617, '[', 674, '\\', 309, \
|
||||
'`', 855, 'e', 956, '{', 666, ']', 786, '}', 786};
|
||||
static uint32_t map[] = {'!', 248, '"', 373, '#', 396, \
|
||||
'$', 370, '&', 199, '\'', 201, '*', 348, '-', 344, '0', \
|
||||
469, '<', 254, '>', 257, '?', 355, '@', 468, '\\', 36, \
|
||||
'_', 473, '`', 416, '|', 235};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
#endif // INLINE_IMPL18_H
|
||||
|
|
|
|||
|
|
@ -19,65 +19,48 @@
|
|||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map422(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map462(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 672, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 508, '\'', 491, '(', 654, '-', 950, '0', \
|
||||
803, '<', 608, '>', 617, '[', 674, '\\', 310, ']', 786, \
|
||||
'`', 855, '{', 666, '}', 667};
|
||||
static uint32_t map[] = {'!', 248, '"', 373, '#', 396, \
|
||||
'$', 370, '&', 206, '\'', 201, '*', 348, '-', 344, '0', \
|
||||
469, '<', 252, '>', 257, '?', 355, '@', 468, '\\', 38, \
|
||||
'_', 473, '`', 416};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map423(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map463(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 672, '"', 788, '#', 862, \
|
||||
'$', 781, '\'', 491, '(', 654, ')', 499, '+', 771, '-', \
|
||||
769, '0', 803, '<', 495, '>', 496, '\\', 352, '`', 855, \
|
||||
'~', 772, '[', 786, ']', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'!', 247, '#', 396, '$', 369, \
|
||||
'&', 199, '*', 345, '-', 342, '0', 471, '<', 254, '>', \
|
||||
257, '?', 354, '@', 467, '\\', 54, '_', 474, '|', 235};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map424(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map464(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 672, '"', 788, '#', 862, \
|
||||
'$', 781, '\'', 491, '(', 654, ')', 499, '+', 771, '-', \
|
||||
769, '0', 804, '<', 495, '>', 496, '\\', 332, '`', 855, \
|
||||
'~', 772, '[', 786, ']', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'!', 247, '#', 396, '$', 369, \
|
||||
')', 237, '*', 345, '-', 342, '0', 471, '?', 354, '@', \
|
||||
467, '\\', 71, '_', 474, '|', 233};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map425(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map465(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 951, '"', 788, '#', 862, \
|
||||
'$', 781, '%', 649, '&', 601, '\'', 491, '(', 654, '*', \
|
||||
638, '+', 630, '-', 633, '/', 644, '0', 803, '<', 607, \
|
||||
'=', 560, '>', 616, '?', 761, '\\', 318, ']', 675, '^', \
|
||||
596, '`', 856, '|', 592, '[', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'!', 247, '#', 396, '$', 369, \
|
||||
'*', 345, '-', 342, '0', 471, '?', 354, '@', 467, '\\', \
|
||||
75, '_', 474};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map426(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 951, '"', 788, '#', 862, \
|
||||
'$', 781, '%', 649, '&', 601, '\'', 491, '(', 654, '*', \
|
||||
638, '+', 630, '-', 633, '/', 644, '0', 803, '<', 607, \
|
||||
'=', 560, '>', 616, '?', 761, '\\', 319, ']', 675, '^', \
|
||||
596, '`', 855, '|', 592, '[', 786, '{', 786, '}', 786};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
#endif // INLINE_IMPL19_H
|
||||
|
|
|
|||
|
|
@ -19,67 +19,65 @@
|
|||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map237(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map106(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 695, '!', 669, '"', 788, \
|
||||
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
|
||||
945, ';', 554, '<', 612, '>', 618, '?', 760, '@', 941, \
|
||||
'\\', 91, '_', 948, '|', 593};
|
||||
static uint32_t map[] = {'\n', 282, '!', 248, '"', 373, \
|
||||
'#', 396, '$', 370, '&', 199, '\'', 201, '(', 232, '*', \
|
||||
348, '-', 344, '0', 469, '<', 254, '>', 257, '?', 355, \
|
||||
'@', 468, '\\', 28, '_', 473, '`', 416, '|', 235, '[', \
|
||||
372, ']', 372, '{', 372, '}', 372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map238(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map107(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 696, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 654, '*', \
|
||||
640, '-', 636, '0', 943, ';', 554, '<', 609, '=', 952, \
|
||||
'>', 617, '?', 761, '@', 942, '\\', 30, '_', 947, '`', \
|
||||
855, '|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'\n', 283, '!', 248, '"', 373, \
|
||||
'#', 396, '$', 370, '&', 199, '\'', 201, '*', 348, '-', \
|
||||
344, '0', 469, '<', 254, '>', 257, '?', 355, '@', 468, \
|
||||
'\\', 34, '_', 473, '`', 416, '|', 235, '[', 372, ']', \
|
||||
372, '{', 372, '}', 372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map239(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map108(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 697, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 602, '\'', 491, '(', 654, '-', 950, '0', \
|
||||
803, ';', 554, '<', 609, '=', 952, '>', 617, '\\', 321, \
|
||||
'`', 855, 'e', 956, '|', 593, '[', 786, ']', 786, '{', \
|
||||
786, '}', 786};
|
||||
static uint32_t map[] = {'\n', 284, '!', 247, '#', 396, \
|
||||
'$', 369, '&', 336, '*', 345, '-', 342, '0', 471, ';', \
|
||||
483, '<', 254, '>', 257, '?', 354, '@', 467, '\\', 40, \
|
||||
'_', 474, 'e', 436, '|', 235};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map240(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map109(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 698, '!', 669, '"', 788, \
|
||||
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
|
||||
945, ';', 554, '<', 613, '>', 618, '?', 760, '@', 941, \
|
||||
'\\', 183, '_', 948, 'e', 877, '|', 593};
|
||||
static uint32_t map[] = {'\n', 285, '!', 247, '#', 396, \
|
||||
'$', 369, '&', 336, '*', 345, '-', 342, '0', 471, ';', \
|
||||
483, '<', 254, '>', 257, '?', 354, '@', 467, '\\', 43, \
|
||||
'_', 474, '|', 235};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map241(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map110(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 699, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
|
||||
640, '-', 636, '0', 943, ';', 554, '<', 609, '=', 952, \
|
||||
'>', 617, '?', 761, '@', 942, '\\', 153, '_', 947, '`', \
|
||||
855, 'e', 871, '|', 593, '[', 786, ']', 786, '{', 786, \
|
||||
'}', 786};
|
||||
static uint32_t map[] = {'\n', 286, '!', 247, '#', 396, \
|
||||
'$', 369, '&', 336, '*', 345, '-', 342, '0', 471, ';', \
|
||||
484, '<', 254, '>', 257, '?', 354, '@', 467, '\\', 45, \
|
||||
'_', 474, '`', 416, '|', 235};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
#endif // INLINE_IMPL2_H
|
||||
|
|
|
|||
|
|
@ -1,86 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* inline_impl20.h :+: :+: :+: */
|
||||
/* +:+ +:+ +:+ */
|
||||
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
|
||||
/* +#+#+#+#+#+ +#+ */
|
||||
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
|
||||
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
|
||||
/* */
|
||||
/* ************************************************************************** */
|
||||
|
||||
#ifndef INLINE_IMPL20_H
|
||||
# define INLINE_IMPL20_H
|
||||
|
||||
# include "../../../headers/symbols.h"
|
||||
# include "../../../headers/external_scanner_symbol_identifiers.h"
|
||||
# include "../../../headers/field_identifiers.h"
|
||||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map427(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 671, '"', 788, '#', 816, \
|
||||
'$', 780, '%', 650, '&', 600, ')', 655, '*', 639, '+', \
|
||||
631, '-', 634, '/', 645, '0', 945, '<', 615, '=', 562, \
|
||||
'>', 620, '?', 760, '@', 941, '\\', 67, '^', 597, '_', \
|
||||
948, '|', 594};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map428(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 671, '"', 788, '#', 816, \
|
||||
'$', 780, '%', 650, '&', 600, ')', 499, '*', 639, '+', \
|
||||
631, '-', 634, '/', 645, '0', 945, '<', 615, '=', 562, \
|
||||
'>', 620, '?', 760, '@', 941, '\\', 181, '^', 597, '_', \
|
||||
948, '|', 594};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map429(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 671, '"', 788, '#', 816, \
|
||||
'$', 780, '%', 650, '&', 600, '*', 639, '+', 631, '-', \
|
||||
634, '/', 645, '0', 945, ':', 762, '<', 615, '=', 562, \
|
||||
'>', 620, '?', 760, '@', 941, '\\', 64, '^', 597, '_', \
|
||||
948, '|', 594};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map430(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 671, '"', 788, '#', 816, \
|
||||
'$', 780, '%', 650, '&', 600, '*', 639, '+', 631, '-', \
|
||||
634, '/', 645, '0', 945, '<', 615, '=', 562, '>', 620, \
|
||||
'?', 760, '@', 941, '\\', 60, ']', 675, '^', 597, '_', \
|
||||
948, '|', 594};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map431(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 671, '"', 788, '#', 816, \
|
||||
'$', 780, '%', 650, '&', 600, '*', 639, '+', 631, '-', \
|
||||
634, '/', 645, '0', 945, '<', 615, '=', 562, '>', 620, \
|
||||
'?', 760, '@', 941, '\\', 178, ']', 509, '^', 597, '_', \
|
||||
948, '|', 594};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
|
|
@ -1,82 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* inline_impl21.h :+: :+: :+: */
|
||||
/* +:+ +:+ +:+ */
|
||||
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
|
||||
/* +#+#+#+#+#+ +#+ */
|
||||
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
|
||||
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
|
||||
/* */
|
||||
/* ************************************************************************** */
|
||||
|
||||
#ifndef INLINE_IMPL21_H
|
||||
# define INLINE_IMPL21_H
|
||||
|
||||
# include "../../../headers/symbols.h"
|
||||
# include "../../../headers/external_scanner_symbol_identifiers.h"
|
||||
# include "../../../headers/field_identifiers.h"
|
||||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map432(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 671, '"', 788, '#', 816, \
|
||||
'$', 780, '%', 650, '&', 600, '*', 639, '+', 631, '-', \
|
||||
634, '/', 645, '0', 945, '<', 615, '=', 562, '>', 620, \
|
||||
'?', 760, '@', 941, '\\', 69, '^', 597, '_', 948, '|', \
|
||||
594};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map433(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 506, '"', 788, '#', 862, \
|
||||
'$', 785, '%', 650, '&', 600, ')', 499, '*', 639, '+', \
|
||||
631, ',', 556, '-', 634, '.', 503, '/', 645, ':', 762, \
|
||||
';', 490, '<', 615, '=', 562, '>', 620, '?', 760, '[', \
|
||||
673};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map434(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 506, '"', 788, '#', 862, \
|
||||
'$', 785, '%', 650, '&', 600, ')', 499, '*', 639, '+', \
|
||||
631, ',', 556, '-', 634, '/', 645, ':', 762, ';', 490, \
|
||||
'<', 615, '=', 562, '>', 620, '?', 760, '[', 673};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map435(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 506, '"', 788, '#', 862, \
|
||||
'$', 498, '%', 650, '&', 600, '(', 494, ')', 655, '*', \
|
||||
639, '+', 631, ',', 556, '-', 634, '/', 645, '<', 615, \
|
||||
'=', 562, '>', 620, '?', 760};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map436(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 506, '#', 862, '%', 650, \
|
||||
'&', 600, ')', 655, '*', 639, '+', 631, ',', 556, '-', \
|
||||
635, '/', 645, '<', 615, '=', 561, '>', 620};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
|
|
@ -1,77 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* inline_impl22.h :+: :+: :+: */
|
||||
/* +:+ +:+ +:+ */
|
||||
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
|
||||
/* +#+#+#+#+#+ +#+ */
|
||||
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
|
||||
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
|
||||
/* */
|
||||
/* ************************************************************************** */
|
||||
|
||||
#ifndef INLINE_IMPL22_H
|
||||
# define INLINE_IMPL22_H
|
||||
|
||||
# include "../../../headers/symbols.h"
|
||||
# include "../../../headers/external_scanner_symbol_identifiers.h"
|
||||
# include "../../../headers/field_identifiers.h"
|
||||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map437(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 506, '#', 862, '%', 650, \
|
||||
'&', 600, ')', 655, '*', 639, '+', 631, '-', 634, '/', \
|
||||
645, '<', 615, '=', 562, '>', 620, '?', 760, '[', 673};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map438(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 506, '#', 862, '%', 650, \
|
||||
'&', 600, ')', 655, '*', 639, '+', 631, '-', 634, '/', \
|
||||
645, '<', 615, '=', 562, '>', 620, '?', 760};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map439(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 506, '#', 862, '%', 650, \
|
||||
'&', 600, ')', 655, '*', 639, '+', 631, '-', 634, '/', \
|
||||
645, '<', 615, '=', 562, '>', 620, '?', 760};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map440(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 506, '#', 862, '%', 650, \
|
||||
'&', 600, ')', 499, '*', 639, '+', 631, ',', 556, '-', \
|
||||
634, '/', 645, ':', 762, '<', 615, '=', 562, '>', 620, \
|
||||
'?', 760};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map441(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 506, '#', 862, '%', 650, \
|
||||
'&', 600, ')', 499, '*', 639, '+', 631, ',', 556, '-', \
|
||||
635, '/', 645, '<', 615, '=', 561, '>', 620};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
|
|
@ -1,79 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* inline_impl23.h :+: :+: :+: */
|
||||
/* +:+ +:+ +:+ */
|
||||
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
|
||||
/* +#+#+#+#+#+ +#+ */
|
||||
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
|
||||
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
|
||||
/* */
|
||||
/* ************************************************************************** */
|
||||
|
||||
#ifndef INLINE_IMPL23_H
|
||||
# define INLINE_IMPL23_H
|
||||
|
||||
# include "../../../headers/symbols.h"
|
||||
# include "../../../headers/external_scanner_symbol_identifiers.h"
|
||||
# include "../../../headers/field_identifiers.h"
|
||||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map442(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 506, '#', 862, '%', 650, \
|
||||
'&', 600, ')', 499, '*', 639, '+', 631, ',', 556, '-', \
|
||||
635, '/', 645, '<', 615, '=', 561, '>', 620};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map443(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 506, '#', 862, '%', 650, \
|
||||
'&', 600, ')', 499, '*', 639, '+', 631, '-', 634, '/', \
|
||||
645, ':', 762, '<', 615, '=', 562, '>', 620, '?', 760};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map444(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 669, '"', 788, '#', 816, \
|
||||
'$', 780, '&', 489, '*', 637, '-', 632, '0', 945, '<', \
|
||||
612, '>', 618, '?', 760, '@', 941, '\\', 108, ']', 675, \
|
||||
'_', 948, '|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map445(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 669, '"', 788, '#', 816, \
|
||||
'$', 780, '&', 489, '*', 637, '-', 632, '0', 945, '<', \
|
||||
612, '>', 618, '?', 760, '@', 941, '\\', 114, '_', 948, \
|
||||
'|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map446(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 669, '"', 788, '#', 816, \
|
||||
'$', 780, '&', 489, '*', 637, '-', 632, '0', 945, '<', \
|
||||
613, '>', 618, '?', 760, '@', 941, '\\', 195, ']', 675, \
|
||||
'_', 948, '|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
|
|
@ -1,77 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* inline_impl24.h :+: :+: :+: */
|
||||
/* +:+ +:+ +:+ */
|
||||
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
|
||||
/* +#+#+#+#+#+ +#+ */
|
||||
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
|
||||
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
|
||||
/* */
|
||||
/* ************************************************************************** */
|
||||
|
||||
#ifndef INLINE_IMPL24_H
|
||||
# define INLINE_IMPL24_H
|
||||
|
||||
# include "../../../headers/symbols.h"
|
||||
# include "../../../headers/external_scanner_symbol_identifiers.h"
|
||||
# include "../../../headers/field_identifiers.h"
|
||||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map447(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 669, '"', 788, '#', 816, \
|
||||
'$', 780, '&', 489, '*', 637, '-', 632, '0', 945, '<', \
|
||||
613, '>', 618, '?', 760, '@', 941, '\\', 197, '_', 948, \
|
||||
'|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map448(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 669, '"', 788, '#', 816, \
|
||||
'$', 780, ')', 655, '*', 637, '-', 632, '0', 945, '?', \
|
||||
760, '@', 941, '\\', 132, '_', 948, '|', 590};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map449(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 669, '"', 788, '#', 816, \
|
||||
'$', 780, '*', 637, '-', 632, '0', 945, '?', 760, '@', \
|
||||
941, '\\', 135, '_', 948};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map450(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 669, '"', 788, '#', 816, \
|
||||
'$', 780, '*', 637, '-', 632, '0', 945, '?', 760, '@', \
|
||||
941, '\\', 134, '_', 948};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map451(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 669, '"', 788, '#', 862, \
|
||||
'$', 785, '&', 489, '(', 653, '+', 771, '-', 769, '0', \
|
||||
808, '<', 612, '>', 618};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
|
|
@ -1,74 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* inline_impl25.h :+: :+: :+: */
|
||||
/* +:+ +:+ +:+ */
|
||||
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
|
||||
/* +#+#+#+#+#+ +#+ */
|
||||
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
|
||||
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
|
||||
/* */
|
||||
/* ************************************************************************** */
|
||||
|
||||
#ifndef INLINE_IMPL25_H
|
||||
# define INLINE_IMPL25_H
|
||||
|
||||
# include "../../../headers/symbols.h"
|
||||
# include "../../../headers/external_scanner_symbol_identifiers.h"
|
||||
# include "../../../headers/field_identifiers.h"
|
||||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map452(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 669, '#', 816, '$', 780, \
|
||||
'*', 637, '-', 632, '0', 945, '?', 760, '@', 941, '\\', \
|
||||
136, '_', 948};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map453(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 669, '#', 816, '$', 780, \
|
||||
'*', 637, '-', 632, '0', 945, '?', 760, '@', 941, '\\', \
|
||||
138, '_', 948};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map454(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 669, '#', 816, '$', 784, \
|
||||
'*', 637, '-', 632, '0', 945, '?', 760, '@', 941};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map455(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 669, '#', 816, '$', 784, \
|
||||
'*', 637, '-', 632, '0', 945, '?', 760, '@', 941};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map456(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 819, '#', 825, '$', 784, \
|
||||
'*', 637, '-', 632, '0', 945, '=', 826, '?', 760, '@', \
|
||||
941};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
|
|
@ -1,81 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* inline_impl26.h :+: :+: :+: */
|
||||
/* +:+ +:+ +:+ */
|
||||
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
|
||||
/* +#+#+#+#+#+ +#+ */
|
||||
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
|
||||
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
|
||||
/* */
|
||||
/* ************************************************************************** */
|
||||
|
||||
#ifndef INLINE_IMPL26_H
|
||||
# define INLINE_IMPL26_H
|
||||
|
||||
# include "../../../headers/symbols.h"
|
||||
# include "../../../headers/external_scanner_symbol_identifiers.h"
|
||||
# include "../../../headers/field_identifiers.h"
|
||||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map457(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'"', 788, '#', 862, '$', 781, \
|
||||
'&', 508, '\'', 491, '(', 654, '-', 950, '0', 803, '<', \
|
||||
608, '>', 617, '[', 674, '\\', 330, '`', 855, ']', 786, \
|
||||
'{', 786, '}', 786};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map458(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'"', 788, '#', 862, '$', 781, \
|
||||
'&', 508, '\'', 491, '(', 494, ')', 655, '-', 950, '0', \
|
||||
803, '<', 608, '>', 617, '\\', 340, '`', 855, '|', 590, \
|
||||
'[', 786, ']', 786, '{', 786, '}', 786};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map459(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'"', 788, '#', 862, '$', 781, \
|
||||
'&', 508, '\'', 491, '(', 494, ')', 655, '-', 950, '0', \
|
||||
803, '<', 608, '>', 617, '\\', 371, '`', 856, '|', 590, \
|
||||
'[', 786, ']', 786, '{', 786, '}', 786};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map460(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'"', 788, '#', 862, '$', 781, \
|
||||
'&', 489, '\'', 491, '(', 654, ')', 655, '-', 950, '0', \
|
||||
803, '<', 609, '>', 617, '\\', 338, '`', 855, '|', 593, \
|
||||
'[', 786, ']', 786, '{', 786, '}', 786};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map461(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'"', 788, '#', 862, '$', 781, \
|
||||
'&', 489, '\'', 491, '(', 654, '-', 950, '0', 803, '<', \
|
||||
609, '=', 952, '>', 617, '\\', 329, '`', 855, '|', 593, \
|
||||
'[', 786, ']', 786, '{', 786, '}', 786};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
|
|
@ -1,81 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* inline_impl27.h :+: :+: :+: */
|
||||
/* +:+ +:+ +:+ */
|
||||
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
|
||||
/* +#+#+#+#+#+ +#+ */
|
||||
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
|
||||
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
|
||||
/* */
|
||||
/* ************************************************************************** */
|
||||
|
||||
#ifndef INLINE_IMPL27_H
|
||||
# define INLINE_IMPL27_H
|
||||
|
||||
# include "../../../headers/symbols.h"
|
||||
# include "../../../headers/external_scanner_symbol_identifiers.h"
|
||||
# include "../../../headers/field_identifiers.h"
|
||||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map462(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'"', 788, '#', 862, '$', 781, \
|
||||
'&', 489, '\'', 491, '(', 654, '-', 950, '0', 803, '<', \
|
||||
609, '=', 952, '>', 617, '\\', 353, '`', 856, '|', 593, \
|
||||
'[', 786, ']', 786, '{', 786, '}', 786};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map463(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'"', 788, '#', 862, '$', 781, \
|
||||
'&', 489, '\'', 491, '(', 494, ')', 655, '-', 950, '0', \
|
||||
803, '<', 609, '>', 617, '\\', 358, '`', 856, '|', 593, \
|
||||
'[', 786, ']', 786, '{', 786, '}', 786};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map464(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'"', 788, '#', 862, '$', 781, \
|
||||
'&', 489, '\'', 491, '(', 494, '-', 950, '0', 803, '<', \
|
||||
609, '>', 617, '\\', 336, ']', 675, '`', 855, '|', 593, \
|
||||
'[', 786, '{', 786, '}', 786};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map465(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'"', 788, '#', 862, '$', 781, \
|
||||
'&', 489, '\'', 491, '(', 494, '-', 950, '0', 803, '<', \
|
||||
609, '>', 617, '\\', 355, ']', 675, '`', 856, '|', 593, \
|
||||
'[', 786, '{', 786, '}', 786};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map466(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'"', 788, '#', 862, '$', 781, \
|
||||
'&', 489, '\'', 491, '(', 494, '-', 950, '0', 803, '<', \
|
||||
610, '>', 617, '\\', 342, '`', 855, '|', 593, '[', 786, \
|
||||
']', 786, '{', 786, '}', 786};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
|
|
@ -1,81 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* inline_impl28.h :+: :+: :+: */
|
||||
/* +:+ +:+ +:+ */
|
||||
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
|
||||
/* +#+#+#+#+#+ +#+ */
|
||||
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
|
||||
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
|
||||
/* */
|
||||
/* ************************************************************************** */
|
||||
|
||||
#ifndef INLINE_IMPL28_H
|
||||
# define INLINE_IMPL28_H
|
||||
|
||||
# include "../../../headers/symbols.h"
|
||||
# include "../../../headers/external_scanner_symbol_identifiers.h"
|
||||
# include "../../../headers/field_identifiers.h"
|
||||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map467(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'"', 788, '#', 862, '$', 781, \
|
||||
'&', 489, '\'', 491, '(', 494, '-', 950, '0', 803, '<', \
|
||||
610, '>', 617, '\\', 363, ']', 675, '`', 856, '|', 593, \
|
||||
'[', 786, '{', 786, '}', 786};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map468(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'"', 788, '#', 862, '$', 781, \
|
||||
'&', 489, '\'', 491, '(', 494, '-', 950, '0', 803, '<', \
|
||||
610, '>', 617, '\\', 364, '`', 856, '|', 593, '[', 786, \
|
||||
']', 786, '{', 786, '}', 786};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map469(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'"', 788, '#', 862, '$', 781, \
|
||||
'&', 489, '\'', 491, '(', 494, '-', 950, '0', 803, '<', \
|
||||
610, '>', 617, '\\', 400, ']', 675, '`', 855, '|', 593, \
|
||||
'[', 786, '{', 786, '}', 786};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map470(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'"', 788, '#', 862, '$', 781, \
|
||||
'&', 489, '\'', 491, '(', 494, '-', 950, '0', 804, '<', \
|
||||
610, '>', 617, '\\', 334, '`', 855, '|', 593, '[', 786, \
|
||||
']', 786, '{', 786, '}', 786};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map471(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'"', 788, '#', 862, '$', 781, \
|
||||
'&', 489, '\'', 491, '(', 494, '-', 950, '0', 804, '<', \
|
||||
610, '>', 617, '\\', 359, '`', 856, '|', 593, '[', 786, \
|
||||
']', 786, '{', 786, '}', 786};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
|
|
@ -1,78 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* inline_impl29.h :+: :+: :+: */
|
||||
/* +:+ +:+ +:+ */
|
||||
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
|
||||
/* +#+#+#+#+#+ +#+ */
|
||||
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
|
||||
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
|
||||
/* */
|
||||
/* ************************************************************************** */
|
||||
|
||||
#ifndef INLINE_IMPL29_H
|
||||
# define INLINE_IMPL29_H
|
||||
|
||||
# include "../../../headers/symbols.h"
|
||||
# include "../../../headers/external_scanner_symbol_identifiers.h"
|
||||
# include "../../../headers/field_identifiers.h"
|
||||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map472(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'"', 788, '#', 862, '$', 781, \
|
||||
'\'', 491, '(', 654, '-', 950, '0', 803, '<', 495, '>', \
|
||||
496, '\\', 366, '`', 855, 'e', 956, '[', 786, ']', 786, \
|
||||
'{', 786, '}', 786};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map473(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'"', 788, '#', 862, '$', 781, \
|
||||
'\'', 491, '(', 654, '-', 950, '0', 803, '<', 495, '>', \
|
||||
496, '\\', 373, '`', 855, '}', 818, '[', 786, ']', 786, \
|
||||
'{', 786};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map474(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'"', 788, '#', 862, '$', 785, \
|
||||
'&', 489, '(', 653, ')', 499, '+', 501, '-', 502, '0', \
|
||||
809, '<', 613, '=', 559, '>', 618};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map475(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'"', 788, '#', 862, '$', 782, \
|
||||
'\'', 491, '(', 653, ')', 655, ';', 553, '<', 495, '>', \
|
||||
496, '\\', 389, '`', 855, '{', 666, '|', 590, '}', 818};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map476(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'"', 788, '#', 862, '$', 497, \
|
||||
'%', 646, '*', 637, '+', 629, '-', 632, '/', 641, ':', \
|
||||
762};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
|
|
@ -19,67 +19,62 @@
|
|||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map242(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map111(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 700, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 602, '\'', 491, '(', 654, '-', 950, '0', \
|
||||
803, ';', 554, '<', 609, '=', 952, '>', 617, '\\', 322, \
|
||||
'`', 855, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
|
||||
786};
|
||||
static uint32_t map[] = {'\n', 287, '!', 247, '#', 396, \
|
||||
'$', 369, '&', 336, ')', 237, '*', 345, '-', 342, '0', \
|
||||
471, ';', 484, '<', 254, '>', 257, '?', 354, '@', 467, \
|
||||
'\\', 48, '_', 474, '|', 235};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map243(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map112(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 701, '!', 669, '"', 788, \
|
||||
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
|
||||
945, ';', 554, '<', 613, '>', 618, '?', 760, '@', 941, \
|
||||
'\\', 185, '_', 948, '|', 593};
|
||||
static uint32_t map[] = {'\n', 288, '!', 247, '#', 396, \
|
||||
'$', 369, '&', 336, '*', 345, '-', 342, '0', 471, ';', \
|
||||
484, '<', 254, '>', 257, '?', 354, '@', 467, '\\', 95, \
|
||||
'_', 474, '|', 235};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map244(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map113(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 702, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 654, ')', \
|
||||
655, '*', 640, '-', 636, '0', 943, ';', 555, '<', 609, \
|
||||
'=', 952, '>', 617, '?', 761, '@', 942, '\\', 32, '_', \
|
||||
947, '`', 855, '|', 593, '[', 786, ']', 786, '{', 786, \
|
||||
'}', 786};
|
||||
static uint32_t map[] = {'\n', 289, '!', 247, '#', 396, \
|
||||
'$', 369, '&', 199, '*', 345, '-', 342, '0', 471, '<', \
|
||||
254, '>', 257, '?', 354, '@', 467, '\\', 51, '_', 474, \
|
||||
'|', 235};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map245(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map114(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 703, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 602, '\'', 491, '(', 654, ')', 655, '-', \
|
||||
950, '0', 803, ';', 555, '<', 609, '=', 952, '>', 617, \
|
||||
'\\', 323, '`', 855, '|', 593, '[', 786, ']', 786, '{', \
|
||||
786, '}', 786};
|
||||
static uint32_t map[] = {'\n', 290, '!', 247, '#', 396, \
|
||||
'$', 369, '&', 199, '*', 345, '-', 342, '0', 471, '<', \
|
||||
252, '>', 257, '?', 354, '@', 467, '\\', 97, '_', 474, \
|
||||
'|', 212};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map246(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map115(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 704, '!', 669, '"', 788, \
|
||||
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
|
||||
945, ';', 555, '<', 612, '>', 618, '?', 760, '@', 941, \
|
||||
'\\', 96, '_', 948, '`', 855, '|', 593};
|
||||
static uint32_t map[] = {'\n', 291, '!', 247, '#', 396, \
|
||||
'$', 369, '&', 333, '*', 345, '-', 342, '0', 471, ';', \
|
||||
484, '?', 354, '@', 467, '\\', 66, '_', 474, 'i', 435};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
#endif // INLINE_IMPL3_H
|
||||
|
|
|
|||
|
|
@ -1,77 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* inline_impl30.h :+: :+: :+: */
|
||||
/* +:+ +:+ +:+ */
|
||||
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
|
||||
/* +#+#+#+#+#+ +#+ */
|
||||
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
|
||||
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
|
||||
/* */
|
||||
/* ************************************************************************** */
|
||||
|
||||
#ifndef INLINE_IMPL30_H
|
||||
# define INLINE_IMPL30_H
|
||||
|
||||
# include "../../../headers/symbols.h"
|
||||
# include "../../../headers/external_scanner_symbol_identifiers.h"
|
||||
# include "../../../headers/field_identifiers.h"
|
||||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map478(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'"', 788, '#', 863, '$', 781, \
|
||||
'\'', 491, '(', 654, '-', 950, '0', 803, '<', 495, '>', \
|
||||
496, '\\', 374, '`', 855, '[', 786, ']', 786, '{', 786, \
|
||||
'}', 786};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map479(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'"', 788, '#', 863, '$', 781, \
|
||||
'\'', 491, '(', 494, '-', 950, '0', 803, '<', 495, '>', \
|
||||
496, '\\', 376, ']', 675, '`', 855, '[', 786, '{', 786, \
|
||||
'}', 786};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map481(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'#', 816, '%', 648, '*', 823, \
|
||||
'+', 833, ',', 558, '-', 830, '/', 643, ':', 764, '=', \
|
||||
826, '?', 836, '@', 821, '[', 673};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map484(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'#', 862, '%', 646, '&', 489, \
|
||||
'*', 637, '+', 629, '-', 632, '/', 641, '<', 613, '>', \
|
||||
618};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map485(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'#', 862, '&', 508, '(', 654, \
|
||||
'<', 611, '>', 618, '[', 674, '\\', 392, '{', 666};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
|
|
@ -1,83 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* inline_impl31.h :+: :+: :+: */
|
||||
/* +:+ +:+ +:+ */
|
||||
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
|
||||
/* +#+#+#+#+#+ +#+ */
|
||||
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
|
||||
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
|
||||
/* */
|
||||
/* ************************************************************************** */
|
||||
|
||||
#ifndef INLINE_IMPL31_H
|
||||
# define INLINE_IMPL31_H
|
||||
|
||||
# include "../../../headers/symbols.h"
|
||||
# include "../../../headers/external_scanner_symbol_identifiers.h"
|
||||
# include "../../../headers/field_identifiers.h"
|
||||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map487(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'#', 862, '&', 489, '<', 612, \
|
||||
'>', 618, '\\', 384, ']', 675, '`', 510, '|', 593, '[', \
|
||||
786, '{', 786, '}', 786};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map527(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 703, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 602, '\'', 491, '(', 654, ')', 655, '-', \
|
||||
950, '0', 803, ';', 555, '<', 609, '=', 952, '>', 617, \
|
||||
'\\', 323, '`', 855, '|', 593, '[', 786, ']', 786, '{', \
|
||||
786, '}', 786};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map528(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 705, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 654, '*', \
|
||||
640, '-', 636, '0', 943, ';', 555, '<', 609, '=', 952, \
|
||||
'>', 617, '?', 761, '@', 942, '\\', 156, '_', 947, '`', \
|
||||
855, '|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map529(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 710, '!', 669, '"', 788, \
|
||||
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
|
||||
945, ';', 555, '<', 612, '>', 618, '?', 760, '@', 941, \
|
||||
'\\', 211, '_', 948, '|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map530(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 712, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 602, '\'', 491, '(', 494, ')', 655, '-', \
|
||||
950, '0', 804, ';', 555, '<', 610, '>', 617, '\\', 326, \
|
||||
'`', 855, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
|
||||
786};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
|
|
@ -1,85 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* inline_impl32.h :+: :+: :+: */
|
||||
/* +:+ +:+ +:+ */
|
||||
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
|
||||
/* +#+#+#+#+#+ +#+ */
|
||||
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
|
||||
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
|
||||
/* */
|
||||
/* ************************************************************************** */
|
||||
|
||||
#ifndef INLINE_IMPL32_H
|
||||
# define INLINE_IMPL32_H
|
||||
|
||||
# include "../../../headers/symbols.h"
|
||||
# include "../../../headers/external_scanner_symbol_identifiers.h"
|
||||
# include "../../../headers/field_identifiers.h"
|
||||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map531(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 714, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
|
||||
640, '-', 636, '0', 943, ';', 555, '<', 609, '=', 952, \
|
||||
'>', 617, '?', 761, '@', 942, '\\', 215, '_', 947, '`', \
|
||||
855, '|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map532(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 716, '!', 669, '"', 788, \
|
||||
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
|
||||
945, ';', 555, '<', 613, '>', 618, '?', 760, '@', 941, \
|
||||
'\\', 218, '_', 948, '|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map533(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 724, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 602, '\'', 491, '(', 494, ')', 655, '-', \
|
||||
950, '0', 803, ';', 555, '<', 609, '>', 617, '\\', 331, \
|
||||
'`', 855, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
|
||||
786};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map534(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 730, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 602, '\'', 491, '(', 494, ')', 655, '-', \
|
||||
950, '0', 803, ';', 555, '<', 610, '>', 617, '\\', 399, \
|
||||
'`', 855, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
|
||||
786};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map535(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 732, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
|
||||
640, '-', 636, '0', 943, ';', 555, '<', 609, '>', 617, \
|
||||
'?', 761, '@', 942, '\\', 166, '_', 947, '`', 855, '|', \
|
||||
593, '[', 786, ']', 786, '{', 786, '}', 786};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
|
|
@ -1,86 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* inline_impl33.h :+: :+: :+: */
|
||||
/* +:+ +:+ +:+ */
|
||||
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
|
||||
/* +#+#+#+#+#+ +#+ */
|
||||
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
|
||||
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
|
||||
/* */
|
||||
/* ************************************************************************** */
|
||||
|
||||
#ifndef INLINE_IMPL33_H
|
||||
# define INLINE_IMPL33_H
|
||||
|
||||
# include "../../../headers/symbols.h"
|
||||
# include "../../../headers/external_scanner_symbol_identifiers.h"
|
||||
# include "../../../headers/field_identifiers.h"
|
||||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map536(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 738, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
|
||||
640, '-', 636, '0', 943, ';', 555, '<', 610, '>', 617, \
|
||||
'?', 761, '@', 942, '\\', 207, '_', 947, '`', 855, '|', \
|
||||
593, '[', 786, ']', 786, '{', 786, '}', 786};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map537(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 739, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 602, '\'', 491, '(', 654, ')', 655, '-', \
|
||||
950, '0', 803, ';', 555, '<', 609, '=', 952, '>', 617, \
|
||||
'\\', 339, '`', 856, '|', 593, '[', 786, ']', 786, '{', \
|
||||
786, '}', 786};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map538(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 751, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 602, '\'', 491, '(', 494, ')', 655, '-', \
|
||||
950, '0', 804, ';', 555, '<', 610, '>', 617, '\\', 349, \
|
||||
'`', 856, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
|
||||
786};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map539(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 752, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 602, '\'', 491, '(', 494, ')', 655, '-', \
|
||||
950, '0', 803, ';', 555, '<', 609, '>', 617, '\\', 350, \
|
||||
'`', 856, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
|
||||
786};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map540(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 754, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 602, '\'', 491, '(', 494, ')', 655, '-', \
|
||||
950, '0', 803, ';', 555, '<', 610, '>', 617, '\\', 354, \
|
||||
'`', 856, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
|
||||
786};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
|
|
@ -1,85 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* inline_impl34.h :+: :+: :+: */
|
||||
/* +:+ +:+ +:+ */
|
||||
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
|
||||
/* +#+#+#+#+#+ +#+ */
|
||||
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
|
||||
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
|
||||
/* */
|
||||
/* ************************************************************************** */
|
||||
|
||||
#ifndef INLINE_IMPL34_H
|
||||
# define INLINE_IMPL34_H
|
||||
|
||||
# include "../../../headers/symbols.h"
|
||||
# include "../../../headers/external_scanner_symbol_identifiers.h"
|
||||
# include "../../../headers/field_identifiers.h"
|
||||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map545(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 670, '"', 788, '#', 816, \
|
||||
'$', 781, '%', 647, '&', 601, '\'', 491, '(', 654, ')', \
|
||||
655, '*', 638, '+', 770, ',', 557, '-', 768, '/', 642, \
|
||||
'0', 944, ':', 765, ';', 554, '<', 607, '=', 563, '>', \
|
||||
616, '?', 761, '@', 942, '[', 674, '\\', 301, ']', 675, \
|
||||
'^', 595, '_', 946, '`', 856, 'e', 956, 'i', 955, '{', \
|
||||
666, '|', 592, '}', 818, '~', 772};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map546(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 672, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 508, '\'', 491, '(', 654, ')', 655, '-', \
|
||||
950, '0', 803, ';', 490, '<', 608, '>', 617, '[', 674, \
|
||||
'\\', 304, '`', 855, '{', 666, '|', 590, ']', 786, '}', \
|
||||
786};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map793(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 669, '"', 788, '#', 816, \
|
||||
'$', 780, '*', 637, '-', 632, '0', 945, '?', 760, '@', \
|
||||
941, '\\', 135, '_', 948};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map794(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 669, '#', 816, '$', 780, \
|
||||
'*', 637, '-', 632, '0', 945, '?', 760, '@', 941, '\\', \
|
||||
136, '_', 948};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map880(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 689, '!', 670, '"', 788, \
|
||||
'#', 816, '$', 781, '%', 649, '&', 601, '\'', 491, '(', \
|
||||
654, ')', 655, '*', 638, '+', 630, '-', 633, '/', 644, \
|
||||
'0', 943, ';', 555, '<', 607, '=', 560, '>', 616, '?', \
|
||||
761, '@', 942, '\\', 14, '^', 596, '_', 947, '`', 855, \
|
||||
'|', 592};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
|
|
@ -1,83 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* inline_impl35.h :+: :+: :+: */
|
||||
/* +:+ +:+ +:+ */
|
||||
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
|
||||
/* +#+#+#+#+#+ +#+ */
|
||||
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
|
||||
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
|
||||
/* */
|
||||
/* ************************************************************************** */
|
||||
|
||||
#ifndef INLINE_IMPL35_H
|
||||
# define INLINE_IMPL35_H
|
||||
|
||||
# include "../../../headers/symbols.h"
|
||||
# include "../../../headers/external_scanner_symbol_identifiers.h"
|
||||
# include "../../../headers/field_identifiers.h"
|
||||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map881(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 692, '!', 669, '"', 788, \
|
||||
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
|
||||
945, ';', 554, '<', 612, '>', 618, '?', 760, '@', 941, \
|
||||
'\\', 81, '_', 948, 'e', 877, '|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map882(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 693, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 654, '*', \
|
||||
640, '-', 636, '0', 943, ';', 554, '<', 609, '=', 952, \
|
||||
'>', 617, '?', 761, '@', 942, '\\', 27, '_', 947, '`', \
|
||||
855, 'e', 871, '|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map883(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 695, '!', 669, '"', 788, \
|
||||
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
|
||||
945, ';', 554, '<', 612, '>', 618, '?', 760, '@', 941, \
|
||||
'\\', 91, '_', 948, '|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map884(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 696, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 654, '*', \
|
||||
640, '-', 636, '0', 943, ';', 554, '<', 609, '=', 952, \
|
||||
'>', 617, '?', 761, '@', 942, '\\', 30, '_', 947, '`', \
|
||||
855, '|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map885(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 698, '!', 669, '"', 788, \
|
||||
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
|
||||
945, ';', 554, '<', 613, '>', 618, '?', 760, '@', 941, \
|
||||
'\\', 183, '_', 948, 'e', 877, '|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
|
|
@ -1,84 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* inline_impl36.h :+: :+: :+: */
|
||||
/* +:+ +:+ +:+ */
|
||||
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
|
||||
/* +#+#+#+#+#+ +#+ */
|
||||
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
|
||||
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
|
||||
/* */
|
||||
/* ************************************************************************** */
|
||||
|
||||
#ifndef INLINE_IMPL36_H
|
||||
# define INLINE_IMPL36_H
|
||||
|
||||
# include "../../../headers/symbols.h"
|
||||
# include "../../../headers/external_scanner_symbol_identifiers.h"
|
||||
# include "../../../headers/field_identifiers.h"
|
||||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map886(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 699, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
|
||||
640, '-', 636, '0', 943, ';', 554, '<', 609, '=', 952, \
|
||||
'>', 617, '?', 761, '@', 942, '\\', 153, '_', 947, '`', \
|
||||
855, 'e', 871, '|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map887(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 701, '!', 669, '"', 788, \
|
||||
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
|
||||
945, ';', 554, '<', 613, '>', 618, '?', 760, '@', 941, \
|
||||
'\\', 185, '_', 948, '|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map888(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 702, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 654, ')', \
|
||||
655, '*', 640, '-', 636, '0', 943, ';', 555, '<', 609, \
|
||||
'=', 952, '>', 617, '?', 761, '@', 942, '\\', 32, '_', \
|
||||
947, '`', 855, '|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map889(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 704, '!', 669, '"', 788, \
|
||||
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
|
||||
945, ';', 555, '<', 612, '>', 618, '?', 760, '@', 941, \
|
||||
'\\', 96, '_', 948, '`', 855, '|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map890(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 705, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 654, '*', \
|
||||
640, '-', 636, '0', 943, ';', 555, '<', 609, '=', 952, \
|
||||
'>', 617, '?', 761, '@', 942, '\\', 156, '_', 947, '`', \
|
||||
855, '|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
|
|
@ -1,83 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* inline_impl37.h :+: :+: :+: */
|
||||
/* +:+ +:+ +:+ */
|
||||
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
|
||||
/* +#+#+#+#+#+ +#+ */
|
||||
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
|
||||
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
|
||||
/* */
|
||||
/* ************************************************************************** */
|
||||
|
||||
#ifndef INLINE_IMPL37_H
|
||||
# define INLINE_IMPL37_H
|
||||
|
||||
# include "../../../headers/symbols.h"
|
||||
# include "../../../headers/external_scanner_symbol_identifiers.h"
|
||||
# include "../../../headers/field_identifiers.h"
|
||||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map891(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 707, '!', 669, '"', 788, \
|
||||
'#', 816, '$', 780, '&', 602, ')', 655, '*', 637, '-', \
|
||||
632, '0', 945, ';', 555, '<', 612, '>', 618, '?', 760, \
|
||||
'@', 941, '\\', 98, '_', 948, '|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map892(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 708, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
|
||||
640, '-', 636, '0', 943, ';', 554, '<', 609, '=', 952, \
|
||||
'>', 617, '?', 761, '@', 942, '\\', 202, '_', 947, '`', \
|
||||
855, '|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map893(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 710, '!', 669, '"', 788, \
|
||||
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
|
||||
945, ';', 555, '<', 612, '>', 618, '?', 760, '@', 941, \
|
||||
'\\', 211, '_', 948, '|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map894(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 711, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, ')', \
|
||||
655, '*', 640, '-', 636, '0', 943, ';', 555, '<', 609, \
|
||||
'=', 952, '>', 617, '?', 761, '@', 942, '\\', 158, '_', \
|
||||
947, '`', 855, '|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map895(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 713, '!', 669, '"', 788, \
|
||||
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
|
||||
945, ';', 555, '<', 613, '>', 618, '?', 760, '@', 941, \
|
||||
'\\', 188, '_', 948, '`', 855, '|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
|
|
@ -1,84 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* inline_impl38.h :+: :+: :+: */
|
||||
/* +:+ +:+ +:+ */
|
||||
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
|
||||
/* +#+#+#+#+#+ +#+ */
|
||||
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
|
||||
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
|
||||
/* */
|
||||
/* ************************************************************************** */
|
||||
|
||||
#ifndef INLINE_IMPL38_H
|
||||
# define INLINE_IMPL38_H
|
||||
|
||||
# include "../../../headers/symbols.h"
|
||||
# include "../../../headers/external_scanner_symbol_identifiers.h"
|
||||
# include "../../../headers/field_identifiers.h"
|
||||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map896(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 714, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
|
||||
640, '-', 636, '0', 943, ';', 555, '<', 609, '=', 952, \
|
||||
'>', 617, '?', 761, '@', 942, '\\', 215, '_', 947, '`', \
|
||||
855, '|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map897(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 716, '!', 669, '"', 788, \
|
||||
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
|
||||
945, ';', 555, '<', 613, '>', 618, '?', 760, '@', 941, \
|
||||
'\\', 218, '_', 948, '|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map898(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 717, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
|
||||
640, '-', 636, '0', 943, ';', 554, '<', 609, '>', 617, \
|
||||
'?', 761, '@', 942, '\\', 37, '_', 947, '`', 855, 'e', \
|
||||
871, '|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map899(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 719, '!', 669, '"', 788, \
|
||||
'#', 816, '$', 780, '&', 602, ')', 655, '*', 637, '-', \
|
||||
632, '0', 945, ';', 555, '<', 613, '>', 618, '?', 760, \
|
||||
'@', 941, '\\', 190, '_', 948, '|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map900(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 720, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
|
||||
640, '-', 636, '0', 943, ';', 554, '<', 610, '>', 617, \
|
||||
'?', 761, '@', 942, '\\', 222, '_', 947, '`', 855, 'e', \
|
||||
871, '|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
|
|
@ -1,83 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* inline_impl39.h :+: :+: :+: */
|
||||
/* +:+ +:+ +:+ */
|
||||
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
|
||||
/* +#+#+#+#+#+ +#+ */
|
||||
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
|
||||
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
|
||||
/* */
|
||||
/* ************************************************************************** */
|
||||
|
||||
#ifndef INLINE_IMPL39_H
|
||||
# define INLINE_IMPL39_H
|
||||
|
||||
# include "../../../headers/symbols.h"
|
||||
# include "../../../headers/external_scanner_symbol_identifiers.h"
|
||||
# include "../../../headers/field_identifiers.h"
|
||||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map901(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 722, '!', 669, '"', 788, \
|
||||
'#', 816, '$', 780, '&', 489, '*', 637, '-', 632, '0', \
|
||||
945, '<', 612, '>', 618, '?', 760, '@', 941, '\\', 106, \
|
||||
'_', 948, '|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map902(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 723, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
|
||||
640, '-', 636, '0', 943, ';', 554, '<', 609, '>', 617, \
|
||||
'?', 761, '@', 942, '\\', 43, '_', 947, '`', 855, '|', \
|
||||
593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map903(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 725, '!', 669, '"', 788, \
|
||||
'#', 816, '$', 780, '&', 489, '*', 637, '-', 632, '0', \
|
||||
945, '<', 613, '>', 618, '?', 760, '@', 941, '\\', 193, \
|
||||
'_', 948, '|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map904(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 726, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, ')', \
|
||||
655, '*', 640, '-', 636, '0', 943, ';', 555, '<', 609, \
|
||||
'>', 617, '?', 761, '@', 942, '\\', 46, '_', 947, '`', \
|
||||
855, '|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map905(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 728, '!', 669, '"', 788, \
|
||||
'#', 816, '$', 780, '&', 489, '*', 637, '-', 632, '0', \
|
||||
945, '<', 611, '>', 618, '?', 760, '@', 941, '\\', 213, \
|
||||
'_', 948, '|', 516};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
|
|
@ -19,66 +19,65 @@
|
|||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map247(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map116(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 705, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 654, '*', \
|
||||
640, '-', 636, '0', 943, ';', 555, '<', 609, '=', 952, \
|
||||
'>', 617, '?', 761, '@', 942, '\\', 156, '_', 947, '`', \
|
||||
855, '|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'\n', 292, '"', 373, '#', 421, \
|
||||
'$', 370, '&', 336, '\'', 201, '-', 476, '0', 386, ';', \
|
||||
483, '<', 254, '>', 257, '\\', 140, '`', 416, 'e', 425, \
|
||||
'|', 235, '[', 372, ']', 372, '{', 372, '}', 372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map248(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map117(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 706, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
|
||||
804, ';', 554, '<', 610, '>', 617, '\\', 324, '`', 855, \
|
||||
'e', 866, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
|
||||
786};
|
||||
static uint32_t map[] = {'\n', 293, '!', 248, '"', 373, \
|
||||
'#', 396, '$', 370, '&', 199, '\'', 201, '*', 348, '-', \
|
||||
344, '0', 469, '<', 252, '>', 257, '?', 355, '@', 468, \
|
||||
'\\', 93, '_', 473, '`', 416, '|', 212, '[', 372, ']', \
|
||||
372, '{', 372, '}', 372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map249(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map118(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 707, '!', 669, '"', 788, \
|
||||
'#', 816, '$', 780, '&', 602, ')', 655, '*', 637, '-', \
|
||||
632, '0', 945, ';', 555, '<', 612, '>', 618, '?', 760, \
|
||||
'@', 941, '\\', 98, '_', 948, '|', 593};
|
||||
static uint32_t map[] = {'\n', 294, '"', 373, '#', 421, \
|
||||
'$', 370, '&', 336, '\'', 201, '-', 476, '0', 386, ';', \
|
||||
483, '<', 254, '>', 257, '\\', 141, '`', 416, '|', 235, \
|
||||
'[', 372, ']', 372, '{', 372, '}', 372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map250(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map119(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 708, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
|
||||
640, '-', 636, '0', 943, ';', 554, '<', 609, '=', 952, \
|
||||
'>', 617, '?', 761, '@', 942, '\\', 202, '_', 947, '`', \
|
||||
855, '|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'\n', 295, '!', 248, '"', 373, \
|
||||
'#', 396, '$', 370, '&', 333, '\'', 201, '*', 348, '-', \
|
||||
344, '0', 469, ';', 484, '?', 355, '@', 468, '\\', 57, \
|
||||
'_', 473, '`', 416, '[', 372, ']', 372, '{', 372, '}', \
|
||||
372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map251(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map120(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 709, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
|
||||
804, ';', 554, '<', 610, '>', 617, '\\', 325, '`', 855, \
|
||||
'|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'\n', 296, '"', 373, '#', 421, \
|
||||
'$', 370, '&', 336, '\'', 201, '(', 232, '-', 476, '0', \
|
||||
385, ';', 483, '<', 254, '>', 257, '\\', 142, '`', 416, \
|
||||
'|', 235, '[', 372, ']', 372, '{', 372, '}', 372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
#endif // INLINE_IMPL4_H
|
||||
|
|
|
|||
|
|
@ -1,85 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* inline_impl40.h :+: :+: :+: */
|
||||
/* +:+ +:+ +:+ */
|
||||
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
|
||||
/* +#+#+#+#+#+ +#+ */
|
||||
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
|
||||
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
|
||||
/* */
|
||||
/* ************************************************************************** */
|
||||
|
||||
#ifndef INLINE_IMPL40_H
|
||||
# define INLINE_IMPL40_H
|
||||
|
||||
# include "../../../headers/symbols.h"
|
||||
# include "../../../headers/external_scanner_symbol_identifiers.h"
|
||||
# include "../../../headers/field_identifiers.h"
|
||||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map906(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 729, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
|
||||
640, '-', 636, '0', 943, ';', 554, '<', 610, '>', 617, \
|
||||
'?', 761, '@', 942, '\\', 226, '_', 947, '`', 855, '|', \
|
||||
593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map907(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 731, '!', 669, '"', 788, \
|
||||
'#', 816, '$', 780, '&', 599, '*', 637, '-', 632, '0', \
|
||||
945, ';', 555, '?', 760, '@', 941, '\\', 128, '_', 948, \
|
||||
'i', 876};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map908(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 732, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
|
||||
640, '-', 636, '0', 943, ';', 555, '<', 609, '>', 617, \
|
||||
'?', 761, '@', 942, '\\', 166, '_', 947, '`', 855, '|', \
|
||||
593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map909(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 734, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 489, '\'', 491, '(', 654, '*', \
|
||||
640, '-', 636, '0', 943, '<', 609, '=', 952, '>', 617, \
|
||||
'?', 761, '@', 942, '\\', 48, '_', 947, '`', 855, '|', \
|
||||
593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map910(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 736, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, ')', \
|
||||
655, '*', 640, '-', 636, '0', 943, ';', 555, '<', 610, \
|
||||
'>', 617, '?', 761, '@', 942, '\\', 228, '_', 947, '`', \
|
||||
855, '|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
|
|
@ -1,83 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* inline_impl41.h :+: :+: :+: */
|
||||
/* +:+ +:+ +:+ */
|
||||
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
|
||||
/* +#+#+#+#+#+ +#+ */
|
||||
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
|
||||
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
|
||||
/* */
|
||||
/* ************************************************************************** */
|
||||
|
||||
#ifndef INLINE_IMPL41_H
|
||||
# define INLINE_IMPL41_H
|
||||
|
||||
# include "../../../headers/symbols.h"
|
||||
# include "../../../headers/external_scanner_symbol_identifiers.h"
|
||||
# include "../../../headers/field_identifiers.h"
|
||||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map911(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 738, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
|
||||
640, '-', 636, '0', 943, ';', 555, '<', 610, '>', 617, \
|
||||
'?', 761, '@', 942, '\\', 207, '_', 947, '`', 855, '|', \
|
||||
593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map912(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 740, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 489, '\'', 491, '(', 494, '*', \
|
||||
640, '-', 636, '0', 943, '<', 609, '=', 952, '>', 617, \
|
||||
'?', 761, '@', 942, '\\', 168, '_', 947, '`', 855, '|', \
|
||||
593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map913(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 742, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 489, '\'', 491, '(', 494, '*', \
|
||||
640, '-', 636, '0', 943, '<', 609, '>', 617, '?', 761, \
|
||||
'@', 942, '\\', 58, '_', 947, '`', 855, '|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map914(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 744, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 489, '\'', 491, '(', 494, '*', \
|
||||
640, '-', 636, '0', 943, '<', 610, '>', 617, '?', 761, \
|
||||
'@', 942, '\\', 233, '_', 947, '`', 855, '|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map915(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 746, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 489, '\'', 491, '(', 494, '*', \
|
||||
640, '-', 636, '0', 943, '<', 608, '>', 617, '?', 761, \
|
||||
'@', 942, '\\', 176, '_', 947, '`', 855, '|', 516};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
|
|
@ -1,82 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* inline_impl42.h :+: :+: :+: */
|
||||
/* +:+ +:+ +:+ */
|
||||
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
|
||||
/* +#+#+#+#+#+ +#+ */
|
||||
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
|
||||
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
|
||||
/* */
|
||||
/* ************************************************************************** */
|
||||
|
||||
#ifndef INLINE_IMPL42_H
|
||||
# define INLINE_IMPL42_H
|
||||
|
||||
# include "../../../headers/symbols.h"
|
||||
# include "../../../headers/external_scanner_symbol_identifiers.h"
|
||||
# include "../../../headers/field_identifiers.h"
|
||||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map916(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 748, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 599, '\'', 491, '(', 494, '*', \
|
||||
640, '-', 636, '0', 943, ';', 555, '<', 495, '>', 496, \
|
||||
'?', 761, '@', 942, '\\', 100, '_', 947, '`', 855};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map917(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 750, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '\'', 491, '(', 494, '*', 640, '-', \
|
||||
636, '0', 943, '<', 495, '>', 496, '?', 761, '@', 942, \
|
||||
'\\', 112, '_', 947, '`', 855};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map918(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 670, '"', 788, '#', 816, \
|
||||
'$', 781, '%', 649, '&', 601, '\'', 491, '(', 654, '*', \
|
||||
638, '+', 630, '-', 633, '/', 644, '0', 943, '<', 607, \
|
||||
'=', 560, '>', 616, '?', 761, '@', 942, '\\', 19, ']', \
|
||||
675, '^', 596, '_', 947, '`', 855, '|', 592};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map919(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
|
||||
'$', 781, '&', 508, '\'', 491, '(', 494, '*', 640, '-', \
|
||||
636, '0', 943, '<', 608, '>', 617, '?', 761, '@', 942, \
|
||||
'\\', 74, '_', 947, '`', 855};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map920(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
|
||||
'$', 781, '&', 489, '\'', 491, '(', 654, '*', 640, '-', \
|
||||
636, '0', 943, '<', 609, '=', 952, '>', 617, '?', 761, \
|
||||
'@', 942, '\\', 51, '_', 947, '`', 855, '|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
|
|
@ -1,81 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* inline_impl43.h :+: :+: :+: */
|
||||
/* +:+ +:+ +:+ */
|
||||
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
|
||||
/* +#+#+#+#+#+ +#+ */
|
||||
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
|
||||
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
|
||||
/* */
|
||||
/* ************************************************************************** */
|
||||
|
||||
#ifndef INLINE_IMPL43_H
|
||||
# define INLINE_IMPL43_H
|
||||
|
||||
# include "../../../headers/symbols.h"
|
||||
# include "../../../headers/external_scanner_symbol_identifiers.h"
|
||||
# include "../../../headers/field_identifiers.h"
|
||||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map921(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
|
||||
'$', 781, '&', 489, '\'', 491, '(', 494, '*', 640, '-', \
|
||||
636, '0', 943, '<', 609, '=', 952, '>', 617, '?', 761, \
|
||||
'@', 942, '\\', 171, '_', 947, '`', 855, '|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map922(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
|
||||
'$', 781, '&', 489, '\'', 491, '(', 494, '*', 640, '-', \
|
||||
636, '0', 943, '<', 609, '>', 617, '?', 761, '@', 942, \
|
||||
'\\', 55, ']', 675, '_', 947, '`', 855, '|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map923(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
|
||||
'$', 781, '&', 489, '\'', 491, '(', 494, '*', 640, '-', \
|
||||
636, '0', 943, '<', 609, '>', 617, '?', 761, '@', 942, \
|
||||
'\\', 62, '_', 947, '`', 855, '|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map924(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
|
||||
'$', 781, '&', 489, '\'', 491, '(', 494, '*', 640, '-', \
|
||||
636, '0', 943, '<', 610, '>', 617, '?', 761, '@', 942, \
|
||||
'\\', 231, ']', 675, '_', 947, '`', 855, '|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map925(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
|
||||
'$', 781, '&', 489, '\'', 491, '(', 494, '*', 640, '-', \
|
||||
636, '0', 943, '<', 610, '>', 617, '?', 761, '@', 942, \
|
||||
'\\', 235, '_', 947, '`', 855, '|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
|
|
@ -1,85 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* inline_impl44.h :+: :+: :+: */
|
||||
/* +:+ +:+ +:+ */
|
||||
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
|
||||
/* +#+#+#+#+#+ +#+ */
|
||||
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
|
||||
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
|
||||
/* */
|
||||
/* ************************************************************************** */
|
||||
|
||||
#ifndef INLINE_IMPL44_H
|
||||
# define INLINE_IMPL44_H
|
||||
|
||||
# include "../../../headers/symbols.h"
|
||||
# include "../../../headers/external_scanner_symbol_identifiers.h"
|
||||
# include "../../../headers/field_identifiers.h"
|
||||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map926(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 672, '"', 788, '#', 816, \
|
||||
'$', 781, '\'', 491, '(', 494, ')', 655, '*', 640, '-', \
|
||||
636, '0', 943, '<', 495, '>', 496, '?', 761, '@', 942, \
|
||||
'\\', 110, '_', 947, '`', 855};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map927(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 671, '"', 788, '#', 816, \
|
||||
'$', 780, '%', 650, '&', 600, ')', 655, '*', 639, '+', \
|
||||
631, '-', 634, '/', 645, '0', 945, '<', 615, '=', 562, \
|
||||
'>', 620, '?', 760, '@', 941, '\\', 67, '^', 597, '_', \
|
||||
948, '|', 594};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map928(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 671, '"', 788, '#', 816, \
|
||||
'$', 780, '%', 650, '&', 600, ')', 499, '*', 639, '+', \
|
||||
631, '-', 634, '/', 645, '0', 945, '<', 615, '=', 562, \
|
||||
'>', 620, '?', 760, '@', 941, '\\', 181, '^', 597, '_', \
|
||||
948, '|', 594};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map929(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 671, '"', 788, '#', 816, \
|
||||
'$', 780, '%', 650, '&', 600, '*', 639, '+', 631, '-', \
|
||||
634, '/', 645, '0', 945, ':', 762, '<', 615, '=', 562, \
|
||||
'>', 620, '?', 760, '@', 941, '\\', 64, '^', 597, '_', \
|
||||
948, '|', 594};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map930(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 671, '"', 788, '#', 816, \
|
||||
'$', 780, '%', 650, '&', 600, '*', 639, '+', 631, '-', \
|
||||
634, '/', 645, '0', 945, '<', 615, '=', 562, '>', 620, \
|
||||
'?', 760, '@', 941, '\\', 60, ']', 675, '^', 597, '_', \
|
||||
948, '|', 594};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
|
|
@ -1,83 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* inline_impl45.h :+: :+: :+: */
|
||||
/* +:+ +:+ +:+ */
|
||||
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
|
||||
/* +#+#+#+#+#+ +#+ */
|
||||
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
|
||||
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
|
||||
/* */
|
||||
/* ************************************************************************** */
|
||||
|
||||
#ifndef INLINE_IMPL45_H
|
||||
# define INLINE_IMPL45_H
|
||||
|
||||
# include "../../../headers/symbols.h"
|
||||
# include "../../../headers/external_scanner_symbol_identifiers.h"
|
||||
# include "../../../headers/field_identifiers.h"
|
||||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map931(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 671, '"', 788, '#', 816, \
|
||||
'$', 780, '%', 650, '&', 600, '*', 639, '+', 631, '-', \
|
||||
634, '/', 645, '0', 945, '<', 615, '=', 562, '>', 620, \
|
||||
'?', 760, '@', 941, '\\', 178, ']', 509, '^', 597, '_', \
|
||||
948, '|', 594};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map932(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 671, '"', 788, '#', 816, \
|
||||
'$', 780, '%', 650, '&', 600, '*', 639, '+', 631, '-', \
|
||||
634, '/', 645, '0', 945, '<', 615, '=', 562, '>', 620, \
|
||||
'?', 760, '@', 941, '\\', 69, '^', 597, '_', 948, '|', \
|
||||
594};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map933(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 669, '"', 788, '#', 816, \
|
||||
'$', 780, '&', 489, '*', 637, '-', 632, '0', 945, '<', \
|
||||
612, '>', 618, '?', 760, '@', 941, '\\', 108, ']', 675, \
|
||||
'_', 948, '|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map934(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 669, '"', 788, '#', 816, \
|
||||
'$', 780, '&', 489, '*', 637, '-', 632, '0', 945, '<', \
|
||||
612, '>', 618, '?', 760, '@', 941, '\\', 114, '_', 948, \
|
||||
'|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map935(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 669, '"', 788, '#', 816, \
|
||||
'$', 780, '&', 489, '*', 637, '-', 632, '0', 945, '<', \
|
||||
613, '>', 618, '?', 760, '@', 941, '\\', 195, ']', 675, \
|
||||
'_', 948, '|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
|
|
@ -1,66 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* inline_impl46.h :+: :+: :+: */
|
||||
/* +:+ +:+ +:+ */
|
||||
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
|
||||
/* +#+#+#+#+#+ +#+ */
|
||||
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
|
||||
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
|
||||
/* */
|
||||
/* ************************************************************************** */
|
||||
|
||||
#ifndef INLINE_IMPL46_H
|
||||
# define INLINE_IMPL46_H
|
||||
|
||||
# include "../../../headers/symbols.h"
|
||||
# include "../../../headers/external_scanner_symbol_identifiers.h"
|
||||
# include "../../../headers/field_identifiers.h"
|
||||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map936(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 669, '"', 788, '#', 816, \
|
||||
'$', 780, '&', 489, '*', 637, '-', 632, '0', 945, '<', \
|
||||
613, '>', 618, '?', 760, '@', 941, '\\', 197, '_', 948, \
|
||||
'|', 593};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map937(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 669, '"', 788, '#', 816, \
|
||||
'$', 780, ')', 655, '*', 637, '-', 632, '0', 945, '?', \
|
||||
760, '@', 941, '\\', 132, '_', 948, '|', 590};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map938(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 669, '"', 788, '#', 816, \
|
||||
'$', 780, '*', 637, '-', 632, '0', 945, '?', 760, '@', \
|
||||
941, '\\', 134, '_', 948};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map939(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'!', 669, '#', 816, '$', 780, \
|
||||
'*', 637, '-', 632, '0', 945, '?', 760, '@', 941, '\\', \
|
||||
138, '_', 948};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
|
|
@ -19,67 +19,65 @@
|
|||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map252(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map121(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 710, '!', 669, '"', 788, \
|
||||
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
|
||||
945, ';', 555, '<', 612, '>', 618, '?', 760, '@', 941, \
|
||||
'\\', 211, '_', 948, '|', 593};
|
||||
static uint32_t map[] = {'\n', 297, '!', 248, '"', 373, \
|
||||
'#', 396, '$', 370, '\'', 201, '*', 348, '-', 344, '0', \
|
||||
469, '?', 355, '@', 468, '\\', 63, '_', 473, '`', 416, \
|
||||
'[', 372, ']', 372, '{', 372, '}', 372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map253(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map122(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 711, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, ')', \
|
||||
655, '*', 640, '-', 636, '0', 943, ';', 555, '<', 609, \
|
||||
'=', 952, '>', 617, '?', 761, '@', 942, '\\', 158, '_', \
|
||||
947, '`', 855, '|', 593, '[', 786, ']', 786, '{', 786, \
|
||||
'}', 786};
|
||||
static uint32_t map[] = {'\n', 298, '"', 373, '#', 421, \
|
||||
'$', 370, '&', 336, '\'', 201, ')', 237, '-', 476, '0', \
|
||||
386, ';', 484, '<', 254, '>', 257, '\\', 143, '`', 416, \
|
||||
'|', 235, '[', 372, ']', 372, '{', 372, '}', 372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map254(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map123(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 712, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 602, '\'', 491, '(', 494, ')', 655, '-', \
|
||||
950, '0', 804, ';', 555, '<', 610, '>', 617, '\\', 326, \
|
||||
'`', 855, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
|
||||
786};
|
||||
static uint32_t map[] = {'\n', 299, '"', 373, '#', 421, \
|
||||
'$', 370, '&', 336, '\'', 201, '(', 232, ')', 237, '-', \
|
||||
476, '0', 385, ';', 484, '<', 254, '>', 257, '\\', 144, \
|
||||
'`', 416, '|', 235, '[', 372, ']', 372, '{', 372, '}', \
|
||||
372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map255(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map124(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 713, '!', 669, '"', 788, \
|
||||
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
|
||||
945, ';', 555, '<', 613, '>', 618, '?', 760, '@', 941, \
|
||||
'\\', 188, '_', 948, '`', 855, '|', 593};
|
||||
static uint32_t map[] = {'\n', 300, '"', 373, '#', 421, \
|
||||
'$', 370, '&', 336, '\'', 201, '-', 476, '0', 386, ';', \
|
||||
483, '<', 254, '>', 257, '\\', 147, '`', 417, 'e', 425, \
|
||||
'|', 235, '[', 372, ']', 372, '{', 372, '}', 372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map256(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map125(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 714, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
|
||||
640, '-', 636, '0', 943, ';', 555, '<', 609, '=', 952, \
|
||||
'>', 617, '?', 761, '@', 942, '\\', 215, '_', 947, '`', \
|
||||
855, '|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'\n', 301, '"', 373, '#', 421, \
|
||||
'$', 370, '&', 336, '\'', 201, '(', 232, '-', 476, '0', \
|
||||
385, ';', 483, '<', 254, '>', 257, '\\', 148, '`', 417, \
|
||||
'e', 480, '|', 235, '[', 372, ']', 372, '{', 372, '}', \
|
||||
372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
#endif // INLINE_IMPL5_H
|
||||
|
|
|
|||
|
|
@ -19,65 +19,64 @@
|
|||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map257(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map126(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 715, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
|
||||
803, ';', 554, '<', 609, '>', 617, '\\', 327, '`', 855, \
|
||||
'e', 956, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
|
||||
786};
|
||||
static uint32_t map[] = {'\n', 302, '"', 373, '#', 421, \
|
||||
'$', 370, '&', 336, '\'', 201, '(', 232, '-', 476, '0', \
|
||||
385, ';', 483, '<', 254, '>', 257, '\\', 149, '`', 417, \
|
||||
'|', 235, '[', 372, ']', 372, '{', 372, '}', 372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map258(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map127(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 716, '!', 669, '"', 788, \
|
||||
'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
|
||||
945, ';', 555, '<', 613, '>', 618, '?', 760, '@', 941, \
|
||||
'\\', 218, '_', 948, '|', 593};
|
||||
static uint32_t map[] = {'\n', 303, '"', 373, '#', 421, \
|
||||
'$', 370, '&', 336, '\'', 201, '-', 476, '0', 386, ';', \
|
||||
483, '<', 254, '>', 257, '\\', 150, '`', 417, '|', 235, \
|
||||
'[', 372, ']', 372, '{', 372, '}', 372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map259(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map128(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 717, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
|
||||
640, '-', 636, '0', 943, ';', 554, '<', 609, '>', 617, \
|
||||
'?', 761, '@', 942, '\\', 37, '_', 947, '`', 855, 'e', \
|
||||
871, '|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'\n', 304, '"', 373, '#', 421, \
|
||||
'$', 370, '&', 336, '\'', 201, ')', 237, '-', 476, '0', \
|
||||
386, ';', 484, '<', 254, '>', 257, '\\', 151, '`', 417, \
|
||||
'|', 235, '[', 372, ']', 372, '{', 372, '}', 372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map260(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map129(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 718, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
|
||||
803, ';', 554, '<', 609, '>', 617, '\\', 328, '`', 855, \
|
||||
'|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'\n', 305, '"', 373, '#', 421, \
|
||||
'$', 370, '&', 336, '\'', 201, '(', 232, ')', 237, '-', \
|
||||
476, '0', 385, ';', 484, '<', 254, '>', 257, '\\', 152, \
|
||||
'`', 417, '|', 235, '[', 372, ']', 372, '{', 372, '}', \
|
||||
372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map261(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map130(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 719, '!', 669, '"', 788, \
|
||||
'#', 816, '$', 780, '&', 602, ')', 655, '*', 637, '-', \
|
||||
632, '0', 945, ';', 555, '<', 613, '>', 618, '?', 760, \
|
||||
'@', 941, '\\', 190, '_', 948, '|', 593};
|
||||
static uint32_t map[] = {'\n', 306, '"', 373, '#', 421, \
|
||||
'$', 370, '&', 333, '\'', 201, '(', 232, '-', 476, '0', \
|
||||
385, ';', 484, '\\', 156, '`', 416, 'e', 480, '[', 372, \
|
||||
']', 372, '{', 372, '}', 372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
#endif // INLINE_IMPL6_H
|
||||
|
|
|
|||
|
|
@ -19,67 +19,68 @@
|
|||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map262(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map131(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 720, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
|
||||
640, '-', 636, '0', 943, ';', 554, '<', 610, '>', 617, \
|
||||
'?', 761, '@', 942, '\\', 222, '_', 947, '`', 855, 'e', \
|
||||
871, '|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'\n', 307, '"', 373, '#', 421, \
|
||||
'$', 370, '&', 333, '\'', 201, '-', 476, '0', 385, ';', \
|
||||
484, '\\', 161, '`', 416, '[', 372, ']', 372, '{', 372, \
|
||||
'}', 372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map263(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map132(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 721, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
|
||||
803, ';', 554, '<', 610, '>', 617, '\\', 397, '`', 855, \
|
||||
'e', 956, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
|
||||
786};
|
||||
static uint32_t map[] = {'\n', 308, '"', 373, '#', 421, \
|
||||
'$', 370, '&', 333, '\'', 201, '-', 476, '0', 385, ';', \
|
||||
484, '\\', 163, '`', 417, '[', 372, ']', 372, '{', 372, \
|
||||
'}', 372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map264(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map170(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 722, '!', 669, '"', 788, \
|
||||
'#', 816, '$', 780, '&', 489, '*', 637, '-', 632, '0', \
|
||||
945, '<', 612, '>', 618, '?', 760, '@', 941, '\\', 106, \
|
||||
'_', 948, '|', 593};
|
||||
static uint32_t map[] = {'!', 248, '"', 373, '#', 396, \
|
||||
'$', 370, '%', 351, '&', 335, '\'', 201, '(', 232, ')', \
|
||||
237, '*', 346, '+', 363, ',', 311, '-', 361, '/', 349, \
|
||||
'0', 470, ':', 358, ';', 483, '<', 253, '=', 251, '>', \
|
||||
256, '?', 355, '@', 468, '[', 372, '\\', 133, ']', 485, \
|
||||
'^', 331, '_', 472, '`', 417, 'e', 480, 'i', 479, '{', \
|
||||
242, '|', 234, '}', 398, '~', 365};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map265(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map171(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 723, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
|
||||
640, '-', 636, '0', 943, ';', 554, '<', 609, '>', 617, \
|
||||
'?', 761, '@', 942, '\\', 43, '_', 947, '`', 855, '|', \
|
||||
593, '[', 786, ']', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'!', 248, '"', 373, '#', 396, \
|
||||
'$', 370, '&', 199, '\'', 201, '(', 232, '*', 348, '-', \
|
||||
344, '0', 469, '<', 254, '>', 257, '?', 355, '@', 468, \
|
||||
'\\', 31, '_', 473, '`', 416, '|', 235, '[', 372, ']', \
|
||||
372, '{', 372, '}', 372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map266(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map172(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 724, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 602, '\'', 491, '(', 494, ')', 655, '-', \
|
||||
950, '0', 803, ';', 555, '<', 609, '>', 617, '\\', 331, \
|
||||
'`', 855, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
|
||||
786};
|
||||
static uint32_t map[] = {'!', 248, '"', 373, '#', 396, \
|
||||
'$', 370, '&', 199, '\'', 201, '*', 348, '-', 344, '0', \
|
||||
469, '<', 254, '>', 257, '?', 355, '@', 468, '\\', 36, \
|
||||
'_', 473, '`', 416, '|', 235, '[', 372, ']', 372, '{', \
|
||||
372, '}', 372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
#endif // INLINE_IMPL7_H
|
||||
|
|
|
|||
|
|
@ -19,65 +19,65 @@
|
|||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map267(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map173(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 725, '!', 669, '"', 788, \
|
||||
'#', 816, '$', 780, '&', 489, '*', 637, '-', 632, '0', \
|
||||
945, '<', 613, '>', 618, '?', 760, '@', 941, '\\', 193, \
|
||||
'_', 948, '|', 593};
|
||||
static uint32_t map[] = {'!', 248, '"', 373, '#', 396, \
|
||||
'$', 370, '&', 206, '\'', 201, '*', 348, '-', 344, '0', \
|
||||
469, '<', 252, '>', 257, '?', 355, '@', 468, '\\', 38, \
|
||||
'_', 473, '`', 416, '[', 372, ']', 372, '{', 372, '}', \
|
||||
372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map268(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map174(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 726, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, ')', \
|
||||
655, '*', 640, '-', 636, '0', 943, ';', 555, '<', 609, \
|
||||
'>', 617, '?', 761, '@', 942, '\\', 46, '_', 947, '`', \
|
||||
855, '|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'!', 248, '"', 373, '#', 421, \
|
||||
'$', 370, '&', 199, '\'', 201, '(', 232, ')', 237, '-', \
|
||||
476, '0', 385, ';', 200, '<', 254, '>', 257, '\\', 135, \
|
||||
'`', 416, '{', 242, '|', 235, '[', 372, ']', 372, '}', \
|
||||
372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map269(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map175(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 727, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
|
||||
803, ';', 554, '<', 610, '>', 617, '\\', 398, '`', 855, \
|
||||
'|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'!', 248, '"', 373, '#', 421, \
|
||||
'$', 370, '&', 206, '\'', 201, '(', 232, ')', 237, '-', \
|
||||
476, '0', 385, ';', 200, '<', 252, '>', 257, '\\', 137, \
|
||||
'`', 416, 'e', 480, '{', 242, '|', 233, '[', 372, ']', \
|
||||
372, '}', 372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map270(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map176(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 728, '!', 669, '"', 788, \
|
||||
'#', 816, '$', 780, '&', 489, '*', 637, '-', 632, '0', \
|
||||
945, '<', 611, '>', 618, '?', 760, '@', 941, '\\', 213, \
|
||||
'_', 948, '|', 516};
|
||||
static uint32_t map[] = {'!', 248, '"', 373, '#', 421, \
|
||||
'$', 370, '&', 206, '\'', 201, '(', 232, '-', 476, '0', \
|
||||
385, '<', 252, '>', 257, '\\', 138, '`', 416, '{', 242, \
|
||||
'}', 243, '[', 372, ']', 372};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map271(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map177(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 729, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
|
||||
640, '-', 636, '0', 943, ';', 554, '<', 610, '>', 617, \
|
||||
'?', 761, '@', 942, '\\', 226, '_', 947, '`', 855, '|', \
|
||||
593, '[', 786, ']', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'!', 247, '"', 373, '#', 396, \
|
||||
'$', 369, '*', 345, '-', 342, '0', 471, '?', 354, '@', \
|
||||
467, '\\', 69, '_', 474};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
#endif // INLINE_IMPL8_H
|
||||
|
|
|
|||
|
|
@ -19,66 +19,57 @@
|
|||
# include "../../../headers/constants.h"
|
||||
# include "../../../../parse_types.h"
|
||||
|
||||
static inline bool lex_normal_map272(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map178(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 730, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 602, '\'', 491, '(', 494, ')', 655, '-', \
|
||||
950, '0', 803, ';', 555, '<', 610, '>', 617, '\\', 399, \
|
||||
'`', 855, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
|
||||
786};
|
||||
static uint32_t map[] = {'!', 247, '"', 373, '#', 421, \
|
||||
'$', 371, '(', 232, ')', 237, '+', 364, '-', 362, '0', \
|
||||
390, '=', 249};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map273(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map179(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 731, '!', 669, '"', 788, \
|
||||
'#', 816, '$', 780, '&', 599, '*', 637, '-', 632, '0', \
|
||||
945, ';', 555, '?', 760, '@', 941, '\\', 128, '_', 948, \
|
||||
'i', 876};
|
||||
static uint32_t map[] = {'!', 247, '#', 396, '$', 369, \
|
||||
'&', 199, '*', 345, '-', 342, '0', 471, '<', 254, '>', \
|
||||
257, '?', 354, '@', 467, '\\', 54, '_', 474, '|', 235};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map274(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map180(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 732, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
|
||||
640, '-', 636, '0', 943, ';', 555, '<', 609, '>', 617, \
|
||||
'?', 761, '@', 942, '\\', 166, '_', 947, '`', 855, '|', \
|
||||
593, '[', 786, ']', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'!', 247, '#', 396, '$', 369, \
|
||||
')', 237, '*', 345, '-', 342, '0', 471, '?', 354, '@', \
|
||||
467, '\\', 71, '_', 474, '|', 233};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map275(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map181(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 733, '"', 788, '#', 862, \
|
||||
'$', 781, '&', 489, '\'', 491, '(', 494, '-', 950, '0', \
|
||||
803, '<', 608, '>', 617, '\\', 333, '`', 855, '|', 593, \
|
||||
'[', 786, ']', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'!', 247, '#', 396, '$', 369, \
|
||||
'*', 345, '-', 342, '0', 471, '?', 354, '@', 467, '\\', \
|
||||
73, '_', 474};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
|
||||
static inline bool lex_normal_map276(t_lexer *lexer, \
|
||||
static inline bool lex_normal_map182(t_lexer *lexer, \
|
||||
t_lexer_state *s)
|
||||
{
|
||||
static uint32_t map[] = {'\n', 734, '!', 672, '"', 788, \
|
||||
'#', 816, '$', 781, '&', 489, '\'', 491, '(', 654, '*', \
|
||||
640, '-', 636, '0', 943, '<', 609, '=', 952, '>', 617, \
|
||||
'?', 761, '@', 942, '\\', 48, '_', 947, '`', 855, '|', \
|
||||
593, '[', 786, ']', 786, '{', 786, '}', 786};
|
||||
static uint32_t map[] = {'!', 247, '#', 396, '$', 369, \
|
||||
'*', 345, '-', 342, '0', 471, '?', 354, '@', 467};
|
||||
|
||||
return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
|
||||
lexer, s));
|
||||
}
|
||||
#endif
|
||||
#endif // INLINE_IMPL9_H
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
/* 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 */
|
||||
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
|
||||
/* */
|
||||
/* ************************************************************************** */
|
||||
|
||||
|
|
@ -22,13 +22,6 @@
|
|||
# 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);
|
||||
|
|
@ -515,479 +508,6 @@ 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
|
||||
#endif // LEX_NORMAL_FUNCS_H
|
||||
|
|
|
|||
|
|
@ -19,7 +19,7 @@ bool lex_normal_call(t_lexer *lexer, t_lexer_state *s)
|
|||
t_lex_normal_array *t;
|
||||
|
||||
t = create_lex_normal();
|
||||
if (s->state < 959)
|
||||
if (s->state < 486)
|
||||
{
|
||||
return (((bool (*)(t_lexer *, t_lexer_state \
|
||||
*))(t->a[s->state]))(lexer, s));
|
||||
|
|
|
|||
|
|
@ -15,41 +15,41 @@
|
|||
bool lex_normal_s0(t_lexer *lexer, t_lexer_state *s)
|
||||
{
|
||||
if (s->eof)
|
||||
return (lex_advance(547, lexer, s));
|
||||
return (lex_advance(223, 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));
|
||||
return (lex_skip(221, lexer, s));
|
||||
if (s->lookahead != 0)
|
||||
return (lex_advance(958, lexer, s));
|
||||
return (lex_advance(482, 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_skip(170, 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_skip(174, 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_skip(175, 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_skip(176, lexer, s));
|
||||
return (lex_end_state(lexer, s));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -27,29 +27,37 @@ bool lex_normal_s6(t_lexer *lexer, t_lexer_state *s)
|
|||
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_advance(387, lexer, s));
|
||||
if ((s->lookahead != 0 && (s->lookahead > '&' && \
|
||||
s->lookahead < ')')))
|
||||
return (lex_advance(482, 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_skip(116, 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_advance(439, 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_advance(439, lexer, s));
|
||||
if (s->lookahead == '\r')
|
||||
return (lex_advance(8, lexer, s));
|
||||
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
|
||||
s->lookahead == ' '))
|
||||
return (lex_skip(80, lexer, s));
|
||||
if (s->lookahead != 0)
|
||||
return (lex_advance(482, lexer, s));
|
||||
return (lex_end_state(lexer, s));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -15,41 +15,44 @@
|
|||
bool lex_normal_s50(t_lexer *lexer, t_lexer_state *s)
|
||||
{
|
||||
if (s->lookahead == '\n')
|
||||
return (lex_advance(920, lexer, s));
|
||||
return (lex_advance(454, 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));
|
||||
return (lex_advance(454, 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_skip(113, 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_skip(191, 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_advance(463, 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_advance(463, lexer, s));
|
||||
if (s->lookahead == '\r')
|
||||
return (lex_advance(53, lexer, s));
|
||||
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
|
||||
s->lookahead == ' '))
|
||||
return (lex_skip(179, lexer, s));
|
||||
return (lex_end_state(lexer, s));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,56 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* 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));
|
||||
}
|
||||
|
|
@ -1,48 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* 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));
|
||||
}
|
||||
|
|
@ -1,51 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* 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));
|
||||
}
|
||||
|
|
@ -1,67 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* 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));
|
||||
}
|
||||
|
|
@ -1,106 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* 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));
|
||||
}
|
||||
|
|
@ -1,83 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* 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));
|
||||
}
|
||||
|
|
@ -1,100 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* 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));
|
||||
}
|
||||
|
|
@ -1,104 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* state_107.c :+: :+: :+: */
|
||||
/* +:+ +:+ +:+ */
|
||||
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
|
||||
/* +#+#+#+#+#+ +#+ */
|
||||
/* Created: 2024/04/14 19:17:54 by maiboyer #+# #+# */
|
||||
/* Updated: 2024/04/14 19:18:20 by maiboyer ### ########.fr */
|
||||
/* */
|
||||
/* ************************************************************************** */
|
||||
|
||||
#include "./lex_normal_funcs.h"
|
||||
|
||||
bool lex_normal_s535(t_lexer *lexer, t_lexer_state *s)
|
||||
{
|
||||
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));
|
||||
}
|
||||
|
|
@ -1,77 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* 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));
|
||||
}
|
||||
|
|
@ -1,67 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* 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));
|
||||
}
|
||||
|
|
@ -15,48 +15,65 @@
|
|||
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_skip(178, 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_advance(458, 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_advance(458, lexer, s));
|
||||
if (s->lookahead == '\r')
|
||||
return (lex_advance(56, lexer, s));
|
||||
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
|
||||
s->lookahead == ' '))
|
||||
return (lex_skip(119, lexer, s));
|
||||
if (s->lookahead != 0)
|
||||
return (lex_advance(482, 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_skip(59, 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_advance(273, lexer, s));
|
||||
if (s->lookahead == '#')
|
||||
return (lex_advance(421, lexer, s));
|
||||
if (s->lookahead == '&')
|
||||
return (lex_advance(336, lexer, s));
|
||||
if (s->lookahead == ';')
|
||||
return (lex_advance(483, lexer, s));
|
||||
if (s->lookahead == '<')
|
||||
return (lex_advance(254, lexer, s));
|
||||
if (s->lookahead == '>')
|
||||
return (lex_advance(257, lexer, s));
|
||||
if (s->lookahead == '\\')
|
||||
return (lex_skip(160, lexer, s));
|
||||
if (s->lookahead == '`')
|
||||
return (lex_advance(207, lexer, s));
|
||||
if (s->lookahead == 'e')
|
||||
return (lex_advance(211, lexer, s));
|
||||
if (s->lookahead == '|')
|
||||
return (lex_advance(235, lexer, s));
|
||||
if (((s->lookahead >= '[' && s->lookahead <= ']') || \
|
||||
(s->lookahead >= '{' && s->lookahead <= '}')))
|
||||
return (lex_advance(372, lexer, s));
|
||||
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
|
||||
s->lookahead == ' '))
|
||||
return (lex_skip(59, lexer, s));
|
||||
return (lex_end_state(lexer, s));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,52 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* 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));
|
||||
}
|
||||
|
|
@ -1,55 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* 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));
|
||||
}
|
||||
|
|
@ -1,65 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* 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));
|
||||
}
|
||||
|
|
@ -1,61 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* 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));
|
||||
}
|
||||
|
|
@ -1,55 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* 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));
|
||||
}
|
||||
|
|
@ -1,61 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* 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));
|
||||
}
|
||||
|
|
@ -1,49 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* 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));
|
||||
}
|
||||
|
|
@ -1,43 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* 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));
|
||||
}
|
||||
|
|
@ -1,59 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* 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));
|
||||
}
|
||||
|
|
@ -1,65 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* 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));
|
||||
}
|
||||
|
|
@ -15,51 +15,59 @@
|
|||
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') || \
|
||||
return (lex_advance(273, lexer, s));
|
||||
if (s->lookahead == '#')
|
||||
return (lex_advance(421, lexer, s));
|
||||
if (s->lookahead == '&')
|
||||
return (lex_advance(333, lexer, s));
|
||||
if (s->lookahead == ';')
|
||||
return (lex_advance(484, lexer, s));
|
||||
if (s->lookahead == '\\')
|
||||
return (lex_skip(167, lexer, s));
|
||||
if (s->lookahead == '`')
|
||||
return (lex_advance(207, lexer, s));
|
||||
if (s->lookahead == 'i')
|
||||
return (lex_advance(210, lexer, s));
|
||||
if (((s->lookahead >= '[' && s->lookahead <= ']') || \
|
||||
s->lookahead == '{' || s->lookahead == '}'))
|
||||
return (lex_advance(372, lexer, s));
|
||||
if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
|
||||
s->lookahead == ' '))
|
||||
return (lex_skip(430, lexer, s));
|
||||
return (lex_skip(60, 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_skip(131, 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_advance(459, 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_advance(459, lexer, s));
|
||||
if (s->lookahead == '\r')
|
||||
return (lex_advance(62, lexer, s));
|
||||
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
|
||||
s->lookahead == ' '))
|
||||
return (lex_skip(121, lexer, s));
|
||||
if (s->lookahead != 0)
|
||||
return (lex_advance(482, 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_skip(194, lexer, s));
|
||||
return (lex_end_state(lexer, s));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,63 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* 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));
|
||||
}
|
||||
|
|
@ -1,69 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* 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));
|
||||
}
|
||||
|
|
@ -1,67 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* 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));
|
||||
}
|
||||
|
|
@ -1,77 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* 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));
|
||||
}
|
||||
|
|
@ -1,53 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* 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));
|
||||
}
|
||||
|
|
@ -1,53 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* 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));
|
||||
}
|
||||
|
|
@ -1,75 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* 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));
|
||||
}
|
||||
|
|
@ -1,75 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* 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));
|
||||
}
|
||||
|
|
@ -1,76 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* 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));
|
||||
}
|
||||
|
|
@ -1,65 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* 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));
|
||||
}
|
||||
|
|
@ -15,44 +15,46 @@
|
|||
bool lex_normal_s65(t_lexer *lexer, t_lexer_state *s)
|
||||
{
|
||||
if (s->lookahead == '\n')
|
||||
return (lex_skip(466, lexer, s));
|
||||
return (lex_advance(456, 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_advance(456, lexer, s));
|
||||
if (s->lookahead == '\r')
|
||||
return (lex_advance(65, lexer, s));
|
||||
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
|
||||
s->lookahead == ' '))
|
||||
return (lex_skip(115, 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_skip(192, 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_skip(197, 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));
|
||||
return (lex_advance(378, lexer, s));
|
||||
if (s->lookahead == '\r')
|
||||
return (lex_advance(68, lexer, s));
|
||||
return (lex_advance(374, lexer, s));
|
||||
if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
|
||||
s->lookahead == ' '))
|
||||
return (lex_skip(432, lexer, s));
|
||||
return (lex_advance(378, lexer, s));
|
||||
if (s->lookahead != 0)
|
||||
return (lex_advance(381, lexer, s));
|
||||
return (lex_end_state(lexer, s));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,57 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* 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));
|
||||
}
|
||||
|
|
@ -1,65 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* 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));
|
||||
}
|
||||
|
|
@ -1,61 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* 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));
|
||||
}
|
||||
|
|
@ -1,43 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* state_133.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_s665(t_lexer *lexer, t_lexer_state *s)
|
||||
{
|
||||
lex_accept_token(anon_sym_SEMI_SEMI_AMP, lexer, s);
|
||||
return (lex_end_state(lexer, s));
|
||||
}
|
||||
|
||||
bool lex_normal_s666(t_lexer *lexer, t_lexer_state *s)
|
||||
{
|
||||
lex_accept_token(anon_sym_LBRACE, lexer, s);
|
||||
return (lex_end_state(lexer, s));
|
||||
}
|
||||
|
||||
bool lex_normal_s667(t_lexer *lexer, t_lexer_state *s)
|
||||
{
|
||||
lex_accept_token(anon_sym_RBRACE, lexer, s);
|
||||
return (lex_end_state(lexer, s));
|
||||
}
|
||||
|
||||
bool lex_normal_s668(t_lexer *lexer, t_lexer_state *s)
|
||||
{
|
||||
lex_accept_token(anon_sym_PIPE_AMP, lexer, s);
|
||||
return (lex_end_state(lexer, s));
|
||||
}
|
||||
|
||||
bool lex_normal_s669(t_lexer *lexer, t_lexer_state *s)
|
||||
{
|
||||
lex_accept_token(anon_sym_BANG, lexer, s);
|
||||
return (lex_end_state(lexer, s));
|
||||
}
|
||||
|
|
@ -1,61 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* state_134.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_s670(t_lexer *lexer, t_lexer_state *s)
|
||||
{
|
||||
lex_accept_token(anon_sym_BANG, lexer, s);
|
||||
if (s->lookahead == '=')
|
||||
return (lex_advance(606, 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_s671(t_lexer *lexer, t_lexer_state *s)
|
||||
{
|
||||
lex_accept_token(anon_sym_BANG, lexer, s);
|
||||
if (s->lookahead == '=')
|
||||
return (lex_advance(605, lexer, s));
|
||||
return (lex_end_state(lexer, s));
|
||||
}
|
||||
|
||||
bool lex_normal_s672(t_lexer *lexer, t_lexer_state *s)
|
||||
{
|
||||
lex_accept_token(anon_sym_BANG, 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_s673(t_lexer *lexer, t_lexer_state *s)
|
||||
{
|
||||
lex_accept_token(anon_sym_LBRACK, lexer, s);
|
||||
return (lex_end_state(lexer, s));
|
||||
}
|
||||
|
||||
bool lex_normal_s674(t_lexer *lexer, t_lexer_state *s)
|
||||
{
|
||||
lex_accept_token(anon_sym_LBRACK, lexer, s);
|
||||
if (s->lookahead == '[')
|
||||
return (lex_advance(676, lexer, s));
|
||||
return (lex_end_state(lexer, s));
|
||||
}
|
||||
|
|
@ -1,49 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* state_135.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_s675(t_lexer *lexer, t_lexer_state *s)
|
||||
{
|
||||
lex_accept_token(anon_sym_RBRACK, lexer, s);
|
||||
return (lex_end_state(lexer, s));
|
||||
}
|
||||
|
||||
bool lex_normal_s676(t_lexer *lexer, t_lexer_state *s)
|
||||
{
|
||||
lex_accept_token(anon_sym_LBRACK_LBRACK, lexer, s);
|
||||
return (lex_end_state(lexer, s));
|
||||
}
|
||||
|
||||
bool lex_normal_s677(t_lexer *lexer, t_lexer_state *s)
|
||||
{
|
||||
lex_accept_token(anon_sym_RBRACK_RBRACK, lexer, s);
|
||||
return (lex_end_state(lexer, s));
|
||||
}
|
||||
|
||||
bool lex_normal_s678(t_lexer *lexer, t_lexer_state *s)
|
||||
{
|
||||
lex_accept_token(anon_sym_EQ_TILDE, lexer, s);
|
||||
return (lex_end_state(lexer, s));
|
||||
}
|
||||
|
||||
bool lex_normal_s679(t_lexer *lexer, t_lexer_state *s)
|
||||
{
|
||||
lex_accept_token(anon_sym_EQ_TILDE, 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));
|
||||
}
|
||||
|
|
@ -1,49 +0,0 @@
|
|||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* state_136.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_s680(t_lexer *lexer, t_lexer_state *s)
|
||||
{
|
||||
lex_accept_token(anon_sym_AMP_GT, lexer, s);
|
||||
if (s->lookahead == '>')
|
||||
return (lex_advance(681, lexer, s));
|
||||
return (lex_end_state(lexer, s));
|
||||
}
|
||||
|
||||
bool lex_normal_s681(t_lexer *lexer, t_lexer_state *s)
|
||||
{
|
||||
lex_accept_token(anon_sym_AMP_GT_GT, lexer, s);
|
||||
return (lex_end_state(lexer, s));
|
||||
}
|
||||
|
||||
bool lex_normal_s682(t_lexer *lexer, t_lexer_state *s)
|
||||
{
|
||||
lex_accept_token(anon_sym_LT_AMP, lexer, s);
|
||||
if (s->lookahead == '-')
|
||||
return (lex_advance(685, lexer, s));
|
||||
return (lex_end_state(lexer, s));
|
||||
}
|
||||
|
||||
bool lex_normal_s683(t_lexer *lexer, t_lexer_state *s)
|
||||
{
|
||||
lex_accept_token(anon_sym_GT_AMP, lexer, s);
|
||||
if (s->lookahead == '-')
|
||||
return (lex_advance(686, lexer, s));
|
||||
return (lex_end_state(lexer, s));
|
||||
}
|
||||
|
||||
bool lex_normal_s684(t_lexer *lexer, t_lexer_state *s)
|
||||
{
|
||||
lex_accept_token(anon_sym_GT_PIPE, lexer, s);
|
||||
return (lex_end_state(lexer, s));
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Add table
Add a link
Reference in a new issue