From: Mart Lubbers Date: Thu, 2 Dec 2021 05:48:22 +0000 (+0100) Subject: Initial commit X-Git-Url: https://git.martlubbers.net/?a=commitdiff_plain;h=eb6a506ac6721153c0013aaf506e4ed60b34bc6d;p=advent21.git Initial commit --- eb6a506ac6721153c0013aaf506e4ed60b34bc6d diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..0a881d2 --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +*.o +[0-9][0-9] +[0-9][0-9][ab] diff --git a/01.c b/01.c new file mode 100644 index 0000000..b667be8 --- /dev/null +++ b/01.c @@ -0,0 +1,34 @@ +#include +#include +#include + +bool read_int(int *r) +{ + char c; + *r = 0; + while (isdigit(c = getchar())) + *r = *r*10 + c-'0'; + return c != EOF; +} + +int one(int winsize) +{ + int win[winsize+1], wi = 0, increase = 0; + for (; wi 0) + increase++; + wi = (wi+1) % (winsize+1); + } + return increase; +} + +int main(void) +{ + //For a + //printf("%d\n", one(1)); + //For b + printf("%d\n", one(3)); + return 0; +} diff --git a/02a.l b/02a.l new file mode 100644 index 0000000..7cbaea1 --- /dev/null +++ b/02a.l @@ -0,0 +1,21 @@ +%option noyywrap +%option noinput +%option nounput +%{ +#include +int x = 0, z = 0; +%} + +%% +forward\ [0-9] x += atoi(yytext+sizeof("forward")); +up\ [0-9] z -= atoi(yytext+sizeof("up")); +down\ [0-9] z += atoi(yytext+sizeof("down")); +\n ; +%% + +int main (void) +{ + yylex(); + printf("%d\n", x*z); + return 0; +} diff --git a/02b.l b/02b.l new file mode 100644 index 0000000..92ed694 --- /dev/null +++ b/02b.l @@ -0,0 +1,25 @@ +%option noyywrap +%option noinput +%option nounput +%{ +#include +int x = 0, z = 0, aim = 0; +%} + +%% +forward\ [0-9] { + int num = atoi(yytext+sizeof("forward")); + x += num; + z += aim*num; + } +up\ [0-9] aim -= atoi(yytext+sizeof("up")); +down\ [0-9] aim += atoi(yytext+sizeof("down")); +\n ; +%% + +int main (void) +{ + yylex(); + printf("x: %d, z: %d, x*z: %d\n", x, z, x*z); + return 0; +} diff --git a/1.txt b/1.txt new file mode 100644 index 0000000..32cfeab --- /dev/null +++ b/1.txt @@ -0,0 +1,2000 @@ +156 +176 +175 +176 +183 +157 +150 +153 +154 +170 +162 +167 +170 +188 +190 +194 +196 +198 +202 +203 +187 +189 +194 +213 +216 +217 +224 +217 +216 +224 +237 +251 +259 +260 +292 +312 +313 +319 +315 +316 +324 +330 +331 +346 +361 +388 +373 +363 +338 +342 +337 +331 +333 +328 +329 +335 +336 +334 +332 +333 +337 +338 +345 +344 +342 +345 +344 +320 +343 +346 +347 +339 +363 +349 +362 +359 +373 +362 +363 +356 +360 +367 +368 +369 +370 +362 +366 +367 +382 +376 +393 +404 +403 +405 +404 +437 +447 +448 +447 +448 +456 +457 +459 +461 +459 +462 +450 +452 +453 +461 +469 +464 +470 +474 +478 +497 +500 +524 +527 +522 +525 +526 +524 +527 +547 +548 +549 +532 +518 +555 +558 +556 +575 +586 +585 +596 +592 +593 +583 +584 +598 +604 +626 +629 +635 +636 +641 +644 +646 +639 +643 +617 +616 +617 +619 +629 +630 +625 +624 +628 +636 +638 +639 +658 +665 +670 +667 +641 +645 +653 +680 +689 +665 +640 +633 +635 +641 +632 +635 +637 +638 +641 +653 +661 +671 +679 +678 +675 +677 +681 +682 +703 +704 +705 +710 +712 +719 +722 +709 +710 +712 +715 +721 +719 +720 +750 +739 +717 +714 +715 +716 +723 +722 +720 +724 +723 +717 +708 +725 +723 +709 +715 +722 +711 +694 +695 +702 +700 +724 +721 +720 +749 +748 +749 +754 +756 +763 +773 +753 +755 +754 +758 +761 +762 +760 +762 +765 +768 +788 +812 +813 +814 +828 +833 +848 +851 +853 +858 +863 +865 +866 +864 +863 +865 +866 +879 +888 +889 +912 +917 +910 +912 +919 +924 +913 +927 +928 +927 +931 +939 +943 +946 +948 +952 +951 +952 +965 +968 +970 +964 +946 +947 +952 +954 +962 +965 +967 +981 +982 +992 +993 +995 +997 +987 +990 +1005 +1018 +1000 +999 +1000 +1001 +983 +978 +1004 +999 +1002 +1024 +1022 +1030 +1037 +1061 +1071 +1081 +1083 +1077 +1076 +1086 +1101 +1116 +1137 +1153 +1158 +1160 +1167 +1168 +1184 +1204 +1214 +1250 +1271 +1273 +1272 +1274 +1297 +1303 +1304 +1331 +1349 +1350 +1355 +1356 +1357 +1358 +1371 +1391 +1396 +1395 +1399 +1367 +1368 +1330 +1327 +1335 +1336 +1340 +1331 +1332 +1329 +1337 +1324 +1325 +1326 +1327 +1313 +1326 +1328 +1331 +1307 +1309 +1310 +1320 +1324 +1325 +1324 +1353 +1354 +1356 +1357 +1359 +1360 +1361 +1357 +1360 +1362 +1366 +1373 +1380 +1399 +1403 +1414 +1435 +1439 +1424 +1433 +1439 +1446 +1443 +1444 +1438 +1435 +1434 +1426 +1441 +1451 +1452 +1463 +1472 +1468 +1461 +1489 +1485 +1487 +1492 +1489 +1492 +1489 +1497 +1468 +1469 +1473 +1477 +1476 +1477 +1502 +1499 +1501 +1506 +1502 +1505 +1512 +1543 +1541 +1556 +1557 +1555 +1557 +1556 +1530 +1548 +1545 +1552 +1559 +1569 +1570 +1555 +1563 +1562 +1565 +1574 +1573 +1574 +1573 +1563 +1572 +1576 +1571 +1573 +1565 +1570 +1571 +1572 +1579 +1590 +1591 +1595 +1597 +1600 +1596 +1597 +1596 +1605 +1607 +1606 +1607 +1610 +1612 +1614 +1620 +1625 +1639 +1636 +1639 +1634 +1633 +1624 +1644 +1645 +1642 +1651 +1654 +1658 +1663 +1665 +1666 +1668 +1671 +1676 +1663 +1656 +1659 +1656 +1655 +1650 +1656 +1657 +1667 +1673 +1674 +1675 +1676 +1680 +1673 +1674 +1677 +1683 +1690 +1692 +1697 +1693 +1694 +1701 +1714 +1689 +1691 +1692 +1684 +1686 +1685 +1683 +1685 +1686 +1692 +1706 +1694 +1692 +1702 +1703 +1723 +1728 +1726 +1728 +1729 +1730 +1738 +1737 +1703 +1701 +1714 +1729 +1730 +1728 +1729 +1730 +1729 +1707 +1714 +1755 +1760 +1786 +1787 +1807 +1814 +1815 +1813 +1808 +1810 +1794 +1797 +1801 +1800 +1807 +1802 +1803 +1804 +1819 +1821 +1819 +1828 +1816 +1817 +1852 +1839 +1840 +1837 +1838 +1877 +1876 +1868 +1879 +1886 +1885 +1886 +1859 +1864 +1872 +1905 +1907 +1912 +1915 +1920 +1936 +1935 +1943 +1945 +1968 +1963 +1954 +1969 +1968 +1976 +1977 +1978 +1963 +1961 +1966 +1968 +1983 +1984 +1983 +1982 +1954 +1957 +1959 +1970 +1980 +1986 +1996 +1997 +1964 +1957 +1958 +1957 +1969 +1982 +1988 +1985 +1986 +1982 +1981 +1980 +2007 +1999 +2002 +2033 +2039 +2040 +2028 +2048 +2049 +2047 +2046 +2051 +2049 +2036 +2028 +2041 +2038 +2041 +2044 +2052 +2058 +2060 +2063 +2068 +2071 +2070 +2076 +2075 +2055 +2054 +2049 +2035 +2038 +2048 +2071 +2090 +2097 +2102 +2086 +2085 +2083 +2085 +2090 +2107 +2106 +2138 +2144 +2151 +2142 +2153 +2154 +2155 +2156 +2159 +2155 +2178 +2181 +2182 +2189 +2190 +2194 +2197 +2198 +2194 +2198 +2201 +2202 +2201 +2199 +2171 +2169 +2164 +2178 +2181 +2186 +2187 +2188 +2191 +2190 +2193 +2211 +2226 +2241 +2227 +2253 +2259 +2281 +2282 +2283 +2282 +2264 +2263 +2278 +2295 +2299 +2290 +2291 +2294 +2307 +2306 +2315 +2314 +2316 +2315 +2340 +2339 +2350 +2362 +2365 +2322 +2339 +2340 +2353 +2368 +2363 +2361 +2370 +2371 +2376 +2368 +2369 +2371 +2372 +2394 +2408 +2415 +2417 +2399 +2405 +2408 +2410 +2417 +2418 +2425 +2426 +2424 +2423 +2453 +2456 +2467 +2475 +2478 +2480 +2487 +2503 +2506 +2502 +2508 +2494 +2497 +2502 +2505 +2511 +2512 +2509 +2516 +2511 +2516 +2523 +2493 +2500 +2502 +2506 +2507 +2483 +2486 +2484 +2454 +2456 +2467 +2470 +2473 +2485 +2484 +2491 +2492 +2496 +2497 +2518 +2483 +2484 +2511 +2516 +2485 +2486 +2487 +2482 +2483 +2484 +2481 +2508 +2512 +2503 +2511 +2542 +2536 +2538 +2547 +2540 +2531 +2532 +2535 +2526 +2525 +2552 +2562 +2563 +2564 +2563 +2562 +2561 +2564 +2565 +2567 +2568 +2563 +2564 +2576 +2577 +2582 +2573 +2569 +2564 +2570 +2568 +2571 +2582 +2564 +2566 +2564 +2579 +2588 +2587 +2590 +2592 +2598 +2611 +2634 +2653 +2652 +2648 +2649 +2650 +2636 +2641 +2660 +2661 +2659 +2661 +2653 +2654 +2640 +2638 +2636 +2635 +2633 +2635 +2636 +2656 +2657 +2658 +2667 +2679 +2707 +2697 +2708 +2702 +2703 +2714 +2715 +2722 +2726 +2730 +2720 +2724 +2725 +2733 +2745 +2748 +2750 +2746 +2736 +2737 +2739 +2740 +2720 +2729 +2734 +2726 +2739 +2734 +2736 +2735 +2736 +2735 +2737 +2727 +2694 +2692 +2702 +2703 +2710 +2713 +2708 +2710 +2721 +2731 +2722 +2723 +2724 +2742 +2750 +2745 +2735 +2745 +2748 +2778 +2770 +2772 +2773 +2772 +2773 +2768 +2779 +2778 +2779 +2802 +2801 +2809 +2810 +2814 +2833 +2835 +2844 +2859 +2860 +2861 +2865 +2870 +2872 +2870 +2876 +2875 +2877 +2883 +2872 +2871 +2872 +2891 +2889 +2890 +2868 +2866 +2864 +2867 +2862 +2863 +2864 +2867 +2870 +2874 +2875 +2895 +2887 +2886 +2887 +2886 +2889 +2890 +2891 +2890 +2867 +2888 +2895 +2896 +2891 +2894 +2896 +2886 +2888 +2892 +2878 +2871 +2876 +2877 +2875 +2874 +2875 +2887 +2875 +2901 +2920 +2923 +2924 +2925 +2907 +2908 +2931 +2932 +2933 +2937 +2951 +2952 +2951 +2947 +2967 +2966 +2962 +2972 +2953 +2941 +2962 +2988 +2995 +3014 +3008 +3009 +3024 +3034 +3029 +3038 +3058 +3059 +3060 +3037 +3040 +3039 +3030 +3046 +3058 +3059 +3067 +3069 +3082 +3086 +3088 +3089 +3086 +3097 +3105 +3116 +3114 +3148 +3152 +3154 +3164 +3196 +3198 +3200 +3212 +3217 +3224 +3247 +3249 +3250 +3251 +3256 +3243 +3247 +3249 +3250 +3249 +3254 +3255 +3256 +3273 +3274 +3275 +3273 +3274 +3276 +3263 +3271 +3272 +3290 +3289 +3290 +3292 +3279 +3284 +3273 +3277 +3284 +3289 +3292 +3301 +3300 +3338 +3340 +3375 +3384 +3382 +3375 +3377 +3373 +3376 +3375 +3382 +3385 +3404 +3400 +3403 +3415 +3408 +3420 +3421 +3422 +3419 +3423 +3432 +3434 +3435 +3436 +3438 +3431 +3426 +3434 +3460 +3462 +3463 +3438 +3445 +3446 +3451 +3448 +3468 +3460 +3453 +3459 +3464 +3465 +3459 +3465 +3462 +3464 +3474 +3489 +3501 +3502 +3503 +3506 +3507 +3515 +3505 +3508 +3509 +3508 +3510 +3494 +3495 +3494 +3495 +3496 +3497 +3500 +3513 +3512 +3513 +3514 +3531 +3533 +3531 +3523 +3524 +3528 +3550 +3549 +3538 +3532 +3529 +3535 +3526 +3529 +3528 +3563 +3533 +3534 +3541 +3543 +3544 +3543 +3565 +3576 +3581 +3622 +3624 +3630 +3622 +3628 +3640 +3649 +3644 +3645 +3655 +3654 +3648 +3649 +3644 +3642 +3643 +3668 +3672 +3688 +3718 +3724 +3734 +3737 +3758 +3757 +3760 +3761 +3777 +3775 +3770 +3767 +3768 +3767 +3774 +3771 +3778 +3776 +3782 +3790 +3791 +3803 +3819 +3824 +3822 +3828 +3819 +3805 +3809 +3808 +3809 +3815 +3817 +3819 +3817 +3821 +3842 +3846 +3844 +3842 +3857 +3858 +3876 +3869 +3878 +3848 +3850 +3840 +3862 +3861 +3859 +3869 +3872 +3865 +3864 +3859 +3861 +3854 +3853 +3854 +3850 +3851 +3860 +3866 +3850 +3846 +3847 +3864 +3852 +3859 +3857 +3860 +3859 +3860 +3862 +3877 +3880 +3881 +3914 +3911 +3913 +3923 +3924 +3934 +3936 +3927 +3934 +3939 +3940 +3942 +3936 +3937 +3936 +3956 +3936 +3937 +3942 +3943 +3951 +3954 +3966 +3978 +3980 +3992 +3997 +4001 +3991 +3990 +3994 +4000 +4007 +4010 +4014 +3990 +3991 +3992 +3995 +4005 +4006 +4009 +4022 +4023 +4026 +4003 +4017 +4018 +4020 +4021 +4023 +4026 +4028 +4027 +4016 +4015 +4011 +4001 +4027 +4031 +4033 +4045 +4059 +4065 +4063 +4064 +4065 +4070 +4075 +4076 +4069 +4052 +4054 +4024 +4017 +4018 +4017 +4018 +4015 +4011 +4014 +4015 +4022 +4009 +4008 +4009 +3988 +4010 +4025 +3990 +3998 +4002 +4008 +4006 +4008 +4015 +4013 +4010 +4019 +4035 +4034 +4036 +4044 +4073 +4070 +4067 +4068 +4086 +4087 +4088 +4085 +4084 +4083 +4086 +4083 +4082 +4083 +4080 +4077 +4049 +4050 +4052 +4053 +4057 +4065 +4068 +4065 +4083 +4084 +4101 +4110 +4114 +4113 +4111 +4112 +4116 +4094 +4101 +4105 +4104 +4107 +4106 +4120 +4138 +4147 +4148 +4152 +4157 +4160 +4161 +4163 +4155 +4153 +4156 +4178 +4179 +4184 +4203 +4206 +4208 +4212 +4196 +4197 +4169 +4173 +4159 +4160 +4161 +4162 +4163 +4160 +4162 +4164 +4165 +4166 +4168 +4166 +4167 +4157 +4166 +4157 +4159 +4175 +4173 +4162 +4153 +4137 +4142 +4144 +4145 +4146 +4152 +4158 +4173 +4171 +4167 +4168 +4173 +4172 +4173 +4178 +4181 +4161 +4164 +4160 +4153 +4155 +4154 +4149 +4160 +4162 +4178 +4172 +4174 +4183 +4184 +4192 +4198 +4201 +4204 +4210 +4211 +4216 +4222 +4232 +4233 +4248 +4250 +4254 +4255 +4270 +4275 +4276 +4282 +4289 +4287 +4288 +4290 +4291 +4319 +4334 +4352 +4360 +4367 +4377 +4384 +4407 +4408 +4407 +4419 +4404 +4407 +4423 +4425 +4424 +4428 +4429 +4451 +4446 +4444 +4445 +4449 +4472 +4474 +4475 +4486 +4496 +4470 +4473 +4478 +4477 +4478 +4480 +4491 +4492 +4487 +4486 +4494 +4499 +4521 +4520 +4532 +4536 +4510 +4516 +4526 +4534 +4515 +4509 +4510 +4511 +4472 +4473 +4483 +4477 +4478 +4497 +4522 +4524 +4550 +4553 +4558 +4559 +4543 +4534 +4533 +4521 +4525 +4526 +4514 +4520 +4515 +4503 +4506 +4511 +4529 +4530 +4536 +4538 +4551 +4553 +4558 +4561 +4545 +4542 +4546 +4534 +4533 +4535 +4539 +4536 +4532 +4541 +4545 +4538 +4535 +4516 +4514 +4513 +4538 +4549 +4556 +4562 +4563 +4564 +4568 +4570 +4575 +4576 +4591 +4577 +4589 +4590 +4571 +4576 +4574 +4575 +4576 +4574 +4577 +4574 +4575 +4588 +4580 +4598 +4595 +4610 +4603 +4604 +4605 +4593 +4594 +4580 +4583 +4604 +4613 +4614 +4631 +4629 +4647 +4628 +4615 +4634 +4635 +4636 +4640 +4646 +4652 +4651 +4653 +4649 +4643 +4645 +4642 +4643 +4639 +4644 +4655 +4658 +4659 +4660 +4668 +4669 +4670 +4680 +4692 +4682 +4686 +4688 +4691 +4690 +4697 +4698 +4700 +4703 +4709 +4713 +4718 +4720 +4728 +4742 +4744 +4743 +4751 +4753 +4741 +4747 +4750 +4751 +4733 +4732 +4734 +4723 +4724 +4738 +4739 +4767 +4773 +4775 +4778 +4782 +4786 +4790 +4754 +4757 +4769 +4763 +4768 +4770 +4773 +4798 +4818 +4819 +4820 +4819 +4820 +4822 +4830 +4828 +4830 +4815 +4821 +4828 +4826 +4829 +4828 +4824 +4823 +4827 +4809 +4816 +4818 +4819 +4821 +4822 +4833 +4837 +4834 +4835 +4838 +4848 +4855 +4866 +4864 +4859 +4879 +4882 +4880 +4878 +4860 +4847 +4850 +4835 +4836 +4840 +4827 +4849 +4848 +4849 +4855 +4847 +4842 +4846 +4849 +4807 +4809 +4815 +4842 +4847 +4863 +4846 +4845 +4844 +4846 +4849 +4861 +4841 +4861 +4862 +4881 +4880 +4890 +4892 +4895 +4916 +4917 +4923 +4943 +4945 +4944 +4946 +4957 +4955 +4943 +4939 +4955 +4957 +4961 +4962 +4970 +4972 +4973 +4979 +4964 +4963 +4960 +4961 +4955 +4946 +4951 +4949 +4962 +4964 +4968 +4976 +4965 +4967 +4961 +4965 +4966 +4953 +4923 +4928 +4929 +4932 +4934 +4936 +4951 +4949 +4950 +4976 +4975 +4996 +4999 +5007 +5011 +5010 +5004 +5017 +5022 +5016 +5015 +5022 +5016 +5025 +5040 +5033 +5037 +5024 +5025 +5028 +5030 +5026 +5025 +5028 +5029 +5035 +5034 +5058 +5061 +5060 +5065 +5049 +5056 +5055 +5050 +5068 +5069 +5074 +5090 +5083 +5068 +5080 +5079 +5080 +5081 +5084 +5099 +5100 +5115 +5114 +5119 +5120 +5128 +5120 +5131 +5130 +5120 +5113 +5126 +5130 +5156 +5158 +5159 +5163 +5162 +5125 +5126 +5135 +5162 +5166 +5173 +5169 +5177 +5183 +5199 +5200 +5188 +5191 +5192 +5184 +5193 +5203 +5206 +5214 +5219 +5215 +5230 +5231 +5208 +5207 +5208 +5181 +5161 +5162 +5164 +5189 +5190 +5170 diff --git a/1e.txt b/1e.txt new file mode 100644 index 0000000..167e291 --- /dev/null +++ b/1e.txt @@ -0,0 +1,10 @@ +199 +200 +208 +210 +200 +207 +240 +269 +260 +263 diff --git a/2.c b/2.c new file mode 100644 index 0000000..029c7f8 --- /dev/null +++ b/2.c @@ -0,0 +1,1747 @@ + +#line 3 "" + +#define YY_INT_ALIGNED short int + +/* A lexical scanner generated by flex */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 6 +#define YY_FLEX_SUBMINOR_VERSION 4 +#if YY_FLEX_SUBMINOR_VERSION > 0 +#define FLEX_BETA +#endif + +/* First, we deal with platform-specific or compiler-specific issues. */ + +/* begin standard C headers. */ +#include +#include +#include +#include + +/* end standard C headers. */ + +/* flex integer type definitions */ + +#ifndef FLEXINT_H +#define FLEXINT_H + +/* C99 systems have . Non-C99 systems may or may not. */ + +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + +/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, + * if you want the limit (max/min) macros for int types. + */ +#ifndef __STDC_LIMIT_MACROS +#define __STDC_LIMIT_MACROS 1 +#endif + +#include +typedef int8_t flex_int8_t; +typedef uint8_t flex_uint8_t; +typedef int16_t flex_int16_t; +typedef uint16_t flex_uint16_t; +typedef int32_t flex_int32_t; +typedef uint32_t flex_uint32_t; +#else +typedef signed char flex_int8_t; +typedef short int flex_int16_t; +typedef int flex_int32_t; +typedef unsigned char flex_uint8_t; +typedef unsigned short int flex_uint16_t; +typedef unsigned int flex_uint32_t; + +/* Limits of integral types. */ +#ifndef INT8_MIN +#define INT8_MIN (-128) +#endif +#ifndef INT16_MIN +#define INT16_MIN (-32767-1) +#endif +#ifndef INT32_MIN +#define INT32_MIN (-2147483647-1) +#endif +#ifndef INT8_MAX +#define INT8_MAX (127) +#endif +#ifndef INT16_MAX +#define INT16_MAX (32767) +#endif +#ifndef INT32_MAX +#define INT32_MAX (2147483647) +#endif +#ifndef UINT8_MAX +#define UINT8_MAX (255U) +#endif +#ifndef UINT16_MAX +#define UINT16_MAX (65535U) +#endif +#ifndef UINT32_MAX +#define UINT32_MAX (4294967295U) +#endif + +#ifndef SIZE_MAX +#define SIZE_MAX (~(size_t)0) +#endif + +#endif /* ! C99 */ + +#endif /* ! FLEXINT_H */ + +/* begin standard C++ headers. */ + +/* TODO: this is always defined, so inline it */ +#define yyconst const + +#if defined(__GNUC__) && __GNUC__ >= 3 +#define yynoreturn __attribute__((__noreturn__)) +#else +#define yynoreturn +#endif + +/* Returned upon end-of-file. */ +#define YY_NULL 0 + +/* Promotes a possibly negative, possibly signed char to an + * integer in range [0..255] for use as an array index. + */ +#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN (yy_start) = 1 + 2 * +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START (((yy_start) - 1) / 2) +#define YYSTATE YY_START +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE yyrestart( yyin ) +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#ifndef YY_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k. + * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. + * Ditto for the __ia64__ case accordingly. + */ +#define YY_BUF_SIZE 32768 +#else +#define YY_BUF_SIZE 16384 +#endif /* __ia64__ */ +#endif + +/* The state buf must be large enough to hold one state per character in the main buffer. + */ +#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) + +#ifndef YY_TYPEDEF_YY_BUFFER_STATE +#define YY_TYPEDEF_YY_BUFFER_STATE +typedef struct yy_buffer_state *YY_BUFFER_STATE; +#endif + +#ifndef YY_TYPEDEF_YY_SIZE_T +#define YY_TYPEDEF_YY_SIZE_T +typedef size_t yy_size_t; +#endif + +extern int yyleng; + +extern FILE *yyin, *yyout; + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + + #define YY_LESS_LINENO(n) + #define YY_LINENO_REWIND_TO(ptr) + +/* Return all but the first "n" matched characters back to the input stream. */ +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + int yyless_macro_arg = (n); \ + YY_LESS_LINENO(yyless_macro_arg);\ + *yy_cp = (yy_hold_char); \ + YY_RESTORE_YY_MORE_OFFSET \ + (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ + } \ + while ( 0 ) +#define unput(c) yyunput( c, (yytext_ptr) ) + +#ifndef YY_STRUCT_YY_BUFFER_STATE +#define YY_STRUCT_YY_BUFFER_STATE +struct yy_buffer_state + { + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + int yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + int yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + int yy_bs_lineno; /**< The line count. */ + int yy_bs_column; /**< The column count. */ + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; + +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + + }; +#endif /* !YY_STRUCT_YY_BUFFER_STATE */ + +/* Stack of input buffers. */ +static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ +static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ +static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */ + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + * + * Returns the top of the stack, or NULL. + */ +#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ + ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ + : NULL) +/* Same as previous macro, but useful when we know that the buffer stack is not + * NULL or when we need an lvalue. For internal use only. + */ +#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] + +/* yy_hold_char holds the character lost when yytext is formed. */ +static char yy_hold_char; +static int yy_n_chars; /* number of characters read into yy_ch_buf */ +int yyleng; + +/* Points to current character in buffer. */ +static char *yy_c_buf_p = NULL; +static int yy_init = 0; /* whether we need to initialize */ +static int yy_start = 0; /* start state number */ + +/* Flag which is used to allow yywrap()'s to do buffer switches + * instead of setting up a fresh yyin. A bit of a hack ... + */ +static int yy_did_buffer_switch_on_eof; + +void yyrestart ( FILE *input_file ); +void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer ); +YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size ); +void yy_delete_buffer ( YY_BUFFER_STATE b ); +void yy_flush_buffer ( YY_BUFFER_STATE b ); +void yypush_buffer_state ( YY_BUFFER_STATE new_buffer ); +void yypop_buffer_state ( void ); + +static void yyensure_buffer_stack ( void ); +static void yy_load_buffer_state ( void ); +static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file ); +#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER ) + +YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size ); +YY_BUFFER_STATE yy_scan_string ( const char *yy_str ); +YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len ); + +void *yyalloc ( yy_size_t ); +void *yyrealloc ( void *, yy_size_t ); +void yyfree ( void * ); + +#define yy_new_buffer yy_create_buffer +#define yy_set_interactive(is_interactive) \ + { \ + if ( ! YY_CURRENT_BUFFER ){ \ + yyensure_buffer_stack (); \ + YY_CURRENT_BUFFER_LVALUE = \ + yy_create_buffer( yyin, YY_BUF_SIZE ); \ + } \ + YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ + } +#define yy_set_bol(at_bol) \ + { \ + if ( ! YY_CURRENT_BUFFER ){\ + yyensure_buffer_stack (); \ + YY_CURRENT_BUFFER_LVALUE = \ + yy_create_buffer( yyin, YY_BUF_SIZE ); \ + } \ + YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ + } +#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) + +/* Begin user sect3 */ + +#define yywrap() (/*CONSTCOND*/1) +#define YY_SKIP_YYWRAP +typedef flex_uint8_t YY_CHAR; + +FILE *yyin = NULL, *yyout = NULL; + +typedef int yy_state_type; + +extern int yylineno; +int yylineno = 1; + +extern char *yytext; +#ifdef yytext_ptr +#undef yytext_ptr +#endif +#define yytext_ptr yytext + +static yy_state_type yy_get_previous_state ( void ); +static yy_state_type yy_try_NUL_trans ( yy_state_type current_state ); +static int yy_get_next_buffer ( void ); +static void yynoreturn yy_fatal_error ( const char* msg ); + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ +#define YY_DO_BEFORE_ACTION \ + (yytext_ptr) = yy_bp; \ + yyleng = (int) (yy_cp - yy_bp); \ + (yy_hold_char) = *yy_cp; \ + *yy_cp = '\0'; \ + (yy_c_buf_p) = yy_cp; +#define YY_NUM_RULES 5 +#define YY_END_OF_BUFFER 6 +/* This struct is not used in this scanner, + but its presence is necessary. */ +struct yy_trans_info + { + flex_int32_t yy_verify; + flex_int32_t yy_nxt; + }; +static const flex_int16_t yy_accept[26] = + { 0, + 0, 0, 6, 5, 4, 5, 5, 5, 0, 0, + 0, 0, 0, 0, 0, 0, 2, 0, 0, 3, + 0, 0, 0, 1, 0 + } ; + +static const YY_CHAR yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 5, 1, 1, 6, + + 1, 7, 1, 1, 1, 1, 1, 1, 1, 8, + 9, 10, 1, 11, 1, 1, 12, 1, 13, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1 + } ; + +static const YY_CHAR yy_meta[14] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1 + } ; + +static const flex_int16_t yy_base[27] = + { 0, + 0, 11, 29, 30, 30, 19, 18, 16, 12, 13, + 19, 13, 7, 15, 13, 10, 30, 10, 0, 30, + 2, 2, 0, 30, 30, 0 + } ; + +static const flex_int16_t yy_def[27] = + { 0, + 26, 26, 25, 25, 25, 25, 25, 25, 25, 25, + 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, + 25, 25, 25, 25, 0, 25 + } ; + +static const flex_int16_t yy_nxt[44] = + { 0, + 4, 5, 25, 24, 23, 6, 7, 22, 25, 25, + 21, 8, 5, 20, 19, 18, 6, 7, 17, 16, + 15, 14, 8, 13, 12, 11, 10, 9, 25, 3, + 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, + 25, 25, 25 + } ; + +static const flex_int16_t yy_chk[44] = + { 0, + 26, 1, 0, 23, 22, 1, 1, 21, 0, 0, + 19, 1, 2, 18, 16, 15, 2, 2, 14, 13, + 12, 11, 2, 10, 9, 8, 7, 6, 3, 25, + 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, + 25, 25, 25 + } ; + +static yy_state_type yy_last_accepting_state; +static char *yy_last_accepting_cpos; + +extern int yy_flex_debug; +int yy_flex_debug = 0; + +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#define REJECT reject_used_but_not_detected +#define yymore() yymore_used_but_not_detected +#define YY_MORE_ADJ 0 +#define YY_RESTORE_YY_MORE_OFFSET +char *yytext; +#line 1 "2.l" +#define YY_NO_INPUT 1 +#line 5 "2.l" +#include +int x = 0, z = 0; +#line 463 "" +#line 464 "" + +#define INITIAL 0 + +#ifndef YY_NO_UNISTD_H +/* Special case for "unistd.h", since it is non-ANSI. We include it way + * down here because we want the user's section 1 to have been scanned first. + * The user has a chance to override it with an option. + */ +#include +#endif + +#ifndef YY_EXTRA_TYPE +#define YY_EXTRA_TYPE void * +#endif + +static int yy_init_globals ( void ); + +/* Accessor methods to globals. + These are made visible to non-reentrant scanners for convenience. */ + +int yylex_destroy ( void ); + +int yyget_debug ( void ); + +void yyset_debug ( int debug_flag ); + +YY_EXTRA_TYPE yyget_extra ( void ); + +void yyset_extra ( YY_EXTRA_TYPE user_defined ); + +FILE *yyget_in ( void ); + +void yyset_in ( FILE * _in_str ); + +FILE *yyget_out ( void ); + +void yyset_out ( FILE * _out_str ); + + int yyget_leng ( void ); + +char *yyget_text ( void ); + +int yyget_lineno ( void ); + +void yyset_lineno ( int _line_number ); + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int yywrap ( void ); +#else +extern int yywrap ( void ); +#endif +#endif + +#ifndef YY_NO_UNPUT + +#endif + +#ifndef yytext_ptr +static void yy_flex_strncpy ( char *, const char *, int ); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen ( const char * ); +#endif + +#ifndef YY_NO_INPUT +#ifdef __cplusplus +static int yyinput ( void ); +#else +static int input ( void ); +#endif + +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k */ +#define YY_READ_BUF_SIZE 16384 +#else +#define YY_READ_BUF_SIZE 8192 +#endif /* __ia64__ */ +#endif + +/* Copy whatever the last rule matched to the standard output. */ +#ifndef ECHO +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ + if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ + { \ + int c = '*'; \ + int n; \ + for ( n = 0; n < max_size && \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else \ + { \ + errno=0; \ + while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ + { \ + if( errno != EINTR) \ + { \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + break; \ + } \ + errno=0; \ + clearerr(yyin); \ + } \ + }\ +\ + +#endif + +/* No semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef yyterminate +#define yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) +#endif + +/* end tables serialization structures and prototypes */ + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL_IS_OURS 1 + +extern int yylex (void); + +#define YY_DECL int yylex (void) +#endif /* !YY_DECL */ + +/* Code executed at the beginning of each rule, after yytext and yyleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK /*LINTED*/break; +#endif + +#define YY_RULE_SETUP \ + YY_USER_ACTION + +/** The main scanner function which does all the work. + */ +YY_DECL +{ + yy_state_type yy_current_state; + char *yy_cp, *yy_bp; + int yy_act; + + if ( !(yy_init) ) + { + (yy_init) = 1; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! (yy_start) ) + (yy_start) = 1; /* first start state */ + + if ( ! yyin ) + yyin = stdin; + + if ( ! yyout ) + yyout = stdout; + + if ( ! YY_CURRENT_BUFFER ) { + yyensure_buffer_stack (); + YY_CURRENT_BUFFER_LVALUE = + yy_create_buffer( yyin, YY_BUF_SIZE ); + } + + yy_load_buffer_state( ); + } + + { +#line 9 "2.l" + + +#line 682 "" + + while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ + { + yy_cp = (yy_c_buf_p); + + /* Support of yytext. */ + *yy_cp = (yy_hold_char); + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + + yy_current_state = (yy_start); +yy_match: + do + { + YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 26 ) + yy_c = yy_meta[yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + ++yy_cp; + } + while ( yy_base[yy_current_state] != 30 ); + +yy_find_action: + yy_act = yy_accept[yy_current_state]; + if ( yy_act == 0 ) + { /* have to back up */ + yy_cp = (yy_last_accepting_cpos); + yy_current_state = (yy_last_accepting_state); + yy_act = yy_accept[yy_current_state]; + } + + YY_DO_BEFORE_ACTION; + +do_action: /* This label is used only to access EOF actions. */ + + switch ( yy_act ) + { /* beginning of action switch */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = (yy_hold_char); + yy_cp = (yy_last_accepting_cpos); + yy_current_state = (yy_last_accepting_state); + goto yy_find_action; + +case 1: +YY_RULE_SETUP +#line 11 "2.l" +{ + x += yytext[strlen(yytext)-1]-'0'; + } + YY_BREAK +case 2: +YY_RULE_SETUP +#line 14 "2.l" +{ + z -= yytext[strlen(yytext)-1]-'0'; + } + YY_BREAK +case 3: +YY_RULE_SETUP +#line 17 "2.l" +{ + z += yytext[strlen(yytext)-1]-'0'; + } + YY_BREAK +case 4: +/* rule 4 can match eol */ +YY_RULE_SETUP +#line 20 "2.l" +; + YY_BREAK +case 5: +YY_RULE_SETUP +#line 21 "2.l" +ECHO; + YY_BREAK +#line 771 "" +case YY_STATE_EOF(INITIAL): + yyterminate(); + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = (yy_hold_char); + YY_RESTORE_YY_MORE_OFFSET + + if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure + * consistency between YY_CURRENT_BUFFER and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; + YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; + YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state( ); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state ); + + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++(yy_c_buf_p); + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { + yy_cp = (yy_c_buf_p); + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer( ) ) + { + case EOB_ACT_END_OF_FILE: + { + (yy_did_buffer_switch_on_eof) = 0; + + if ( yywrap( ) ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * yytext, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! (yy_did_buffer_switch_on_eof) ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + (yy_c_buf_p) = + (yytext_ptr) + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state( ); + + yy_cp = (yy_c_buf_p); + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + (yy_c_buf_p) = + &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; + + yy_current_state = yy_get_previous_state( ); + + yy_cp = (yy_c_buf_p); + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ + } /* end of user's declarations */ +} /* end of yylex */ + +/* yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ +static int yy_get_next_buffer (void) +{ + char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; + char *source = (yytext_ptr); + int number_to_move, i; + int ret_val; + + if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1); + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; + + else + { + int num_to_read = + YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; + + int yy_c_buf_p_offset = + (int) ((yy_c_buf_p) - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + int new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + yyrealloc( (void *) b->yy_ch_buf, + (yy_size_t) (b->yy_buf_size + 2) ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = NULL; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - + number_to_move - 1; + + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), + (yy_n_chars), num_to_read ); + + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + if ( (yy_n_chars) == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + yyrestart( yyin ); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { + /* Extend the array by 50%, plus the number we really need. */ + int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( + (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size ); + if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); + /* "- 2" to take care of EOB's */ + YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); + } + + (yy_n_chars) += number_to_move; + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; + + (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; + + return ret_val; +} + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + + static yy_state_type yy_get_previous_state (void) +{ + yy_state_type yy_current_state; + char *yy_cp; + + yy_current_state = (yy_start); + + for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) + { + YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 26 ) + yy_c = yy_meta[yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + } + + return yy_current_state; +} + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ + static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) +{ + int yy_is_jam; + char *yy_cp = (yy_c_buf_p); + + YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 26 ) + yy_c = yy_meta[yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + yy_is_jam = (yy_current_state == 25); + + return yy_is_jam ? 0 : yy_current_state; +} + +#ifndef YY_NO_UNPUT + +#endif + +#ifndef YY_NO_INPUT +#ifdef __cplusplus + static int yyinput (void) +#else + static int input (void) +#endif + +{ + int c; + + *(yy_c_buf_p) = (yy_hold_char); + + if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) + /* This was really a NUL. */ + *(yy_c_buf_p) = '\0'; + + else + { /* need more input */ + int offset = (int) ((yy_c_buf_p) - (yytext_ptr)); + ++(yy_c_buf_p); + + switch ( yy_get_next_buffer( ) ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + yyrestart( yyin ); + + /*FALLTHROUGH*/ + + case EOB_ACT_END_OF_FILE: + { + if ( yywrap( ) ) + return 0; + + if ( ! (yy_did_buffer_switch_on_eof) ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(); +#else + return input(); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + (yy_c_buf_p) = (yytext_ptr) + offset; + break; + } + } + } + + c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ + *(yy_c_buf_p) = '\0'; /* preserve yytext */ + (yy_hold_char) = *++(yy_c_buf_p); + + return c; +} +#endif /* ifndef YY_NO_INPUT */ + +/** Immediately switch to a different input stream. + * @param input_file A readable stream. + * + * @note This function does not reset the start condition to @c INITIAL . + */ + void yyrestart (FILE * input_file ) +{ + + if ( ! YY_CURRENT_BUFFER ){ + yyensure_buffer_stack (); + YY_CURRENT_BUFFER_LVALUE = + yy_create_buffer( yyin, YY_BUF_SIZE ); + } + + yy_init_buffer( YY_CURRENT_BUFFER, input_file ); + yy_load_buffer_state( ); +} + +/** Switch to a different input buffer. + * @param new_buffer The new input buffer. + * + */ + void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ) +{ + + /* TODO. We should be able to replace this entire function body + * with + * yypop_buffer_state(); + * yypush_buffer_state(new_buffer); + */ + yyensure_buffer_stack (); + if ( YY_CURRENT_BUFFER == new_buffer ) + return; + + if ( YY_CURRENT_BUFFER ) + { + /* Flush out information for old buffer. */ + *(yy_c_buf_p) = (yy_hold_char); + YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + YY_CURRENT_BUFFER_LVALUE = new_buffer; + yy_load_buffer_state( ); + + /* We don't actually know whether we did this switch during + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe + * to go ahead and always set it. + */ + (yy_did_buffer_switch_on_eof) = 1; +} + +static void yy_load_buffer_state (void) +{ + (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; + (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; + yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; + (yy_hold_char) = *(yy_c_buf_p); +} + +/** Allocate and initialize an input buffer state. + * @param file A readable stream. + * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. + * + * @return the allocated buffer state. + */ + YY_BUFFER_STATE yy_create_buffer (FILE * file, int size ) +{ + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_is_our_buffer = 1; + + yy_init_buffer( b, file ); + + return b; +} + +/** Destroy the buffer. + * @param b a buffer created with yy_create_buffer() + * + */ + void yy_delete_buffer (YY_BUFFER_STATE b ) +{ + + if ( ! b ) + return; + + if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ + YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) + yyfree( (void *) b->yy_ch_buf ); + + yyfree( (void *) b ); +} + +/* Initializes or reinitializes a buffer. + * This function is sometimes called more than once on the same buffer, + * such as during a yyrestart() or at EOF. + */ + static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file ) + +{ + int oerrno = errno; + + yy_flush_buffer( b ); + + b->yy_input_file = file; + b->yy_fill_buffer = 1; + + /* If b is the current buffer, then yy_init_buffer was _probably_ + * called from yyrestart() or through yy_get_next_buffer. + * In that case, we don't want to reset the lineno or column. + */ + if (b != YY_CURRENT_BUFFER){ + b->yy_bs_lineno = 1; + b->yy_bs_column = 0; + } + + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; + + errno = oerrno; +} + +/** Discard all buffered characters. On the next scan, YY_INPUT will be called. + * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. + * + */ + void yy_flush_buffer (YY_BUFFER_STATE b ) +{ + if ( ! b ) + return; + + b->yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[0]; + + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == YY_CURRENT_BUFFER ) + yy_load_buffer_state( ); +} + +/** Pushes the new state onto the stack. The new state becomes + * the current state. This function will allocate the stack + * if necessary. + * @param new_buffer The new state. + * + */ +void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) +{ + if (new_buffer == NULL) + return; + + yyensure_buffer_stack(); + + /* This block is copied from yy_switch_to_buffer. */ + if ( YY_CURRENT_BUFFER ) + { + /* Flush out information for old buffer. */ + *(yy_c_buf_p) = (yy_hold_char); + YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + /* Only push if top exists. Otherwise, replace top. */ + if (YY_CURRENT_BUFFER) + (yy_buffer_stack_top)++; + YY_CURRENT_BUFFER_LVALUE = new_buffer; + + /* copied from yy_switch_to_buffer. */ + yy_load_buffer_state( ); + (yy_did_buffer_switch_on_eof) = 1; +} + +/** Removes and deletes the top of the stack, if present. + * The next element becomes the new top. + * + */ +void yypop_buffer_state (void) +{ + if (!YY_CURRENT_BUFFER) + return; + + yy_delete_buffer(YY_CURRENT_BUFFER ); + YY_CURRENT_BUFFER_LVALUE = NULL; + if ((yy_buffer_stack_top) > 0) + --(yy_buffer_stack_top); + + if (YY_CURRENT_BUFFER) { + yy_load_buffer_state( ); + (yy_did_buffer_switch_on_eof) = 1; + } +} + +/* Allocates the stack if it does not exist. + * Guarantees space for at least one push. + */ +static void yyensure_buffer_stack (void) +{ + yy_size_t num_to_alloc; + + if (!(yy_buffer_stack)) { + + /* First allocation is just for 2 elements, since we don't know if this + * scanner will even need a stack. We use 2 instead of 1 to avoid an + * immediate realloc on the next call. + */ + num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ + (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc + (num_to_alloc * sizeof(struct yy_buffer_state*) + ); + if ( ! (yy_buffer_stack) ) + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); + + memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); + + (yy_buffer_stack_max) = num_to_alloc; + (yy_buffer_stack_top) = 0; + return; + } + + if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ + + /* Increase the buffer to prepare for a possible push. */ + yy_size_t grow_size = 8 /* arbitrary grow size */; + + num_to_alloc = (yy_buffer_stack_max) + grow_size; + (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc + ((yy_buffer_stack), + num_to_alloc * sizeof(struct yy_buffer_state*) + ); + if ( ! (yy_buffer_stack) ) + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); + + /* zero only the new slots.*/ + memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); + (yy_buffer_stack_max) = num_to_alloc; + } +} + +/** Setup the input buffer state to scan directly from a user-specified character buffer. + * @param base the character buffer + * @param size the size in bytes of the character buffer + * + * @return the newly allocated buffer state object. + */ +YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) +{ + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return NULL; + + b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); + + b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; + b->yy_is_our_buffer = 0; + b->yy_input_file = NULL; + b->yy_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + + yy_switch_to_buffer( b ); + + return b; +} + +/** Setup the input buffer state to scan a string. The next call to yylex() will + * scan from a @e copy of @a str. + * @param yystr a NUL-terminated string to scan + * + * @return the newly allocated buffer state object. + * @note If you want to scan bytes that may contain NUL values, then use + * yy_scan_bytes() instead. + */ +YY_BUFFER_STATE yy_scan_string (const char * yystr ) +{ + + return yy_scan_bytes( yystr, (int) strlen(yystr) ); +} + +/** Setup the input buffer state to scan the given bytes. The next call to yylex() will + * scan from a @e copy of @a bytes. + * @param yybytes the byte buffer to scan + * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. + * + * @return the newly allocated buffer state object. + */ +YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len ) +{ + YY_BUFFER_STATE b; + char *buf; + yy_size_t n; + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = (yy_size_t) (_yybytes_len + 2); + buf = (char *) yyalloc( n ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); + + for ( i = 0; i < _yybytes_len; ++i ) + buf[i] = yybytes[i]; + + buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; + + b = yy_scan_buffer( buf, n ); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->yy_is_our_buffer = 1; + + return b; +} + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +static void yynoreturn yy_fatal_error (const char* msg ) +{ + fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); +} + +/* Redefine yyless() so it works in section 3 code. */ + +#undef yyless +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + int yyless_macro_arg = (n); \ + YY_LESS_LINENO(yyless_macro_arg);\ + yytext[yyleng] = (yy_hold_char); \ + (yy_c_buf_p) = yytext + yyless_macro_arg; \ + (yy_hold_char) = *(yy_c_buf_p); \ + *(yy_c_buf_p) = '\0'; \ + yyleng = yyless_macro_arg; \ + } \ + while ( 0 ) + +/* Accessor methods (get/set functions) to struct members. */ + +/** Get the current line number. + * + */ +int yyget_lineno (void) +{ + + return yylineno; +} + +/** Get the input stream. + * + */ +FILE *yyget_in (void) +{ + return yyin; +} + +/** Get the output stream. + * + */ +FILE *yyget_out (void) +{ + return yyout; +} + +/** Get the length of the current token. + * + */ +int yyget_leng (void) +{ + return yyleng; +} + +/** Get the current token. + * + */ + +char *yyget_text (void) +{ + return yytext; +} + +/** Set the current line number. + * @param _line_number line number + * + */ +void yyset_lineno (int _line_number ) +{ + + yylineno = _line_number; +} + +/** Set the input stream. This does not discard the current + * input buffer. + * @param _in_str A readable stream. + * + * @see yy_switch_to_buffer + */ +void yyset_in (FILE * _in_str ) +{ + yyin = _in_str ; +} + +void yyset_out (FILE * _out_str ) +{ + yyout = _out_str ; +} + +int yyget_debug (void) +{ + return yy_flex_debug; +} + +void yyset_debug (int _bdebug ) +{ + yy_flex_debug = _bdebug ; +} + +static int yy_init_globals (void) +{ + /* Initialization is the same as for the non-reentrant scanner. + * This function is called from yylex_destroy(), so don't allocate here. + */ + + (yy_buffer_stack) = NULL; + (yy_buffer_stack_top) = 0; + (yy_buffer_stack_max) = 0; + (yy_c_buf_p) = NULL; + (yy_init) = 0; + (yy_start) = 0; + +/* Defined in main.c */ +#ifdef YY_STDINIT + yyin = stdin; + yyout = stdout; +#else + yyin = NULL; + yyout = NULL; +#endif + + /* For future reference: Set errno on error, since we are called by + * yylex_init() + */ + return 0; +} + +/* yylex_destroy is for both reentrant and non-reentrant scanners. */ +int yylex_destroy (void) +{ + + /* Pop the buffer stack, destroying each element. */ + while(YY_CURRENT_BUFFER){ + yy_delete_buffer( YY_CURRENT_BUFFER ); + YY_CURRENT_BUFFER_LVALUE = NULL; + yypop_buffer_state(); + } + + /* Destroy the stack itself. */ + yyfree((yy_buffer_stack) ); + (yy_buffer_stack) = NULL; + + /* Reset the globals. This is important in a non-reentrant scanner so the next time + * yylex() is called, initialization will occur. */ + yy_init_globals( ); + + return 0; +} + +/* + * Internal utility routines. + */ + +#ifndef yytext_ptr +static void yy_flex_strncpy (char* s1, const char * s2, int n ) +{ + + int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; +} +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen (const char * s ) +{ + int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; +} +#endif + +void *yyalloc (yy_size_t size ) +{ + return malloc(size); +} + +void *yyrealloc (void * ptr, yy_size_t size ) +{ + + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return realloc(ptr, size); +} + +void yyfree (void * ptr ) +{ + free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ +} + +#define YYTABLES_NAME "yytables" + +#line 21 "2.l" + + +int main (void) +{ + yylex(); + printf("x: %d, z: %d, x*z: %d\n", x, z, x*z); + return 0; +} + diff --git a/2.txt b/2.txt new file mode 100644 index 0000000..96cdcf7 --- /dev/null +++ b/2.txt @@ -0,0 +1,1000 @@ +forward 5 +forward 2 +forward 9 +down 2 +forward 9 +forward 3 +forward 2 +down 6 +forward 3 +forward 3 +down 3 +down 3 +forward 8 +down 5 +forward 7 +forward 9 +forward 9 +forward 6 +forward 9 +forward 3 +forward 3 +forward 1 +forward 7 +down 6 +forward 7 +forward 4 +down 3 +down 1 +forward 4 +down 7 +down 2 +down 8 +forward 9 +down 5 +down 2 +forward 6 +up 4 +down 3 +down 1 +down 6 +down 7 +forward 6 +up 2 +forward 2 +down 9 +down 3 +forward 7 +up 3 +up 7 +forward 8 +forward 7 +down 4 +up 8 +up 1 +forward 4 +down 6 +forward 9 +forward 3 +down 1 +down 1 +forward 2 +forward 4 +forward 3 +up 2 +forward 1 +down 8 +forward 4 +down 5 +forward 9 +up 1 +forward 3 +forward 6 +up 8 +forward 1 +forward 7 +up 9 +down 3 +up 7 +down 1 +forward 5 +forward 3 +forward 7 +down 5 +down 1 +down 2 +down 4 +down 5 +down 5 +down 8 +up 9 +down 7 +down 7 +down 6 +forward 3 +forward 5 +forward 1 +forward 8 +up 4 +down 8 +down 3 +down 1 +down 9 +down 3 +down 9 +down 8 +down 2 +forward 1 +forward 7 +forward 1 +down 3 +down 1 +up 3 +down 6 +forward 6 +forward 6 +down 8 +forward 3 +down 1 +forward 2 +down 4 +down 7 +up 8 +forward 4 +down 4 +up 1 +forward 6 +down 6 +forward 5 +forward 9 +up 5 +down 3 +up 9 +down 6 +up 3 +down 9 +down 4 +down 2 +forward 3 +down 6 +down 7 +down 9 +forward 7 +forward 2 +forward 5 +up 6 +down 8 +forward 1 +down 2 +forward 8 +down 5 +down 2 +up 4 +forward 9 +up 4 +down 4 +down 2 +forward 3 +up 2 +down 5 +down 9 +up 4 +forward 9 +down 5 +down 2 +down 2 +forward 9 +up 9 +forward 6 +up 7 +down 2 +forward 8 +down 1 +forward 2 +down 3 +up 6 +down 4 +forward 5 +up 4 +forward 5 +forward 9 +forward 9 +forward 5 +down 1 +down 7 +forward 6 +forward 9 +forward 3 +forward 4 +up 8 +down 1 +up 1 +down 3 +up 1 +down 5 +forward 6 +up 5 +up 6 +down 9 +forward 7 +down 7 +forward 1 +forward 2 +up 4 +forward 4 +down 9 +up 4 +down 6 +forward 1 +up 9 +forward 2 +down 8 +forward 6 +forward 6 +down 6 +forward 5 +forward 9 +up 8 +down 4 +forward 8 +up 6 +down 4 +up 9 +forward 2 +down 8 +down 6 +forward 2 +down 3 +forward 1 +forward 3 +forward 2 +up 4 +down 6 +up 6 +down 4 +down 2 +forward 1 +up 7 +forward 9 +forward 9 +forward 7 +down 1 +down 9 +forward 5 +forward 4 +forward 1 +forward 4 +down 5 +forward 6 +forward 8 +down 5 +down 7 +up 2 +up 1 +forward 5 +down 5 +down 1 +down 5 +down 8 +down 8 +down 5 +forward 7 +down 6 +down 2 +forward 9 +forward 1 +forward 3 +forward 4 +up 3 +down 4 +up 7 +forward 8 +forward 7 +up 4 +down 9 +forward 7 +forward 6 +up 1 +down 1 +up 6 +down 5 +up 1 +forward 2 +down 2 +forward 3 +down 6 +up 5 +up 4 +down 8 +down 5 +down 3 +down 4 +up 3 +down 3 +down 2 +down 7 +up 2 +down 8 +forward 5 +up 1 +forward 9 +down 6 +down 6 +down 8 +up 4 +forward 9 +forward 8 +up 7 +down 9 +down 4 +forward 9 +forward 9 +up 2 +down 1 +forward 1 +forward 4 +forward 2 +forward 9 +down 1 +down 3 +down 1 +down 3 +up 5 +down 2 +forward 4 +down 2 +forward 1 +down 6 +up 9 +down 3 +forward 1 +forward 5 +forward 8 +down 5 +down 6 +down 9 +forward 4 +down 7 +up 8 +forward 8 +down 9 +forward 6 +down 8 +up 3 +forward 4 +up 9 +down 7 +up 7 +forward 6 +forward 1 +up 9 +down 7 +up 7 +down 5 +forward 6 +up 7 +down 8 +down 8 +forward 4 +up 4 +forward 1 +forward 6 +down 4 +up 9 +forward 4 +up 1 +up 8 +up 6 +forward 9 +forward 4 +forward 7 +up 1 +down 5 +up 5 +up 5 +forward 4 +down 9 +up 8 +down 6 +down 3 +down 6 +forward 2 +up 1 +forward 3 +up 8 +down 1 +forward 5 +down 9 +forward 4 +up 5 +forward 3 +forward 2 +down 8 +down 9 +up 6 +down 9 +down 7 +forward 5 +forward 4 +forward 9 +up 8 +forward 3 +down 7 +forward 9 +down 8 +forward 4 +forward 8 +up 9 +up 9 +down 6 +forward 5 +forward 5 +forward 5 +up 2 +up 2 +up 1 +down 6 +forward 2 +forward 2 +down 8 +down 6 +up 2 +forward 1 +down 1 +up 5 +forward 7 +down 2 +forward 1 +forward 3 +down 5 +down 7 +forward 8 +forward 4 +forward 9 +up 1 +up 7 +up 9 +forward 3 +up 1 +forward 6 +forward 3 +forward 9 +up 9 +down 6 +forward 8 +up 6 +down 9 +forward 3 +forward 7 +down 9 +forward 4 +forward 5 +forward 7 +down 1 +down 4 +down 3 +forward 6 +down 3 +forward 7 +forward 8 +down 1 +forward 3 +down 4 +up 7 +forward 2 +forward 8 +down 6 +up 3 +down 2 +forward 9 +forward 5 +forward 7 +up 2 +up 6 +down 9 +forward 1 +up 5 +forward 1 +up 6 +up 2 +up 1 +forward 6 +down 8 +forward 7 +down 5 +forward 3 +down 9 +down 4 +forward 3 +down 1 +up 1 +up 7 +forward 4 +down 6 +forward 3 +forward 2 +down 8 +forward 9 +forward 6 +up 3 +down 3 +down 1 +down 7 +up 8 +up 2 +up 8 +forward 6 +forward 8 +forward 6 +forward 4 +down 6 +forward 6 +forward 6 +forward 1 +down 2 +forward 2 +forward 6 +down 1 +up 6 +forward 3 +forward 9 +forward 6 +down 2 +forward 2 +up 4 +down 2 +up 4 +forward 2 +forward 2 +forward 3 +up 1 +forward 8 +forward 3 +forward 3 +forward 1 +down 5 +down 9 +forward 4 +down 1 +forward 5 +forward 2 +down 5 +forward 6 +forward 3 +up 3 +forward 6 +forward 9 +forward 5 +down 2 +down 2 +down 7 +forward 8 +down 1 +down 5 +down 9 +up 3 +up 5 +up 4 +forward 3 +down 9 +down 2 +down 8 +down 5 +down 2 +forward 4 +up 3 +down 5 +up 3 +down 8 +down 7 +up 1 +forward 2 +forward 1 +down 2 +up 1 +up 5 +down 8 +down 3 +up 9 +forward 2 +down 8 +down 4 +down 3 +forward 3 +forward 7 +up 1 +down 9 +forward 1 +down 6 +up 3 +up 5 +down 6 +up 4 +forward 7 +up 4 +forward 9 +up 4 +forward 4 +down 7 +down 2 +down 8 +up 3 +down 7 +down 4 +up 5 +forward 8 +down 8 +down 1 +forward 7 +up 9 +down 5 +up 8 +down 1 +up 3 +forward 8 +up 4 +down 1 +up 1 +up 7 +forward 3 +forward 6 +forward 5 +forward 2 +down 4 +forward 2 +down 7 +up 7 +up 6 +down 4 +forward 4 +forward 9 +forward 7 +down 4 +down 6 +forward 5 +down 2 +down 6 +down 2 +down 2 +forward 9 +up 5 +forward 9 +down 3 +down 6 +down 1 +forward 5 +down 5 +forward 7 +forward 9 +up 8 +forward 6 +down 6 +down 2 +forward 8 +forward 5 +up 9 +up 4 +forward 1 +forward 2 +forward 2 +up 9 +down 6 +forward 6 +forward 8 +up 5 +up 7 +forward 4 +down 3 +forward 1 +up 6 +up 9 +forward 6 +up 8 +forward 5 +down 4 +forward 1 +down 3 +forward 1 +forward 6 +forward 2 +up 4 +down 6 +forward 9 +down 2 +forward 4 +down 4 +forward 3 +down 5 +down 2 +forward 2 +forward 2 +up 1 +forward 1 +down 7 +down 8 +up 6 +forward 8 +forward 5 +forward 8 +down 6 +forward 5 +down 3 +up 3 +forward 4 +up 9 +forward 8 +forward 4 +down 3 +forward 6 +up 6 +down 2 +down 7 +down 3 +down 2 +down 8 +forward 5 +down 9 +up 6 +down 6 +forward 8 +down 1 +forward 8 +down 1 +down 1 +forward 3 +forward 9 +down 6 +forward 7 +down 4 +forward 1 +forward 4 +forward 3 +down 6 +forward 5 +down 5 +forward 1 +forward 3 +forward 8 +down 9 +up 8 +up 6 +up 6 +forward 2 +forward 9 +down 4 +down 8 +forward 6 +up 1 +down 2 +down 6 +forward 6 +forward 2 +up 8 +forward 6 +down 9 +down 1 +forward 7 +forward 6 +forward 5 +forward 6 +down 6 +up 7 +down 9 +forward 9 +forward 3 +forward 5 +down 4 +down 1 +down 7 +up 3 +up 7 +forward 6 +forward 8 +down 7 +down 4 +forward 7 +down 6 +up 1 +forward 4 +down 2 +forward 4 +forward 3 +forward 4 +forward 4 +up 3 +down 8 +down 4 +down 1 +down 8 +down 3 +up 9 +down 4 +forward 7 +down 6 +up 2 +down 8 +up 9 +down 6 +forward 1 +down 3 +forward 9 +down 9 +forward 1 +down 5 +up 5 +up 1 +forward 8 +down 8 +down 9 +down 5 +down 2 +down 5 +forward 3 +down 9 +forward 4 +forward 4 +up 2 +forward 8 +forward 4 +forward 1 +down 5 +forward 5 +down 5 +forward 6 +forward 4 +up 5 +down 9 +up 3 +up 8 +forward 5 +forward 9 +up 6 +forward 6 +down 5 +forward 7 +down 8 +down 7 +down 9 +forward 4 +down 8 +forward 4 +down 5 +forward 6 +forward 4 +down 7 +down 5 +forward 4 +down 3 +up 4 +forward 3 +up 9 +down 8 +forward 9 +forward 6 +forward 9 +down 1 +forward 2 +up 5 +down 9 +down 2 +down 9 +up 8 +forward 7 +forward 8 +forward 4 +down 1 +up 8 +forward 8 +down 8 +down 4 +forward 9 +down 3 +forward 7 +forward 9 +down 5 +forward 7 +forward 1 +forward 5 +forward 2 +down 4 +forward 7 +down 6 +forward 3 +down 9 +forward 3 +down 5 +up 6 +up 3 +forward 1 +up 9 +down 1 +forward 2 +down 8 +down 7 +up 9 +up 2 +down 5 +up 9 +forward 9 +forward 9 +down 1 +forward 5 +up 5 +forward 1 +up 1 +down 3 +forward 3 +down 3 +forward 3 +up 5 +up 4 +down 7 +down 7 +down 4 +forward 7 +down 6 +forward 1 +up 1 +down 8 +forward 4 +down 3 +forward 9 +up 6 +forward 6 +forward 3 +up 9 +down 9 +forward 4 +up 5 +down 3 +down 8 +down 3 +down 3 +forward 4 +forward 6 +forward 4 +up 2 +up 3 +up 5 +down 5 +down 6 +forward 5 +forward 4 +down 1 +down 2 +up 8 +down 2 +down 1 +up 4 +forward 5 +forward 8 +forward 8 +forward 5 +down 3 +forward 4 +up 8 +forward 7 +forward 4 +down 9 +down 6 +forward 2 +down 7 +forward 6 +up 7 +up 1 +up 4 +forward 2 +forward 9 +forward 7 +up 5 +forward 2 +up 5 +forward 1 +forward 2 +forward 4 +down 6 +forward 2 +up 6 +up 7 +forward 3 +forward 2 +forward 6 +forward 4 +forward 9 +forward 6 +up 6 +forward 5 +up 7 +up 5 +down 6 +down 2 +down 1 +forward 7 +down 5 +down 1 +down 7 +forward 8 +forward 8 +forward 5 +down 9 +forward 6 diff --git a/2e.txt b/2e.txt new file mode 100644 index 0000000..b7172ac --- /dev/null +++ b/2e.txt @@ -0,0 +1,6 @@ +forward 5 +down 5 +forward 8 +up 3 +down 8 +forward 2 diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..b275854 --- /dev/null +++ b/Makefile @@ -0,0 +1,8 @@ +CFLAGS=-Wall -Wextra + +BINARIES:=01 02a 02b + +all: $(BINARIES) + +clean: + $(RM) *.o a.out $(BINARIES)