diff options
| author | Kimplul <kimi.h.kuparinen@gmail.com> | 2023-03-26 23:13:29 +0300 |
|---|---|---|
| committer | Kimplul <kimi.h.kuparinen@gmail.com> | 2023-03-26 23:14:04 +0300 |
| commit | 9fb179ab999c3b98caabca09b30c409dc5dd3b3d (patch) | |
| tree | 087f849f78028950885b46fbbe1bae35f9c1a908 /gen | |
| parent | 373728f324b82d305748cfe3c853053fe2a9f761 (diff) | |
| download | ek-9fb179ab999c3b98caabca09b30c409dc5dd3b3d.tar.gz ek-9fb179ab999c3b98caabca09b30c409dc5dd3b3d.zip | |
start enums
Diffstat (limited to 'gen')
| -rw-r--r-- | gen/gen_lexer.c | 525 | ||||
| -rw-r--r-- | gen/gen_lexer.h | 493 | ||||
| -rw-r--r-- | gen/gen_parser.c | 2633 | ||||
| -rw-r--r-- | gen/gen_parser.c.uncrustify | 0 | ||||
| -rw-r--r-- | gen/gen_parser.h | 7 |
5 files changed, 2078 insertions, 1580 deletions
diff --git a/gen/gen_lexer.c b/gen/gen_lexer.c index 8db9955..cebc5f3 100644 --- a/gen/gen_lexer.c +++ b/gen/gen_lexer.c @@ -1,5 +1,3 @@ -/* SPDX-License-Identifier: GPL-3.0-or-later */ - #line 2 "gen/gen_lexer.c" #line 4 "gen/gen_lexer.c" @@ -341,8 +339,8 @@ static void yynoreturn yy_fatal_error ( const char* msg , yyscan_t yyscanner ); yyg->yy_hold_char = *yy_cp; \ *yy_cp = '\0'; \ yyg->yy_c_buf_p = yy_cp; -#define YY_NUM_RULES 93 -#define YY_END_OF_BUFFER 94 +#define YY_NUM_RULES 94 +#define YY_END_OF_BUFFER 95 /* This struct is not used in this scanner, but its presence is necessary. */ struct yy_trans_info @@ -350,33 +348,33 @@ struct yy_trans_info flex_int32_t yy_verify; flex_int32_t yy_nxt; }; -static const flex_int16_t yy_accept[223] = +static const flex_int16_t yy_accept[224] = { 0, - 0, 0, 0, 0, 94, 92, 91, 91, 19, 92, - 92, 26, 35, 34, 9, 10, 24, 22, 16, 23, - 15, 25, 88, 88, 18, 17, 41, 40, 42, 21, - 90, 13, 14, 27, 90, 90, 90, 90, 90, 90, - 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, - 11, 37, 12, 39, 6, 8, 5, 7, 91, 45, - 0, 87, 0, 20, 53, 36, 56, 0, 0, 0, - 0, 50, 88, 88, 51, 0, 2, 1, 52, 89, - 88, 0, 0, 48, 43, 46, 47, 44, 49, 90, - 54, 28, 61, 90, 90, 90, 90, 78, 90, 90, + 0, 0, 0, 0, 95, 93, 92, 92, 20, 93, + 93, 27, 36, 35, 10, 11, 25, 23, 17, 24, + 16, 26, 89, 89, 19, 18, 42, 41, 43, 22, + 91, 14, 15, 28, 91, 91, 91, 91, 91, 91, + 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, + 12, 38, 13, 40, 6, 8, 5, 7, 92, 46, + 0, 88, 0, 21, 54, 37, 57, 0, 0, 0, + 0, 51, 89, 89, 52, 0, 2, 1, 53, 90, + 89, 0, 0, 9, 49, 44, 47, 48, 45, 50, + 91, 55, 29, 62, 91, 91, 91, 91, 79, 91, - 90, 90, 90, 90, 71, 90, 90, 90, 90, 90, - 90, 90, 90, 90, 90, 90, 90, 57, 38, 6, - 5, 4, 3, 29, 0, 0, 0, 0, 0, 60, - 1, 0, 89, 0, 89, 88, 88, 58, 59, 55, - 90, 90, 90, 90, 90, 90, 90, 90, 76, 90, - 90, 89, 79, 62, 90, 90, 90, 90, 90, 90, - 90, 33, 31, 0, 0, 0, 0, 0, 90, 75, - 90, 90, 90, 90, 73, 90, 83, 90, 72, 90, - 90, 90, 90, 90, 90, 90, 90, 31, 32, 30, - 0, 89, 85, 80, 90, 63, 90, 70, 90, 90, + 91, 91, 91, 91, 91, 72, 91, 91, 91, 91, + 91, 91, 91, 91, 91, 91, 91, 91, 58, 39, + 6, 5, 4, 3, 30, 0, 0, 0, 0, 0, + 61, 1, 0, 90, 0, 90, 89, 89, 59, 60, + 56, 91, 91, 91, 91, 91, 91, 91, 91, 77, + 91, 91, 90, 80, 63, 91, 91, 91, 91, 91, + 91, 91, 34, 32, 0, 0, 0, 0, 0, 91, + 76, 91, 91, 91, 91, 74, 91, 84, 91, 73, + 91, 91, 91, 91, 91, 91, 91, 91, 32, 33, + 31, 0, 90, 86, 81, 91, 64, 91, 71, 91, - 90, 90, 90, 90, 90, 90, 64, 77, 90, 84, - 82, 67, 81, 69, 65, 74, 90, 68, 90, 66, - 86, 0 + 91, 91, 91, 91, 91, 91, 91, 65, 78, 91, + 85, 83, 68, 82, 70, 66, 75, 91, 69, 91, + 67, 87, 0 } ; static const YY_CHAR yy_ec[256] = @@ -422,67 +420,67 @@ static const YY_CHAR yy_meta[65] = 1, 1, 1, 1 } ; -static const flex_int16_t yy_base[233] = +static const flex_int16_t yy_base[234] = { 0, - 0, 0, 62, 63, 366, 367, 65, 67, 340, 66, - 358, 338, 64, 327, 367, 367, 367, 63, 367, 72, - 345, 61, 84, 90, 367, 367, 52, 69, 73, 367, - 0, 367, 367, 82, 306, 306, 74, 45, 66, 307, + 0, 0, 62, 63, 367, 368, 65, 67, 341, 66, + 359, 339, 64, 328, 368, 368, 368, 63, 368, 72, + 346, 61, 84, 90, 339, 368, 52, 69, 73, 368, + 0, 368, 368, 82, 306, 306, 74, 45, 66, 307, 306, 77, 300, 317, 298, 311, 75, 293, 301, 305, - 367, 60, 367, 367, 0, 367, 101, 337, 126, 367, - 126, 367, 345, 367, 367, 367, 367, 338, 115, 120, - 127, 367, 139, 146, 367, 330, 367, 0, 367, 185, - 161, 0, 131, 320, 367, 367, 367, 367, 319, 0, - 367, 318, 0, 300, 287, 290, 296, 0, 284, 298, + 368, 60, 368, 368, 0, 368, 101, 337, 126, 368, + 126, 368, 345, 368, 368, 368, 368, 338, 115, 120, + 127, 368, 139, 146, 368, 330, 368, 0, 368, 185, + 161, 0, 131, 368, 320, 368, 368, 368, 368, 319, + 0, 368, 318, 0, 300, 287, 290, 296, 0, 284, - 280, 280, 281, 278, 0, 280, 288, 275, 279, 289, - 272, 266, 272, 278, 271, 276, 275, 367, 367, 0, - 139, 367, 367, 367, 311, 165, 177, 310, 0, 367, - 0, 150, 169, 198, 367, 169, 157, 367, 367, 367, - 280, 275, 137, 178, 274, 273, 265, 271, 0, 261, - 260, 0, 0, 0, 254, 267, 252, 252, 264, 254, - 256, 367, 367, 213, 216, 294, 177, 223, 255, 0, - 246, 254, 246, 248, 0, 256, 0, 243, 0, 242, - 241, 241, 246, 240, 189, 226, 232, 367, 367, 367, - 227, 231, 0, 0, 217, 0, 197, 0, 187, 171, + 298, 280, 280, 281, 278, 0, 280, 288, 275, 279, + 289, 272, 266, 272, 278, 271, 276, 275, 368, 368, + 0, 139, 368, 368, 368, 311, 165, 177, 310, 0, + 368, 0, 150, 169, 198, 368, 169, 157, 368, 368, + 368, 280, 275, 137, 178, 274, 273, 265, 271, 0, + 261, 260, 0, 0, 0, 254, 267, 252, 252, 264, + 254, 256, 368, 368, 213, 216, 294, 177, 223, 255, + 0, 246, 254, 246, 248, 0, 256, 0, 243, 0, + 242, 241, 241, 246, 240, 189, 226, 232, 368, 368, + 368, 227, 231, 0, 0, 217, 0, 197, 0, 187, - 173, 167, 153, 162, 160, 151, 0, 0, 137, 0, - 0, 0, 0, 0, 0, 0, 120, 0, 110, 0, - 0, 367, 252, 258, 264, 266, 272, 278, 284, 139, - 288, 132 + 171, 173, 167, 153, 162, 160, 151, 0, 0, 137, + 0, 0, 0, 0, 0, 0, 0, 120, 0, 110, + 0, 0, 368, 252, 258, 264, 266, 272, 278, 284, + 139, 288, 132 } ; -static const flex_int16_t yy_def[233] = +static const flex_int16_t yy_def[234] = { 0, - 222, 1, 223, 223, 222, 222, 222, 222, 222, 224, - 222, 222, 222, 225, 222, 222, 222, 222, 222, 222, - 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, - 226, 222, 222, 222, 226, 226, 226, 226, 226, 226, - 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, - 222, 222, 222, 222, 227, 222, 222, 222, 222, 222, - 224, 222, 224, 222, 222, 222, 222, 222, 228, 222, - 222, 222, 222, 222, 222, 222, 222, 229, 222, 222, - 222, 230, 222, 222, 222, 222, 222, 222, 222, 226, - 222, 222, 226, 226, 226, 226, 226, 226, 226, 226, + 223, 1, 224, 224, 223, 223, 223, 223, 223, 225, + 223, 223, 223, 226, 223, 223, 223, 223, 223, 223, + 223, 223, 223, 223, 223, 223, 223, 223, 223, 223, + 227, 223, 223, 223, 227, 227, 227, 227, 227, 227, + 227, 227, 227, 227, 227, 227, 227, 227, 227, 227, + 223, 223, 223, 223, 228, 223, 223, 223, 223, 223, + 225, 223, 225, 223, 223, 223, 223, 223, 229, 223, + 223, 223, 223, 223, 223, 223, 223, 230, 223, 223, + 223, 231, 223, 223, 223, 223, 223, 223, 223, 223, + 227, 223, 223, 227, 227, 227, 227, 227, 227, 227, - 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, - 226, 226, 226, 226, 226, 226, 226, 222, 222, 227, - 222, 222, 222, 222, 222, 222, 222, 231, 232, 222, - 229, 222, 222, 222, 222, 230, 222, 222, 222, 222, - 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, - 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, - 226, 222, 222, 222, 222, 231, 232, 222, 226, 226, - 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, - 226, 226, 226, 226, 226, 226, 226, 222, 222, 222, - 222, 222, 226, 226, 226, 226, 226, 226, 226, 226, + 227, 227, 227, 227, 227, 227, 227, 227, 227, 227, + 227, 227, 227, 227, 227, 227, 227, 227, 223, 223, + 228, 223, 223, 223, 223, 223, 223, 223, 232, 233, + 223, 230, 223, 223, 223, 223, 231, 223, 223, 223, + 223, 227, 227, 227, 227, 227, 227, 227, 227, 227, + 227, 227, 227, 227, 227, 227, 227, 227, 227, 227, + 227, 227, 223, 223, 223, 223, 232, 233, 223, 227, + 227, 227, 227, 227, 227, 227, 227, 227, 227, 227, + 227, 227, 227, 227, 227, 227, 227, 227, 223, 223, + 223, 223, 223, 227, 227, 227, 227, 227, 227, 227, - 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, - 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, - 226, 0, 222, 222, 222, 222, 222, 222, 222, 222, - 222, 222 + 227, 227, 227, 227, 227, 227, 227, 227, 227, 227, + 227, 227, 227, 227, 227, 227, 227, 227, 227, 227, + 227, 227, 0, 223, 223, 223, 223, 223, 223, 223, + 223, 223, 223 } ; -static const flex_int16_t yy_nxt[432] = +static const flex_int16_t yy_nxt[433] = { 0, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 24, @@ -491,50 +489,50 @@ static const flex_int16_t yy_nxt[432] = 38, 39, 40, 41, 31, 42, 31, 31, 43, 44, 31, 45, 46, 47, 48, 49, 50, 31, 31, 31, 51, 52, 53, 54, 56, 56, 59, 59, 59, 59, - 62, 66, 77, 57, 57, 84, 85, 78, 58, 58, - 70, 71, 71, 71, 118, 79, 97, 72, 67, 73, - 74, 74, 74, 86, 87, 98, 75, 88, 89, 80, + 62, 66, 77, 57, 57, 85, 86, 78, 58, 58, + 70, 71, 71, 71, 119, 79, 98, 72, 67, 73, + 74, 74, 74, 87, 88, 99, 75, 89, 90, 80, - 63, 81, 81, 81, 74, 80, 91, 74, 74, 74, - 74, 95, 121, 99, 100, 101, 82, 122, 92, 105, - 112, 119, 83, 102, 96, 106, 107, 59, 59, 113, - 62, 114, 126, 126, 126, 80, 167, 71, 71, 71, - 71, 82, 80, 136, 71, 71, 71, 71, 137, 137, - 121, 221, 129, 127, 80, 122, 74, 74, 74, 74, - 63, 80, 220, 74, 74, 74, 74, 133, 133, 133, - 133, 129, 128, 163, 137, 137, 80, 129, 81, 81, - 81, 74, 164, 164, 164, 162, 133, 133, 133, 133, - 171, 172, 219, 218, 165, 165, 129, 132, 135, 132, + 63, 81, 81, 81, 74, 80, 92, 74, 74, 74, + 74, 96, 122, 100, 101, 102, 82, 123, 93, 106, + 113, 120, 83, 103, 97, 107, 108, 59, 59, 114, + 62, 115, 127, 127, 127, 80, 168, 71, 71, 71, + 71, 82, 80, 137, 71, 71, 71, 71, 138, 138, + 122, 222, 130, 128, 80, 123, 74, 74, 74, 74, + 63, 80, 221, 74, 74, 74, 74, 134, 134, 134, + 134, 130, 129, 164, 138, 138, 80, 130, 81, 81, + 81, 74, 165, 165, 165, 163, 134, 134, 134, 134, + 172, 173, 220, 219, 166, 166, 130, 133, 136, 133, - 168, 217, 133, 133, 133, 133, 216, 215, 168, 214, - 132, 135, 132, 134, 135, 133, 133, 133, 133, 173, - 168, 188, 213, 174, 189, 212, 134, 135, 168, 205, - 164, 164, 164, 165, 165, 191, 211, 191, 210, 206, - 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, - 192, 192, 55, 55, 55, 55, 55, 55, 61, 61, - 61, 61, 61, 61, 68, 68, 209, 68, 68, 68, - 90, 90, 120, 208, 120, 207, 120, 120, 125, 204, - 125, 125, 125, 125, 131, 203, 131, 131, 131, 131, - 166, 202, 166, 201, 200, 199, 198, 197, 196, 195, + 169, 218, 134, 134, 134, 134, 217, 216, 169, 215, + 133, 136, 133, 135, 136, 134, 134, 134, 134, 174, + 169, 189, 214, 175, 190, 213, 135, 136, 169, 206, + 165, 165, 165, 166, 166, 192, 212, 192, 211, 207, + 193, 193, 193, 193, 193, 193, 193, 193, 193, 193, + 193, 193, 55, 55, 55, 55, 55, 55, 61, 61, + 61, 61, 61, 61, 68, 68, 210, 68, 68, 68, + 91, 91, 121, 209, 121, 208, 121, 121, 126, 205, + 126, 126, 126, 126, 132, 204, 132, 132, 132, 132, + 167, 203, 167, 202, 201, 200, 199, 198, 197, 196, - 194, 193, 190, 187, 186, 185, 184, 183, 182, 181, - 180, 179, 178, 177, 176, 175, 170, 169, 162, 162, - 161, 160, 159, 158, 157, 156, 155, 154, 152, 153, - 152, 151, 150, 149, 148, 147, 146, 145, 144, 143, - 142, 141, 140, 139, 138, 130, 124, 222, 123, 117, - 116, 115, 111, 110, 109, 108, 104, 103, 94, 93, - 76, 69, 65, 64, 60, 222, 5, 222, 222, 222, - 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, - 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, - 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, + 195, 194, 191, 188, 187, 186, 185, 184, 183, 182, + 181, 180, 179, 178, 177, 176, 171, 170, 163, 163, + 162, 161, 160, 159, 158, 157, 156, 155, 153, 154, + 153, 152, 151, 150, 149, 148, 147, 146, 145, 144, + 143, 142, 141, 140, 139, 131, 125, 223, 124, 118, + 117, 116, 112, 111, 110, 109, 105, 104, 95, 94, + 84, 76, 69, 65, 64, 60, 223, 5, 223, 223, + 223, 223, 223, 223, 223, 223, 223, 223, 223, 223, + 223, 223, 223, 223, 223, 223, 223, 223, 223, 223, + 223, 223, 223, 223, 223, 223, 223, 223, 223, 223, - 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, - 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, - 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, - 222 + 223, 223, 223, 223, 223, 223, 223, 223, 223, 223, + 223, 223, 223, 223, 223, 223, 223, 223, 223, 223, + 223, 223, 223, 223, 223, 223, 223, 223, 223, 223, + 223, 223 } ; -static const flex_int16_t yy_chk[432] = +static const flex_int16_t yy_chk[433] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -550,40 +548,40 @@ static const flex_int16_t yy_chk[432] = 10, 23, 23, 23, 23, 24, 34, 24, 24, 24, 24, 37, 57, 39, 39, 39, 23, 57, 34, 42, 47, 52, 23, 39, 37, 42, 42, 59, 59, 47, - 61, 47, 69, 69, 69, 70, 232, 70, 70, 70, - 70, 23, 71, 230, 71, 71, 71, 71, 83, 83, - 121, 219, 70, 69, 73, 121, 73, 73, 73, 73, - 61, 74, 217, 74, 74, 74, 74, 132, 132, 132, - 132, 73, 69, 126, 137, 137, 81, 70, 81, 81, - 81, 81, 126, 126, 126, 127, 133, 133, 133, 133, - 143, 143, 209, 206, 127, 127, 73, 80, 133, 80, + 61, 47, 69, 69, 69, 70, 233, 70, 70, 70, + 70, 23, 71, 231, 71, 71, 71, 71, 83, 83, + 122, 220, 70, 69, 73, 122, 73, 73, 73, 73, + 61, 74, 218, 74, 74, 74, 74, 133, 133, 133, + 133, 73, 69, 127, 138, 138, 81, 70, 81, 81, + 81, 81, 127, 127, 127, 128, 134, 134, 134, 134, + 144, 144, 210, 207, 128, 128, 73, 80, 134, 80, - 136, 205, 80, 80, 80, 80, 204, 203, 167, 202, - 134, 133, 134, 80, 80, 134, 134, 134, 134, 144, - 136, 164, 201, 144, 165, 200, 80, 80, 167, 185, - 164, 164, 164, 165, 165, 168, 199, 168, 197, 185, - 168, 168, 168, 168, 191, 191, 191, 191, 192, 192, - 192, 192, 223, 223, 223, 223, 223, 223, 224, 224, - 224, 224, 224, 224, 225, 225, 195, 225, 225, 225, - 226, 226, 227, 187, 227, 186, 227, 227, 228, 184, - 228, 228, 228, 228, 229, 183, 229, 229, 229, 229, - 231, 182, 231, 181, 180, 178, 176, 174, 173, 172, + 137, 206, 80, 80, 80, 80, 205, 204, 168, 203, + 135, 134, 135, 80, 80, 135, 135, 135, 135, 145, + 137, 165, 202, 145, 166, 201, 80, 80, 168, 186, + 165, 165, 165, 166, 166, 169, 200, 169, 198, 186, + 169, 169, 169, 169, 192, 192, 192, 192, 193, 193, + 193, 193, 224, 224, 224, 224, 224, 224, 225, 225, + 225, 225, 225, 225, 226, 226, 196, 226, 226, 226, + 227, 227, 228, 188, 228, 187, 228, 228, 229, 185, + 229, 229, 229, 229, 230, 184, 230, 230, 230, 230, + 232, 183, 232, 182, 181, 179, 177, 175, 174, 173, - 171, 169, 166, 161, 160, 159, 158, 157, 156, 155, - 151, 150, 148, 147, 146, 145, 142, 141, 128, 125, - 117, 116, 115, 114, 113, 112, 111, 110, 109, 108, - 107, 106, 104, 103, 102, 101, 100, 99, 97, 96, - 95, 94, 92, 89, 84, 76, 68, 63, 58, 50, + 172, 170, 167, 162, 161, 160, 159, 158, 157, 156, + 152, 151, 149, 148, 147, 146, 143, 142, 129, 126, + 118, 117, 116, 115, 114, 113, 112, 111, 110, 109, + 108, 107, 105, 104, 103, 102, 101, 100, 98, 97, + 96, 95, 93, 90, 85, 76, 68, 63, 58, 50, 49, 48, 46, 45, 44, 43, 41, 40, 36, 35, - 21, 14, 12, 11, 9, 5, 222, 222, 222, 222, - 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, - 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, - 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, + 25, 21, 14, 12, 11, 9, 5, 223, 223, 223, + 223, 223, 223, 223, 223, 223, 223, 223, 223, 223, + 223, 223, 223, 223, 223, 223, 223, 223, 223, 223, + 223, 223, 223, 223, 223, 223, 223, 223, 223, 223, - 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, - 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, - 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, - 222 + 223, 223, 223, 223, 223, 223, 223, 223, 223, 223, + 223, 223, 223, 223, 223, 223, 223, 223, 223, 223, + 223, 223, 223, 223, 223, 223, 223, 223, 223, 223, + 223, 223 } ; /* The intent behind this definition is that it'll catch @@ -908,13 +906,13 @@ yy_match: 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 >= 223 ) + if ( yy_current_state >= 224 ) 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] != 367 ); + while ( yy_base[yy_current_state] != 368 ); yy_find_action: yy_act = yy_accept[yy_current_state]; @@ -989,116 +987,121 @@ YY_RULE_SETUP case 9: YY_RULE_SETUP #line 63 "src/lexer.l" -{return LPAREN;} +{return SCOPE;} YY_BREAK case 10: YY_RULE_SETUP #line 64 "src/lexer.l" -{return RPAREN;} +{return LPAREN;} YY_BREAK case 11: YY_RULE_SETUP #line 65 "src/lexer.l" -{return LBRACE;} +{return RPAREN;} YY_BREAK case 12: YY_RULE_SETUP #line 66 "src/lexer.l" -{return RBRACE;} +{return LBRACE;} YY_BREAK case 13: YY_RULE_SETUP #line 67 "src/lexer.l" -{return LBRACKET;} +{return RBRACE;} YY_BREAK case 14: YY_RULE_SETUP #line 68 "src/lexer.l" -{return RBRACKET;} +{return LBRACKET;} YY_BREAK case 15: YY_RULE_SETUP #line 69 "src/lexer.l" -{return DOT;} +{return RBRACKET;} YY_BREAK case 16: YY_RULE_SETUP #line 70 "src/lexer.l" -{return COMMA;} +{return DOT;} YY_BREAK case 17: YY_RULE_SETUP #line 71 "src/lexer.l" -{return SEMICOLON;} +{return COMMA;} YY_BREAK case 18: YY_RULE_SETUP #line 72 "src/lexer.l" -{return COLON;} +{return SEMICOLON;} YY_BREAK case 19: YY_RULE_SETUP #line 73 "src/lexer.l" -{return BANG;} +{return COLON;} YY_BREAK case 20: YY_RULE_SETUP #line 74 "src/lexer.l" -{return PASTE;} +{return BANG;} YY_BREAK case 21: YY_RULE_SETUP #line 75 "src/lexer.l" -{return AT;} +{return PASTE;} YY_BREAK case 22: YY_RULE_SETUP -#line 77 "src/lexer.l" -{return PLUS;} +#line 76 "src/lexer.l" +{return AT;} YY_BREAK case 23: YY_RULE_SETUP #line 78 "src/lexer.l" -{return MINUS;} +{return PLUS;} YY_BREAK case 24: YY_RULE_SETUP #line 79 "src/lexer.l" -{return STAR;} +{return MINUS;} YY_BREAK case 25: YY_RULE_SETUP #line 80 "src/lexer.l" -{return DIV;} +{return STAR;} YY_BREAK case 26: YY_RULE_SETUP #line 81 "src/lexer.l" -{return REM;} +{return DIV;} YY_BREAK case 27: YY_RULE_SETUP #line 82 "src/lexer.l" -{return XOR;} +{return REM;} YY_BREAK case 28: YY_RULE_SETUP #line 83 "src/lexer.l" -{return POW;} +{return XOR;} YY_BREAK case 29: -/* rule 29 can match eol */ YY_RULE_SETUP -#line 85 "src/lexer.l" +#line 84 "src/lexer.l" +{return POW;} + YY_BREAK +case 30: +/* rule 30 can match eol */ +YY_RULE_SETUP +#line 86 "src/lexer.l" { /* regular character constant, 'a' */ yylval->integer = yytext[1]; return INT; } YY_BREAK -case 30: +case 31: YY_RULE_SETUP -#line 91 "src/lexer.l" +#line 92 "src/lexer.l" { /* hex character constant, '\xef' */ /* handling is slightly different from C, here it's more or less just @@ -1107,147 +1110,142 @@ YY_RULE_SETUP return INT; } YY_BREAK -case 31: +case 32: YY_RULE_SETUP -#line 99 "src/lexer.l" +#line 100 "src/lexer.l" { /* octal character constant, '\033' */ yylval->integer = strtoll(yytext + 2, NULL, 8); return INT; } YY_BREAK -case 32: +case 33: YY_RULE_SETUP -#line 105 "src/lexer.l" +#line 106 "src/lexer.l" { /* binary character constant, '\b101' */ yylval->integer = strtoll(yytext + 3, NULL, 2); return INT; } YY_BREAK -case 33: +case 34: YY_RULE_SETUP -#line 111 "src/lexer.l" +#line 112 "src/lexer.l" { /* escaped character constant */ yylval->integer = match_escape(yytext[2]); return INT; } YY_BREAK -case 34: -YY_RULE_SETUP -#line 117 "src/lexer.l" -{return SQUOTE;} - YY_BREAK case 35: YY_RULE_SETUP -#line 119 "src/lexer.l" -{return AND;} +#line 118 "src/lexer.l" +{return SQUOTE;} YY_BREAK case 36: YY_RULE_SETUP #line 120 "src/lexer.l" -{return LAND;} +{return AND;} YY_BREAK case 37: YY_RULE_SETUP #line 121 "src/lexer.l" -{return OR;} +{return LAND;} YY_BREAK case 38: YY_RULE_SETUP #line 122 "src/lexer.l" -{return LOR;} +{return OR;} YY_BREAK case 39: YY_RULE_SETUP -#line 124 "src/lexer.l" -{return TILDE;} +#line 123 "src/lexer.l" +{return LOR;} YY_BREAK case 40: YY_RULE_SETUP #line 125 "src/lexer.l" -{return TO;} +{return TILDE;} YY_BREAK case 41: YY_RULE_SETUP #line 126 "src/lexer.l" -{return LT;} +{return TO;} YY_BREAK case 42: YY_RULE_SETUP #line 127 "src/lexer.l" -{return GT;} +{return LT;} YY_BREAK case 43: YY_RULE_SETUP #line 128 "src/lexer.l" -{return LE;} +{return GT;} YY_BREAK case 44: YY_RULE_SETUP #line 129 "src/lexer.l" -{return GE;} +{return LE;} YY_BREAK case 45: YY_RULE_SETUP #line 130 "src/lexer.l" -{return NE;} +{return GE;} YY_BREAK case 46: YY_RULE_SETUP #line 131 "src/lexer.l" -{return EQ;} +{return NE;} YY_BREAK case 47: YY_RULE_SETUP -#line 133 "src/lexer.l" -{return FATARROW;} +#line 132 "src/lexer.l" +{return EQ;} YY_BREAK case 48: YY_RULE_SETUP -#line 135 "src/lexer.l" -{return LSHIFT;} +#line 134 "src/lexer.l" +{return FATARROW;} YY_BREAK case 49: YY_RULE_SETUP #line 136 "src/lexer.l" -{return RSHIFT;} +{return LSHIFT;} YY_BREAK case 50: YY_RULE_SETUP -#line 138 "src/lexer.l" -{return PLUSSELF;} +#line 137 "src/lexer.l" +{return RSHIFT;} YY_BREAK case 51: YY_RULE_SETUP #line 139 "src/lexer.l" -{return MINUSSELF;} +{return PLUSSELF;} YY_BREAK case 52: YY_RULE_SETUP #line 140 "src/lexer.l" -{return DIVSELF;} +{return MINUSSELF;} YY_BREAK case 53: YY_RULE_SETUP #line 141 "src/lexer.l" -{return REMSELF;} +{return DIVSELF;} YY_BREAK case 54: YY_RULE_SETUP #line 142 "src/lexer.l" -{return XORSELF;} +{return REMSELF;} YY_BREAK case 55: YY_RULE_SETUP #line 143 "src/lexer.l" -{return POWSELF;} +{return XORSELF;} YY_BREAK case 56: YY_RULE_SETUP #line 144 "src/lexer.l" -{return ORSELF;} +{return POWSELF;} YY_BREAK case 57: YY_RULE_SETUP @@ -1257,152 +1255,157 @@ YY_RULE_SETUP case 58: YY_RULE_SETUP #line 146 "src/lexer.l" -{return LSHIFTSELF;} +{return ORSELF;} YY_BREAK case 59: YY_RULE_SETUP #line 147 "src/lexer.l" -{return RSHIFTSELF;} +{return LSHIFTSELF;} YY_BREAK case 60: YY_RULE_SETUP #line 148 "src/lexer.l" -{return ELLIPSIS;} +{return RSHIFTSELF;} YY_BREAK case 61: YY_RULE_SETUP -#line 150 "src/lexer.l" -{return AS;} +#line 149 "src/lexer.l" +{return ELLIPSIS;} YY_BREAK case 62: YY_RULE_SETUP #line 151 "src/lexer.l" -{return PUB;} +{return AS;} YY_BREAK case 63: YY_RULE_SETUP #line 152 "src/lexer.l" -{return DEFER;} +{return PUB;} YY_BREAK case 64: YY_RULE_SETUP #line 153 "src/lexer.l" -{return UNION;} +{return DEFER;} YY_BREAK case 65: YY_RULE_SETUP #line 154 "src/lexer.l" -{return STRUCT;} +{return UNION;} YY_BREAK case 66: YY_RULE_SETUP #line 155 "src/lexer.l" -{return TYPEDEF;} +{return STRUCT;} YY_BREAK case 67: YY_RULE_SETUP #line 156 "src/lexer.l" -{return IMPORT;} +{return TYPEDEF;} YY_BREAK case 68: YY_RULE_SETUP #line 157 "src/lexer.l" -{return TYPEOF;} +{return IMPORT;} YY_BREAK case 69: YY_RULE_SETUP #line 158 "src/lexer.l" -{return SIZEOF;} +{return TYPEOF;} YY_BREAK case 70: YY_RULE_SETUP #line 159 "src/lexer.l" -{return EMBED;} +{return SIZEOF;} YY_BREAK case 71: YY_RULE_SETUP #line 160 "src/lexer.l" -{return IF;} +{return EMBED;} YY_BREAK case 72: YY_RULE_SETUP #line 161 "src/lexer.l" -{return GOTO;} +{return IF;} YY_BREAK case 73: YY_RULE_SETUP #line 162 "src/lexer.l" -{return ELSE;} +{return GOTO;} YY_BREAK case 74: YY_RULE_SETUP #line 163 "src/lexer.l" -{return SWITCH;} +{return ELSE;} YY_BREAK case 75: YY_RULE_SETUP #line 164 "src/lexer.l" -{return CASE;} +{return SWITCH;} YY_BREAK case 76: YY_RULE_SETUP #line 165 "src/lexer.l" -{return FOR;} +{return CASE;} YY_BREAK case 77: YY_RULE_SETUP #line 166 "src/lexer.l" -{return WHILE;} +{return FOR;} YY_BREAK case 78: YY_RULE_SETUP #line 167 "src/lexer.l" -{return DO;} +{return WHILE;} YY_BREAK case 79: YY_RULE_SETUP #line 168 "src/lexer.l" -{return MUT;} +{return DO;} YY_BREAK case 80: YY_RULE_SETUP #line 169 "src/lexer.l" -{return CONST;} +{return MUT;} YY_BREAK case 81: YY_RULE_SETUP #line 170 "src/lexer.l" -{return RETURN;} +{return CONST;} YY_BREAK case 82: YY_RULE_SETUP #line 171 "src/lexer.l" -{return EXTERN;} +{return RETURN;} YY_BREAK case 83: YY_RULE_SETUP #line 172 "src/lexer.l" -{return ENUM;} +{return EXTERN;} YY_BREAK case 84: YY_RULE_SETUP #line 173 "src/lexer.l" -{return DEFINE;} +{return ENUM;} YY_BREAK case 85: YY_RULE_SETUP #line 174 "src/lexer.l" -{return BREAK;} +{return DEFINE;} YY_BREAK case 86: YY_RULE_SETUP #line 175 "src/lexer.l" -{return CONTINUE;} +{return BREAK;} YY_BREAK case 87: -/* rule 87 can match eol */ YY_RULE_SETUP -#line 177 "src/lexer.l" +#line 176 "src/lexer.l" +{return CONTINUE;} + YY_BREAK +case 88: +/* rule 88 can match eol */ +YY_RULE_SETUP +#line 178 "src/lexer.l" { /* seems risky, I know, but letting the parser choose when to allocate a * new string seems to help with syntax error cleanup */ @@ -1410,39 +1413,39 @@ YY_RULE_SETUP return STRING; } YY_BREAK -case 88: +case 89: YY_RULE_SETUP -#line 184 "src/lexer.l" +#line 185 "src/lexer.l" { yylval->integer = strtoll(yytext, 0, 0); return INT; } YY_BREAK -case 89: +case 90: YY_RULE_SETUP -#line 189 "src/lexer.l" +#line 190 "src/lexer.l" { yylval->dbl = strtod(yytext, 0); return FLOAT; } YY_BREAK -case 90: +case 91: YY_RULE_SETUP -#line 194 "src/lexer.l" +#line 195 "src/lexer.l" { yylval->str = yytext; return ID; } YY_BREAK -case 91: -/* rule 91 can match eol */ +case 92: +/* rule 92 can match eol */ YY_RULE_SETUP -#line 200 "src/lexer.l" +#line 201 "src/lexer.l" {/* skip whitespace */} YY_BREAK -case 92: +case 93: YY_RULE_SETUP -#line 202 "src/lexer.l" +#line 203 "src/lexer.l" { struct src_issue issue; issue.level = SRC_ERROR; @@ -1454,12 +1457,12 @@ YY_RULE_SETUP parser->failed = true; } YY_BREAK -case 93: +case 94: YY_RULE_SETUP -#line 212 "src/lexer.l" +#line 213 "src/lexer.l" YY_FATAL_ERROR( "flex scanner jammed" ); YY_BREAK -#line 1461 "gen/gen_lexer.c" +#line 1466 "gen/gen_lexer.c" case YY_STATE_EOF(INITIAL): case YY_STATE_EOF(SC_COMMENT): yyterminate(); @@ -1759,7 +1762,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner) 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 >= 223 ) + if ( yy_current_state >= 224 ) yy_c = yy_meta[yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; @@ -1788,11 +1791,11 @@ static int yy_get_next_buffer (yyscan_t yyscanner) 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 >= 223 ) + if ( yy_current_state >= 224 ) yy_c = yy_meta[yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; - yy_is_jam = (yy_current_state == 222); + yy_is_jam = (yy_current_state == 223); (void)yyg; return yy_is_jam ? 0 : yy_current_state; @@ -2591,6 +2594,6 @@ void yyfree (void * ptr , yyscan_t yyscanner) #define YYTABLES_NAME "yytables" -#line 212 "src/lexer.l" +#line 213 "src/lexer.l" diff --git a/gen/gen_lexer.h b/gen/gen_lexer.h new file mode 100644 index 0000000..9c3aadb --- /dev/null +++ b/gen/gen_lexer.h @@ -0,0 +1,493 @@ +#ifndef yyHEADER_H +#define yyHEADER_H 1 +#define yyIN_HEADER 1 + +#line 6 "gen/gen_lexer.h" + +#line 8 "gen/gen_lexer.h" + +#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 <stdio.h> +#include <string.h> +#include <errno.h> +#include <stdlib.h> + +/* end standard C headers. */ + +/* flex integer type definitions */ + +#ifndef FLEXINT_H +#define FLEXINT_H + +/* C99 systems have <inttypes.h>. 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 <inttypes.h> +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 + +/* An opaque pointer. */ +#ifndef YY_TYPEDEF_YY_SCANNER_T +#define YY_TYPEDEF_YY_SCANNER_T +typedef void* yyscan_t; +#endif + +/* For convenience, these vars (plus the bison vars far below) + are macros in the reentrant scanner. */ +#define yyin yyg->yyin_r +#define yyout yyg->yyout_r +#define yyextra yyg->yyextra_r +#define yyleng yyg->yyleng_r +#define yytext yyg->yytext_r +#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) +#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column) +#define yy_flex_debug yyg->yy_flex_debug_r + +/* 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 + +#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 + +#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; + + }; +#endif /* !YY_STRUCT_YY_BUFFER_STATE */ + +void yyrestart ( FILE *input_file , yyscan_t yyscanner ); +void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner ); +YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner ); +void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner ); +void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner ); +void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner ); +void yypop_buffer_state ( yyscan_t yyscanner ); + +YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner ); +YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner ); +YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner ); + +void *yyalloc ( yy_size_t , yyscan_t yyscanner ); +void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner ); +void yyfree ( void * , yyscan_t yyscanner ); + +/* Begin user sect3 */ + +#define yywrap(yyscanner) (/*CONSTCOND*/1) +#define YY_SKIP_YYWRAP + +#define yytext_ptr yytext_r + +#ifdef YY_HEADER_EXPORT_START_CONDITIONS +#define INITIAL 0 +#define SC_COMMENT 1 + +#endif + +#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 <unistd.h> +#endif + +#ifndef YY_EXTRA_TYPE +#define YY_EXTRA_TYPE void * +#endif + +int yylex_init (yyscan_t* scanner); + +int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner); + +/* Accessor methods to globals. + These are made visible to non-reentrant scanners for convenience. */ + +int yylex_destroy ( yyscan_t yyscanner ); + +int yyget_debug ( yyscan_t yyscanner ); + +void yyset_debug ( int debug_flag , yyscan_t yyscanner ); + +YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner ); + +void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner ); + +FILE *yyget_in ( yyscan_t yyscanner ); + +void yyset_in ( FILE * _in_str , yyscan_t yyscanner ); + +FILE *yyget_out ( yyscan_t yyscanner ); + +void yyset_out ( FILE * _out_str , yyscan_t yyscanner ); + + int yyget_leng ( yyscan_t yyscanner ); + +char *yyget_text ( yyscan_t yyscanner ); + +int yyget_lineno ( yyscan_t yyscanner ); + +void yyset_lineno ( int _line_number , yyscan_t yyscanner ); + +int yyget_column ( yyscan_t yyscanner ); + +void yyset_column ( int _column_no , yyscan_t yyscanner ); + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int yywrap ( yyscan_t yyscanner ); +#else +extern int yywrap ( yyscan_t yyscanner ); +#endif +#endif + +#ifndef yytext_ptr +static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen ( const char * , yyscan_t yyscanner); +#endif + +#ifndef YY_NO_INPUT + +#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 + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* 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 (yyscan_t yyscanner); + +#define YY_DECL int yylex (yyscan_t yyscanner) +#endif /* !YY_DECL */ + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + +#undef YY_NEW_FILE +#undef YY_FLUSH_BUFFER +#undef yy_set_bol +#undef yy_new_buffer +#undef yy_set_interactive +#undef YY_DO_BEFORE_ACTION + +#ifdef YY_DECL_IS_OURS +#undef YY_DECL_IS_OURS +#undef YY_DECL +#endif + +#ifndef yy_create_buffer_ALREADY_DEFINED +#undef yy_create_buffer +#endif +#ifndef yy_delete_buffer_ALREADY_DEFINED +#undef yy_delete_buffer +#endif +#ifndef yy_scan_buffer_ALREADY_DEFINED +#undef yy_scan_buffer +#endif +#ifndef yy_scan_string_ALREADY_DEFINED +#undef yy_scan_string +#endif +#ifndef yy_scan_bytes_ALREADY_DEFINED +#undef yy_scan_bytes +#endif +#ifndef yy_init_buffer_ALREADY_DEFINED +#undef yy_init_buffer +#endif +#ifndef yy_flush_buffer_ALREADY_DEFINED +#undef yy_flush_buffer +#endif +#ifndef yy_load_buffer_state_ALREADY_DEFINED +#undef yy_load_buffer_state +#endif +#ifndef yy_switch_to_buffer_ALREADY_DEFINED +#undef yy_switch_to_buffer +#endif +#ifndef yypush_buffer_state_ALREADY_DEFINED +#undef yypush_buffer_state +#endif +#ifndef yypop_buffer_state_ALREADY_DEFINED +#undef yypop_buffer_state +#endif +#ifndef yyensure_buffer_stack_ALREADY_DEFINED +#undef yyensure_buffer_stack +#endif +#ifndef yylex_ALREADY_DEFINED +#undef yylex +#endif +#ifndef yyrestart_ALREADY_DEFINED +#undef yyrestart +#endif +#ifndef yylex_init_ALREADY_DEFINED +#undef yylex_init +#endif +#ifndef yylex_init_extra_ALREADY_DEFINED +#undef yylex_init_extra +#endif +#ifndef yylex_destroy_ALREADY_DEFINED +#undef yylex_destroy +#endif +#ifndef yyget_debug_ALREADY_DEFINED +#undef yyget_debug +#endif +#ifndef yyset_debug_ALREADY_DEFINED +#undef yyset_debug +#endif +#ifndef yyget_extra_ALREADY_DEFINED +#undef yyget_extra +#endif +#ifndef yyset_extra_ALREADY_DEFINED +#undef yyset_extra +#endif +#ifndef yyget_in_ALREADY_DEFINED +#undef yyget_in +#endif +#ifndef yyset_in_ALREADY_DEFINED +#undef yyset_in +#endif +#ifndef yyget_out_ALREADY_DEFINED +#undef yyget_out +#endif +#ifndef yyset_out_ALREADY_DEFINED +#undef yyset_out +#endif +#ifndef yyget_leng_ALREADY_DEFINED +#undef yyget_leng +#endif +#ifndef yyget_text_ALREADY_DEFINED +#undef yyget_text +#endif +#ifndef yyget_lineno_ALREADY_DEFINED +#undef yyget_lineno +#endif +#ifndef yyset_lineno_ALREADY_DEFINED +#undef yyset_lineno +#endif +#ifndef yyget_column_ALREADY_DEFINED +#undef yyget_column +#endif +#ifndef yyset_column_ALREADY_DEFINED +#undef yyset_column +#endif +#ifndef yywrap_ALREADY_DEFINED +#undef yywrap +#endif +#ifndef yyget_lval_ALREADY_DEFINED +#undef yyget_lval +#endif +#ifndef yyset_lval_ALREADY_DEFINED +#undef yyset_lval +#endif +#ifndef yyget_lloc_ALREADY_DEFINED +#undef yyget_lloc +#endif +#ifndef yyset_lloc_ALREADY_DEFINED +#undef yyset_lloc +#endif +#ifndef yyalloc_ALREADY_DEFINED +#undef yyalloc +#endif +#ifndef yyrealloc_ALREADY_DEFINED +#undef yyrealloc +#endif +#ifndef yyfree_ALREADY_DEFINED +#undef yyfree +#endif +#ifndef yytext_ALREADY_DEFINED +#undef yytext +#endif +#ifndef yyleng_ALREADY_DEFINED +#undef yyleng +#endif +#ifndef yyin_ALREADY_DEFINED +#undef yyin +#endif +#ifndef yyout_ALREADY_DEFINED +#undef yyout +#endif +#ifndef yy_flex_debug_ALREADY_DEFINED +#undef yy_flex_debug +#endif +#ifndef yylineno_ALREADY_DEFINED +#undef yylineno +#endif +#ifndef yytables_fload_ALREADY_DEFINED +#undef yytables_fload +#endif +#ifndef yytables_destroy_ALREADY_DEFINED +#undef yytables_destroy +#endif +#ifndef yyTABLES_NAME_ALREADY_DEFINED +#undef yyTABLES_NAME +#endif + +#line 213 "src/lexer.l" + + +#line 492 "gen/gen_lexer.h" +#undef yyIN_HEADER +#endif /* yyHEADER_H */ diff --git a/gen/gen_parser.c b/gen/gen_parser.c index 1913d41..2182c59 100644 --- a/gen/gen_parser.c +++ b/gen/gen_parser.c @@ -1,5 +1,3 @@ -/* SPDX-License-Identifier: GPL-3.0-or-later */ - /* A Bison parser, made by GNU Bison 3.8.2. */ /* Bison implementation for Yacc-like parsers in C @@ -191,70 +189,71 @@ enum yysymbol_kind_t YYSYMBOL_RBRACKET = 77, /* "]" */ YYSYMBOL_AS = 78, /* "as" */ YYSYMBOL_DOT = 79, /* "." */ - YYSYMBOL_FATARROW = 80, /* "=>" */ - YYSYMBOL_YYACCEPT = 81, /* $accept */ - YYSYMBOL_id = 82, /* id */ - YYSYMBOL_var = 83, /* var */ - YYSYMBOL_embed = 84, /* embed */ - YYSYMBOL_import = 85, /* import */ - YYSYMBOL_assign = 86, /* assign */ - YYSYMBOL_binary_op = 87, /* binary_op */ - YYSYMBOL_unary_op = 88, /* unary_op */ - YYSYMBOL_arg = 89, /* arg */ - YYSYMBOL_arg_list = 90, /* arg_list */ - YYSYMBOL_param_decl = 91, /* param_decl */ - YYSYMBOL_decl_list = 92, /* decl_list */ - YYSYMBOL_call = 93, /* call */ - YYSYMBOL_defer = 94, /* defer */ - YYSYMBOL_expr = 95, /* expr */ - YYSYMBOL_while = 96, /* while */ - YYSYMBOL_do_while = 97, /* do_while */ - YYSYMBOL_goto = 98, /* goto */ - YYSYMBOL_statement = 99, /* statement */ - YYSYMBOL_statement_list = 100, /* statement_list */ - YYSYMBOL_body = 101, /* body */ - YYSYMBOL_macro_list = 102, /* macro_list */ - YYSYMBOL_macro = 103, /* macro */ - YYSYMBOL_expr_list = 104, /* expr_list */ - YYSYMBOL_struct_init = 105, /* struct_init */ - YYSYMBOL_struct_inits = 106, /* struct_inits */ - YYSYMBOL_struct_construct = 107, /* struct_construct */ - YYSYMBOL_init_expr = 108, /* init_expr */ - YYSYMBOL_cond = 109, /* cond */ - YYSYMBOL_expr_if = 110, /* expr_if */ - YYSYMBOL_if = 111, /* if */ - YYSYMBOL_for = 112, /* for */ - YYSYMBOL_case = 113, /* case */ - YYSYMBOL_case_list = 114, /* case_list */ - YYSYMBOL_switch = 115, /* switch */ - YYSYMBOL_const_for = 116, /* const_for */ - YYSYMBOL_const_if = 117, /* const_if */ - YYSYMBOL_const = 118, /* const */ - YYSYMBOL_func_sign = 119, /* func_sign */ - YYSYMBOL_variadic_sign = 120, /* variadic_sign */ - YYSYMBOL_type = 121, /* type */ - YYSYMBOL_var_decl = 122, /* var_decl */ - YYSYMBOL_var_init = 123, /* var_init */ - YYSYMBOL_proc = 124, /* proc */ - YYSYMBOL_lambda = 125, /* lambda */ - YYSYMBOL_struct_elem = 126, /* struct_elem */ - YYSYMBOL_struct_list = 127, /* struct_list */ - YYSYMBOL_union = 128, /* union */ - YYSYMBOL_generic = 129, /* generic */ - YYSYMBOL_generic_list = 130, /* generic_list */ - YYSYMBOL_struct = 131, /* struct */ - YYSYMBOL_template_elem = 132, /* template_elem */ - YYSYMBOL_template_list = 133, /* template_list */ - YYSYMBOL_type_list = 134, /* type_list */ - YYSYMBOL_type_alias = 135, /* type_alias */ - YYSYMBOL_type_template = 136, /* type_template */ - YYSYMBOL_enum_val = 137, /* enum_val */ - YYSYMBOL_enum_list = 138, /* enum_list */ - YYSYMBOL_enum = 139, /* enum */ - YYSYMBOL_top_if = 140, /* top_if */ - YYSYMBOL_top = 141, /* top */ - YYSYMBOL_unit = 142, /* unit */ - YYSYMBOL_input = 143 /* input */ + YYSYMBOL_SCOPE = 80, /* "::" */ + YYSYMBOL_FATARROW = 81, /* "=>" */ + YYSYMBOL_YYACCEPT = 82, /* $accept */ + YYSYMBOL_id = 83, /* id */ + YYSYMBOL_var = 84, /* var */ + YYSYMBOL_embed = 85, /* embed */ + YYSYMBOL_import = 86, /* import */ + YYSYMBOL_assign = 87, /* assign */ + YYSYMBOL_binary_op = 88, /* binary_op */ + YYSYMBOL_unary_op = 89, /* unary_op */ + YYSYMBOL_arg = 90, /* arg */ + YYSYMBOL_arg_list = 91, /* arg_list */ + YYSYMBOL_param_decl = 92, /* param_decl */ + YYSYMBOL_decl_list = 93, /* decl_list */ + YYSYMBOL_call = 94, /* call */ + YYSYMBOL_defer = 95, /* defer */ + YYSYMBOL_expr = 96, /* expr */ + YYSYMBOL_while = 97, /* while */ + YYSYMBOL_do_while = 98, /* do_while */ + YYSYMBOL_goto = 99, /* goto */ + YYSYMBOL_statement = 100, /* statement */ + YYSYMBOL_statement_list = 101, /* statement_list */ + YYSYMBOL_body = 102, /* body */ + YYSYMBOL_macro_list = 103, /* macro_list */ + YYSYMBOL_macro = 104, /* macro */ + YYSYMBOL_expr_list = 105, /* expr_list */ + YYSYMBOL_struct_init = 106, /* struct_init */ + YYSYMBOL_struct_inits = 107, /* struct_inits */ + YYSYMBOL_struct_construct = 108, /* struct_construct */ + YYSYMBOL_init_expr = 109, /* init_expr */ + YYSYMBOL_cond = 110, /* cond */ + YYSYMBOL_expr_if = 111, /* expr_if */ + YYSYMBOL_if = 112, /* if */ + YYSYMBOL_for = 113, /* for */ + YYSYMBOL_case = 114, /* case */ + YYSYMBOL_case_list = 115, /* case_list */ + YYSYMBOL_switch = 116, /* switch */ + YYSYMBOL_const_for = 117, /* const_for */ + YYSYMBOL_const_if = 118, /* const_if */ + YYSYMBOL_const = 119, /* const */ + YYSYMBOL_func_sign = 120, /* func_sign */ + YYSYMBOL_variadic_sign = 121, /* variadic_sign */ + YYSYMBOL_type = 122, /* type */ + YYSYMBOL_var_decl = 123, /* var_decl */ + YYSYMBOL_var_init = 124, /* var_init */ + YYSYMBOL_proc = 125, /* proc */ + YYSYMBOL_lambda = 126, /* lambda */ + YYSYMBOL_struct_elem = 127, /* struct_elem */ + YYSYMBOL_struct_list = 128, /* struct_list */ + YYSYMBOL_union = 129, /* union */ + YYSYMBOL_generic = 130, /* generic */ + YYSYMBOL_generic_list = 131, /* generic_list */ + YYSYMBOL_struct = 132, /* struct */ + YYSYMBOL_template_elem = 133, /* template_elem */ + YYSYMBOL_template_list = 134, /* template_list */ + YYSYMBOL_type_list = 135, /* type_list */ + YYSYMBOL_type_alias = 136, /* type_alias */ + YYSYMBOL_type_template = 137, /* type_template */ + YYSYMBOL_enum_val = 138, /* enum_val */ + YYSYMBOL_enum_list = 139, /* enum_list */ + YYSYMBOL_enum = 140, /* enum */ + YYSYMBOL_top_if = 141, /* top_if */ + YYSYMBOL_top = 142, /* top */ + YYSYMBOL_unit = 143, /* unit */ + YYSYMBOL_input = 144 /* input */ }; typedef enum yysymbol_kind_t yysymbol_kind_t; @@ -585,19 +584,19 @@ union yyalloc /* YYFINAL -- State number of the termination state. */ #define YYFINAL 57 /* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 1993 +#define YYLAST 1987 /* YYNTOKENS -- Number of terminals. */ -#define YYNTOKENS 81 +#define YYNTOKENS 82 /* YYNNTS -- Number of nonterminals. */ #define YYNNTS 63 /* YYNRULES -- Number of rules. */ -#define YYNRULES 215 +#define YYNRULES 216 /* YYNSTATES -- Number of states. */ -#define YYNSTATES 432 +#define YYNSTATES 434 /* YYMAXUTOK -- Last valid token kind. */ -#define YYMAXUTOK 335 +#define YYMAXUTOK 336 /* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM @@ -644,35 +643,35 @@ static const yytype_int8 yytranslate[] = 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, - 75, 76, 77, 78, 79, 80 + 75, 76, 77, 78, 79, 80, 81 }; #if YYDEBUG /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ static const yytype_int16 yyrline[] = { - 0, 148, 148, 154, 155, 158, 161, 164, 165, 168, - 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, - 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, - 189, 192, 195, 196, 197, 198, 199, 200, 203, 204, - 205, 206, 207, 210, 211, 212, 215, 216, 219, 221, - 222, 223, 224, 228, 229, 232, 236, 237, 238, 239, - 240, 241, 242, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 260, 263, 269, 271, 272, - 273, 274, 275, 277, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, - 294, 310, 311, 314, 315, 318, 319, 322, 326, 333, - 339, 340, 343, 344, 350, 351, 354, 357, 358, 359, - 360, 363, 364, 368, 369, 372, 373, 374, 377, 380, - 383, 384, 387, 390, 397, 401, 406, 414, 416, 420, - 423, 425, 427, 429, 433, 434, 441, 442, 446, 449, - 453, 457, 461, 466, 470, 471, 474, 475, 479, 485, - 489, 495, 498, 501, 502, 505, 508, 513, 514, 515, - 518, 521, 528, 529, 530, 531, 534, 535, 538, 539, - 542, 547, 550, 556, 557, 560, 561, 562, 565, 566, - 572, 576, 580, 588, 589, 590, 591, 592, 593, 594, - 595, 596, 597, 598, 599, 600, 601, 602, 603, 604, - 605, 606, 621, 622, 625, 626 + 0, 150, 150, 156, 157, 160, 163, 166, 167, 170, + 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 194, 197, 198, 199, 200, 201, 202, 205, 206, + 207, 208, 209, 212, 213, 214, 217, 218, 221, 223, + 224, 225, 226, 230, 231, 234, 238, 239, 240, 241, + 242, 243, 244, 248, 249, 250, 251, 252, 253, 254, + 255, 256, 257, 258, 259, 260, 263, 266, 272, 274, + 275, 276, 277, 278, 280, 281, 282, 283, 284, 285, + 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, + 296, 297, 313, 314, 317, 318, 321, 322, 325, 329, + 336, 342, 343, 346, 347, 353, 354, 357, 360, 361, + 362, 363, 366, 367, 371, 372, 375, 376, 377, 380, + 383, 386, 387, 390, 393, 400, 404, 409, 417, 419, + 423, 426, 428, 430, 432, 436, 437, 444, 445, 449, + 452, 456, 460, 464, 469, 473, 474, 477, 478, 482, + 488, 492, 498, 501, 504, 505, 508, 511, 516, 517, + 518, 521, 524, 531, 532, 533, 534, 537, 538, 541, + 542, 545, 550, 553, 559, 560, 563, 564, 565, 568, + 569, 575, 579, 583, 591, 592, 593, 594, 595, 596, + 597, 598, 599, 600, 601, 602, 603, 604, 605, 606, + 607, 608, 609, 624, 625, 628, 629 }; #endif @@ -700,10 +699,10 @@ static const char *const yytname[] = "\"continue\"", "\"switch\"", "\"case\"", "\"for\"", "\"while\"", "\"do\"", "\"mut\"", "\"return\"", "\"const\"", "\"extern\"", "\"enum\"", "\"define\"", "\"(\"", "\")\"", "\"{\"", "\"}\"", "\"[\"", "\"]\"", - "\"as\"", "\".\"", "\"=>\"", "$accept", "id", "var", "embed", "import", - "assign", "binary_op", "unary_op", "arg", "arg_list", "param_decl", - "decl_list", "call", "defer", "expr", "while", "do_while", "goto", - "statement", "statement_list", "body", "macro_list", "macro", + "\"as\"", "\".\"", "\"::\"", "\"=>\"", "$accept", "id", "var", "embed", + "import", "assign", "binary_op", "unary_op", "arg", "arg_list", + "param_decl", "decl_list", "call", "defer", "expr", "while", "do_while", + "goto", "statement", "statement_list", "body", "macro_list", "macro", "expr_list", "struct_init", "struct_inits", "struct_construct", "init_expr", "cond", "expr_if", "if", "for", "case", "case_list", "switch", "const_for", "const_if", "const", "func_sign", "variadic_sign", @@ -721,12 +720,12 @@ yysymbol_name (yysymbol_kind_t yysymbol) } #endif -#define YYPACT_NINF (-248) +#define YYPACT_NINF (-235) #define yypact_value_is_default(Yyn) \ ((Yyn) == YYPACT_NINF) -#define YYTABLE_NINF (-216) +#define YYTABLE_NINF (-217) #define yytable_value_is_error(Yyn) \ 0 @@ -735,50 +734,50 @@ yysymbol_name (yysymbol_kind_t yysymbol) STATE-NUM. */ static const yytype_int16 yypact[] = { - 323, -248, -248, -248, 227, 47, 47, 17, 29, 47, - 47, 47, 330, 57, 62, -248, 80, -248, -248, -248, - 81, -248, -248, 203, -248, 95, 98, 103, -248, -248, - -248, 109, -248, -248, 15, 25, -248, 1116, -248, 61, - 32, 64, 42, 1116, 132, 160, 68, 491, 65, -248, - 72, -248, -248, -248, 982, -248, -248, -248, -248, -248, - -248, 47, 47, 22, -248, -248, -248, -248, 1116, 47, - 1116, 1116, 1116, 1116, 1116, -248, 70, 79, 1116, 47, - 58, 82, -248, -248, -248, -248, -248, -248, 1209, -248, - 68, -248, 58, 47, 23, -248, -248, 74, 982, -248, - 982, -248, -248, 58, 518, 108, 27, -248, 114, 58, - 1273, 58, 752, -248, 1146, 569, 1914, 85, -248, -248, - 58, 117, 96, 333, -248, 161, 100, 47, -248, 151, - 166, -248, 33, 102, 74, -248, 74, 74, 409, 1498, - 74, 1116, 173, 536, 1337, 80, 106, 136, 116, -248, - 904, 1060, 1116, 1116, 1116, 1116, 1116, 1116, 1116, 1116, - 1116, 1116, 1116, 1116, 1116, 1116, 1116, 1116, 1116, 1116, - 1116, 1116, 1116, 1116, 1116, 1116, 1116, 1116, 1116, 1116, - 1116, 699, 58, 47, -21, 112, 193, 158, 135, 72, - 51, -248, -248, 138, 58, 58, 58, 47, -248, 208, - 58, -248, 58, 174, 153, -248, -248, 47, 1146, 214, - 220, 1116, 1014, 1116, 72, 936, -16, -248, 408, 221, - 232, 1401, -248, -248, 233, 666, 170, -248, -248, -248, - -248, -248, -248, -248, 237, -248, -248, 1090, 1914, 72, - 47, 206, 183, -248, 58, -248, 47, 185, 47, -248, - 75, -248, 251, -248, -248, -248, 1465, 190, -248, -248, - 47, 61, 1116, -248, 545, 217, 194, -248, -248, 1914, - -248, -2, -2, -2, 409, 409, 1242, 1442, 1498, 1434, - 1370, 1306, 842, 842, 842, 842, 766, 766, 172, 172, - 1914, 1914, 1914, 1914, 1914, 1914, 1914, 1914, 1914, 1914, - 191, -248, -248, 47, 1116, 47, -248, -248, 47, 72, - -248, -248, 189, -248, 197, -248, -248, 58, -248, -248, - 72, -248, -248, 1529, 266, 1593, 219, -248, 275, 1116, - 47, -248, -248, -248, -248, -248, -248, -248, -248, -248, - -248, 215, 229, 281, 569, -248, -248, -248, 47, -248, - 47, 47, -248, -248, -248, -248, 72, -248, 1014, -248, - 234, 218, 1914, -248, 222, -248, 58, -248, -248, 236, - 228, 1116, -248, 1116, -248, 1593, 288, -248, -24, 982, - -248, 225, 231, 226, -248, -248, -23, -248, 72, 238, - -20, 1116, 228, 235, 1658, 1722, 244, 1116, -248, -248, - -248, -248, 239, -248, 699, -248, -248, -248, -248, -248, - 1786, -248, -248, 1116, -248, -17, 1850, 72, 47, 240, - 828, 1593, -248, -248, 1116, -248, 241, -248, -248, -248, - -248, -248 + 563, -235, -235, -235, 322, 51, 51, 17, 15, 51, + 51, 51, 332, 67, 81, -235, 111, -235, -235, -235, + 114, -235, -235, 96, -235, 131, 126, 128, -235, -235, + -235, 143, -235, -235, -16, 25, -235, 1110, -235, 85, + 39, 87, 42, 1110, 68, 134, 82, 494, 90, -235, + 80, -235, -235, -235, 976, -235, -235, -235, -235, -235, + -235, 51, 51, 127, -235, -235, -235, -235, 1110, 51, + 1110, 1110, 1110, 1110, 1110, -235, 100, 104, 1110, 51, + 167, -51, -235, -235, -235, -235, -235, -235, 1203, -235, + 82, -235, 167, 51, 34, -235, -235, 89, 976, -235, + 976, -235, -235, 167, 411, 129, 27, -235, 137, 167, + 1267, 167, 746, -235, 1140, 573, 1908, 101, -235, -235, + 167, 139, 115, 221, -235, 179, 116, 51, -235, 265, + 180, -235, 33, 117, 89, -235, 89, 89, 331, 591, + 89, 1110, 188, 218, 1331, 111, 121, 157, 130, -235, + 898, 167, 1054, 1110, 1110, 1110, 1110, 1110, 1110, 1110, + 1110, 1110, 1110, 1110, 1110, 1110, 1110, 1110, 1110, 1110, + 1110, 1110, 1110, 1110, 1110, 1110, 1110, 1110, 1110, 1110, + 1110, 1110, 1266, 167, 51, -21, 135, 203, 164, 145, + 80, 32, -235, -235, 141, 167, 167, 167, 51, -235, + 209, 167, -235, 167, 170, 150, -235, -235, 51, 1140, + 222, 227, 1110, 1008, 1110, 80, 930, -4, -235, 246, + 234, 236, 1395, -235, -235, 238, 670, 176, -235, -235, + -235, -235, -235, -235, -235, 244, -235, -235, 1084, 1908, + 80, 51, 212, 189, -235, 167, -235, 51, 192, 51, + -235, -7, -235, 257, -235, -235, -235, 1459, 195, -235, + -235, 51, 85, 1110, -235, 249, 225, 197, -235, -235, + -235, 1908, -235, 8, 8, 8, 331, 331, 1364, 519, + 591, 1556, 1492, 1428, 836, 836, 836, 836, 760, 760, + 585, 585, 1908, 1908, 1908, 1908, 1908, 1908, 1908, 1908, + 1908, 1908, 199, -235, -235, 51, 1110, 51, -235, -235, + 51, 80, -235, -235, 198, -235, 207, -235, -235, 167, + -235, -235, 80, -235, -235, 1523, 266, 1587, 217, -235, + 281, 1110, 51, -235, -235, -235, -235, -235, -235, -235, + -235, -235, -235, 219, 237, 288, 573, -235, -235, -235, + 51, -235, 51, 51, -235, -235, -235, -235, 80, -235, + 1008, -235, 241, 226, 1908, -235, 229, -235, 167, -235, + -235, 242, 247, 1110, -235, 1110, -235, 1587, 292, -235, + -31, 976, -235, 231, 235, 245, -235, -235, -23, -235, + 80, 240, -20, 1110, 247, 248, 1652, 1716, 253, 1110, + -235, -235, -235, -235, 230, -235, 1266, -235, -235, -235, + -235, -235, 1780, -235, -235, 1110, -235, -10, 1844, 80, + 51, 252, 822, 1587, -235, -235, 1110, -235, 259, -235, + -235, -235, -235, -235 }; /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. @@ -786,73 +785,73 @@ static const yytype_int16 yypact[] = means the default is an error. */ static const yytype_uint8 yydefact[] = { - 0, 211, 2, 193, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 197, 3, 4, 195, 196, - 0, 201, 194, 0, 214, 0, 0, 0, 205, 204, - 203, 0, 208, 202, 0, 0, 6, 0, 198, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 146, 144, - 0, 155, 209, 199, 0, 200, 213, 1, 210, 206, - 207, 0, 0, 0, 180, 60, 61, 62, 0, 0, + 0, 212, 2, 194, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 198, 3, 4, 196, 197, + 0, 202, 195, 0, 215, 0, 0, 0, 206, 205, + 204, 0, 209, 203, 0, 0, 6, 0, 199, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 147, 145, + 0, 156, 210, 200, 0, 201, 214, 1, 211, 207, + 208, 0, 0, 0, 181, 60, 61, 62, 0, 0, 0, 0, 0, 0, 0, 59, 0, 0, 0, 0, - 0, 56, 73, 64, 67, 68, 65, 66, 0, 74, - 0, 160, 0, 0, 0, 147, 149, 152, 0, 153, - 0, 154, 143, 0, 146, 52, 0, 48, 51, 0, - 0, 0, 0, 159, 0, 0, 117, 119, 156, 118, - 0, 169, 0, 0, 162, 0, 0, 0, 182, 0, - 0, 175, 177, 0, 41, 58, 39, 70, 38, 40, - 42, 0, 0, 56, 0, 0, 0, 106, 0, 72, + 0, 56, 74, 64, 67, 68, 65, 66, 0, 75, + 0, 161, 0, 0, 0, 148, 150, 153, 0, 154, + 0, 155, 144, 0, 147, 52, 0, 48, 51, 0, + 0, 0, 0, 160, 0, 0, 118, 120, 157, 119, + 0, 170, 0, 0, 163, 0, 0, 0, 183, 0, + 0, 176, 178, 0, 41, 58, 39, 70, 38, 40, + 42, 0, 0, 56, 0, 0, 0, 107, 0, 73, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 183, 187, 0, 0, - 0, 157, 158, 0, 0, 0, 0, 0, 140, 0, - 0, 150, 0, 179, 0, 100, 99, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 104, 56, 0, - 0, 0, 90, 91, 0, 0, 0, 98, 93, 85, - 88, 92, 89, 94, 0, 96, 97, 0, 121, 0, - 0, 115, 0, 112, 0, 167, 0, 0, 164, 170, - 0, 172, 0, 174, 176, 181, 0, 0, 63, 69, - 0, 0, 0, 54, 56, 47, 0, 45, 44, 7, - 8, 11, 12, 13, 10, 9, 15, 14, 16, 18, - 17, 19, 32, 33, 34, 35, 36, 37, 20, 21, - 22, 23, 24, 25, 26, 29, 27, 28, 30, 31, - 0, 71, 57, 0, 0, 186, 189, 109, 0, 0, - 142, 50, 0, 141, 0, 49, 151, 0, 148, 77, - 0, 81, 82, 0, 0, 0, 0, 80, 0, 0, - 0, 138, 137, 87, 84, 83, 78, 86, 101, 103, - 95, 0, 0, 0, 0, 116, 120, 168, 0, 163, - 0, 0, 173, 55, 5, 105, 0, 43, 0, 53, - 190, 0, 184, 185, 0, 107, 0, 139, 178, 125, - 0, 0, 75, 0, 79, 0, 0, 122, 0, 0, - 114, 0, 0, 0, 161, 46, 0, 188, 0, 0, - 0, 0, 131, 0, 0, 0, 134, 0, 123, 124, - 113, 171, 0, 165, 0, 192, 108, 145, 126, 127, - 0, 130, 132, 0, 76, 0, 111, 0, 0, 0, - 0, 0, 135, 136, 0, 133, 0, 191, 129, 128, - 110, 166 + 0, 0, 0, 0, 0, 0, 0, 184, 188, 0, + 0, 0, 158, 159, 0, 0, 0, 0, 0, 141, + 0, 0, 151, 0, 180, 0, 101, 100, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 105, 56, + 0, 0, 0, 91, 92, 0, 0, 0, 99, 94, + 86, 89, 93, 90, 95, 0, 97, 98, 0, 122, + 0, 0, 116, 0, 113, 0, 168, 0, 0, 165, + 171, 0, 173, 0, 175, 177, 182, 0, 0, 63, + 69, 0, 0, 0, 54, 56, 47, 0, 45, 44, + 72, 7, 8, 11, 12, 13, 10, 9, 15, 14, + 16, 18, 17, 19, 32, 33, 34, 35, 36, 37, + 20, 21, 22, 23, 24, 25, 26, 29, 27, 28, + 30, 31, 0, 71, 57, 0, 0, 187, 190, 110, + 0, 0, 143, 50, 0, 142, 0, 49, 152, 0, + 149, 78, 0, 82, 83, 0, 0, 0, 0, 81, + 0, 0, 0, 139, 138, 88, 85, 84, 79, 87, + 102, 104, 96, 0, 0, 0, 0, 117, 121, 169, + 0, 164, 0, 0, 174, 55, 5, 106, 0, 43, + 0, 53, 191, 0, 185, 186, 0, 108, 0, 140, + 179, 126, 0, 0, 76, 0, 80, 0, 0, 123, + 0, 0, 115, 0, 0, 0, 162, 46, 0, 189, + 0, 0, 0, 0, 132, 0, 0, 0, 135, 0, + 124, 125, 114, 172, 0, 166, 0, 193, 109, 146, + 127, 128, 0, 131, 133, 0, 77, 0, 112, 0, + 0, 0, 0, 0, 136, 137, 0, 134, 0, 192, + 130, 129, 111, 167 }; /* YYPGOTO[NTERM-NUM]. */ static const yytype_int16 yypgoto[] = { - -248, 0, 3, -248, 4, -248, -248, -248, 94, -51, - -248, -65, -248, -248, 291, -248, -248, -248, -248, -222, - -34, -73, 9, -115, -248, -32, 167, -30, 111, -218, - -70, -248, -248, -71, -248, -248, -90, -248, -12, -248, - 437, 20, -63, 322, -248, -248, -246, -248, -248, -220, - 10, -248, 195, 18, 13, 14, -248, -247, 16, -55, - -248, -22, -248 + -235, 0, 3, -235, 4, -235, -235, -235, 122, -18, + -235, -62, -235, -235, 293, -235, -235, -235, -235, -223, + -34, -92, 9, -82, -235, 11, 202, -30, 146, -219, + -33, -235, -235, -32, -235, -235, -48, -235, -12, -235, + 440, 20, -63, 372, -235, -235, -216, -235, -235, -222, + 10, -235, 250, 58, 13, 14, -235, -234, 16, -9, + -235, -22, -235 }; /* YYDEFGOTO[NTERM-NUM]. */ static const yytype_int16 yydefgoto[] = { - 0, 81, 13, 82, 14, 83, 84, 85, 265, 266, - 105, 106, 86, 87, 116, 222, 223, 224, 225, 226, - 227, 148, 15, 417, 241, 242, 117, 267, 239, 119, - 229, 230, 392, 393, 231, 331, 332, 232, 49, 50, + 0, 81, 13, 82, 14, 83, 84, 85, 266, 267, + 105, 106, 86, 87, 116, 223, 224, 225, 226, 227, + 228, 148, 15, 419, 242, 243, 117, 268, 240, 119, + 230, 231, 394, 395, 232, 333, 334, 233, 49, 50, 51, 16, 17, 18, 89, 125, 126, 131, 121, 122, - 19, 132, 133, 204, 20, 21, 187, 188, 22, 38, + 19, 132, 133, 205, 20, 21, 188, 189, 22, 38, 23, 24, 25 }; @@ -861,410 +860,408 @@ static const yytype_int16 yydefgoto[] = number is the opposite. If YYTABLE_NINF, syntax error. */ static const yytype_int16 yytable[] = { - 12, 56, 349, 338, 12, 34, 35, 26, 27, 39, - 40, 41, 48, 28, 30, 146, 113, 31, 32, 341, - 33, 190, 36, 12, 118, 184, 347, 91, 2, 2, - 95, 2, 42, 114, 37, 48, 197, 208, 43, 2, - 329, 329, 48, 92, 48, 48, 104, 330, 2, 42, - 112, 404, 198, 2, 112, 43, 361, 112, 363, 199, - 308, 120, 123, 129, 2, 42, 108, 52, 191, 135, - 192, 43, 53, 127, 2, 42, 182, 183, 143, 147, - 48, 43, 124, 130, 127, 243, 37, 61, 54, 62, - 104, 55, 48, 186, 147, 57, 189, 128, 145, 63, - 198, 47, 381, 48, 48, 383, 93, 199, 58, 48, - 108, 48, 218, 59, 90, 219, 220, 252, 47, 60, - 48, 228, 233, 48, 309, 234, 235, 250, 236, 48, - 382, 311, 129, 90, 47, 315, 94, 111, 2, 42, - 98, 102, 141, 48, 47, 43, 112, 350, 103, 351, - 264, 142, 130, 183, 150, 307, 196, 2, 42, 300, - 399, 251, 200, 244, 43, 246, 2, 42, 100, 247, - 268, 248, 426, 43, 146, 249, 253, 255, 257, 259, - 326, 12, 48, 302, 260, 328, 303, 355, 152, 153, - 154, 155, 156, 261, 48, 48, 104, 312, 428, 48, - 104, 304, 48, -212, 1, 342, 305, 319, 47, 2, - 306, 310, 264, 3, 2, 42, 108, 194, 48, 195, - 108, 43, 317, 90, 321, 218, 318, 47, 219, 220, - 322, 334, 268, 2, 228, 233, 47, 143, 234, 235, - 343, 236, 335, 337, 48, 339, 120, 340, 123, 356, - 182, 183, 4, 5, 344, 6, 7, 145, 345, 348, - 147, 352, 264, 354, 48, 358, 360, 359, 124, 366, - 367, 8, 9, 10, 11, 365, 371, 5, -212, 6, - 7, 313, 357, 373, 47, 374, 369, 378, 377, 379, - 391, 372, 386, 387, 390, 388, 9, 10, 11, 397, - 401, 403, 415, 186, 402, 186, 324, 385, 364, 430, - 412, 407, 380, 418, 243, 427, 431, 48, 270, 320, - 409, 411, 384, -215, 1, 423, 29, 254, 88, 2, - 376, 405, 0, 3, 97, 368, 2, 42, 110, 2, - 42, 396, 0, 43, 398, 0, 43, 0, 123, 400, - 120, 123, 0, 0, 406, 0, 408, 0, 264, 134, - 0, 136, 137, 138, 139, 140, 48, 0, 124, 144, - 0, 124, 4, 5, 0, 6, 7, 0, 268, 0, - 0, 422, 419, 425, 0, 0, 0, 429, 0, 0, - 0, 8, 9, 10, 11, 0, 44, 0, 45, 194, - 0, 195, 46, 221, 12, 238, 47, 0, 0, 47, - 0, 0, 0, 0, 2, 42, 0, 0, 123, 333, - 218, 43, 0, 219, 220, 152, 153, 154, 0, 228, - 233, 0, 256, 234, 235, 0, 236, 0, 124, 0, - 0, 0, 269, 271, 272, 273, 274, 275, 276, 277, - 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, - 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, - 298, 299, 64, 0, 44, 0, 45, 0, 0, 96, - 150, 99, 101, 107, 47, 0, 0, 182, 183, 0, - 0, 0, 0, 0, 65, 66, 67, 2, 68, 238, - 69, 0, 323, 70, 325, 71, 0, 0, 0, 0, - 72, 0, 0, 0, 73, 0, 221, 149, 74, 0, - 0, 0, 0, 0, 2, 42, 0, 107, 144, 185, - 0, 43, 0, 0, 0, 0, 0, 0, 75, 0, - 193, 0, 2, 42, 0, 76, 201, 77, 203, 43, - 0, 2, 42, 139, 0, 0, 0, 245, 43, 0, - 0, 0, 0, 78, 0, 0, 0, 79, 109, 80, - 0, 0, 65, 66, 67, 2, 68, 0, 69, 0, - 0, 70, 0, 71, 194, 0, 195, 0, 72, 0, - 111, 0, 73, 0, 47, 362, 74, 0, 0, 0, - 0, 0, 44, 0, 45, 0, 0, 0, 150, 0, - 0, 194, 47, 195, 0, 0, 75, 150, 0, 301, - 375, 47, 0, 76, 0, 77, 114, 0, 0, 0, - 0, 99, 101, 107, 0, 0, 314, 107, 0, 316, - 0, 78, 0, 115, 0, 79, 0, 80, 240, 0, + 12, 56, 191, 340, 12, 34, 35, 26, 27, 39, + 40, 41, 48, 28, 30, 146, 113, 31, 32, 343, + 33, 150, 36, 12, 118, 349, 114, 91, 185, 151, + 95, 2, 42, 351, 37, 48, 198, 209, 43, 2, + 2, 310, 48, 112, 48, 48, 104, 331, 2, 42, + 92, 406, 199, 331, 112, 43, 61, 2, 62, 332, + 200, 120, 123, 129, 112, 352, 108, 353, 192, 135, + 193, 363, 37, 365, 2, 42, 98, 52, 143, 147, + 48, 43, 124, 130, 127, 244, 183, 184, 2, 42, + 104, 53, 48, 187, 147, 43, -213, 1, 145, 63, + 199, 47, 2, 48, 48, 311, 3, 190, 200, 48, + 108, 48, 219, 93, 90, 220, 221, 253, 47, 54, + 48, 229, 234, 48, 55, 235, 236, 251, 237, 48, + 384, 57, 129, 2, 383, 313, 58, 385, 59, 317, + 2, 42, 100, 48, 47, 4, 5, 43, 6, 7, + 265, 48, 130, 60, 112, 102, 309, 90, 47, 94, + 302, 401, 111, 103, 8, 9, 10, 11, 184, 357, + 269, -213, 141, 2, 42, 146, 142, 197, 127, 245, + 43, 328, 12, 48, 304, 201, 330, 247, 248, 249, + 254, 250, 256, 258, 260, 48, 48, 104, 314, 430, + 48, 104, 128, 48, 428, 261, 344, 262, 321, 305, + 47, 306, 307, 265, 312, 2, 42, 108, 319, 48, + 308, 108, 43, 320, 2, 42, 219, 2, 42, 220, + 221, 43, 323, 269, 43, 229, 234, 324, 143, 235, + 236, 345, 237, 47, 336, 48, 337, 120, 339, 123, + 358, 341, 2, 42, 342, 2, 42, 335, 145, 43, + 346, 147, 43, 265, 347, 48, 350, 354, 356, 124, + 361, 2, 42, 360, 362, 252, 373, 367, 43, 368, + 369, 375, 315, 359, 44, 47, 45, 195, 371, 196, + 150, 376, 379, 374, 47, 380, 381, 47, 151, 388, + 392, 389, 390, 399, 420, 187, 403, 187, 404, 393, + 366, 417, 44, 409, 45, 195, 244, 196, 150, 48, + 405, 150, 47, 414, 386, 47, 151, 429, 2, 151, + 88, 195, 378, 196, 433, 326, 97, 90, 2, 42, + 110, 47, 387, 398, 432, 43, 400, 153, 154, 155, + 123, 402, 120, 123, 272, 322, 408, 382, 410, 411, + 265, 134, 413, 136, 137, 138, 139, 140, 48, 425, + 124, 144, 5, 124, 6, 7, 29, 370, 0, 407, + 269, 0, 255, 424, 421, 427, 0, 0, 0, 431, + 0, 9, 10, 11, 0, 0, 0, 0, 44, 0, + 45, 0, 0, 0, 46, 222, 12, 239, 47, 183, + 184, 0, 0, 0, 0, 0, 0, 2, 42, 0, + 123, 0, 219, 0, 43, 220, 221, 0, 0, 0, + 0, 229, 234, 0, 257, 235, 236, 0, 237, 0, + 124, 0, 0, 0, 0, 271, 273, 274, 275, 276, + 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, + 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, + 297, 298, 299, 300, 301, 64, 0, 195, 0, 196, + 0, 0, 96, 111, 99, 101, 107, 47, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 65, 66, 67, + 2, 68, 239, 69, 0, 325, 70, 327, 71, 0, + 0, 0, 0, 72, 0, 0, 0, 73, 0, 222, + 149, 74, 0, 0, 0, 0, 0, 0, 0, 0, + 107, 144, 186, 0, 0, 153, 154, 155, 156, 157, + 0, 75, 160, 194, 0, 0, 0, 0, 76, 202, + 77, 204, 0, 170, 171, 0, 139, 0, 0, 0, + 246, 0, 0, -216, 1, 0, 78, 0, 0, 2, + 79, 109, 80, 3, 0, 0, 65, 66, 67, 2, + 68, 0, 69, 0, 0, 70, 0, 71, 0, 0, + 0, 270, 72, 0, 0, 0, 73, 183, 184, 364, + 74, 153, 154, 155, 156, 157, 0, 153, 154, 155, + 156, 157, 4, 5, 0, 6, 7, 0, 0, 0, + 75, 0, 0, 303, 377, 170, 171, 76, 0, 77, + 114, 8, 9, 10, 11, 99, 101, 107, 0, 0, + 316, 107, 0, 318, 0, 78, 0, 115, 0, 79, + 0, 80, 241, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 183, 184, 0, 396, 0, 397, 183, + 184, 206, 0, 65, 66, 67, 2, 68, 0, 69, + 207, 0, 70, 0, 71, 348, 412, 0, 0, 72, + 0, 0, 418, 73, 0, 0, 0, 74, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 423, 0, + 0, 0, 0, 0, 0, 222, 0, 75, 0, 418, + 5, 0, 6, 7, 76, 208, 77, 209, 0, 210, + 211, 212, -103, 213, 214, 215, 0, 216, 217, 0, + 10, 11, 78, 0, 112, -103, 79, 206, 80, 65, + 66, 67, 2, 68, 0, 69, 207, 0, 70, 204, + 71, 0, 0, 0, 0, 72, 0, 0, 0, 73, + 0, 0, 0, 74, 0, 0, 153, 154, 155, 156, + 157, 0, 159, 160, 161, 0, 0, 0, 164, 165, + 166, 167, 0, 75, 170, 171, 5, 0, 6, 7, + 76, 208, 77, 209, 0, 210, 211, 212, 391, 213, + 214, 215, 0, 216, 217, 0, 10, 11, 78, 0, + 112, 218, 79, 206, 80, 65, 66, 67, 2, 68, + 0, 69, 207, 0, 70, 0, 71, 0, 183, 184, + 0, 72, 0, 0, 0, 73, 0, 0, 0, 74, + 0, 0, 153, 154, 155, 156, 157, 0, 159, 160, + 161, 0, 0, 0, 0, 0, 0, 0, 0, 75, + 170, 171, 5, 0, 6, 7, 76, 208, 77, 209, + 0, 210, 211, 212, 0, 213, 214, 215, 0, 216, + 217, 0, 10, 11, 78, 0, 112, 0, 79, 0, + 80, 65, 66, 67, 2, 68, 0, 69, 0, 0, + 70, 0, 71, 0, 183, 184, 0, 72, 0, 0, + 0, 263, 0, 0, 0, 74, 0, 0, 0, 0, + 0, 0, 0, 65, 66, 67, 2, 68, 0, 69, + 329, 0, 70, 0, 71, 75, 0, 0, 0, 72, + 0, 0, 76, 73, 77, 114, 0, 74, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 394, 0, 395, 0, 0, 205, 0, 65, - 66, 67, 2, 68, 0, 69, 206, 0, 70, 0, - 71, 346, 410, 0, 0, 72, 0, 0, 416, 73, - 0, 0, 0, 74, 0, 0, 0, 0, 0, 0, - 1, 0, 0, 0, 421, 2, 0, 0, 0, 3, - 0, 221, 0, 75, 0, 416, 5, 0, 6, 7, - 76, 207, 77, 208, 0, 209, 210, 211, -102, 212, - 213, 214, 0, 215, 216, 0, 10, 11, 78, 0, - 112, -102, 79, 0, 80, 0, 0, 0, 4, 5, - 0, 6, 7, 205, 203, 65, 66, 67, 2, 68, - 0, 69, 206, 0, 70, 0, 71, 8, 9, 10, - 11, 72, 0, 0, 0, 73, 0, 0, 0, 74, - 0, 0, 152, 153, 154, 155, 156, 0, 158, 159, - 160, 0, 0, 0, 163, 164, 165, 166, 0, 75, - 169, 170, 5, 389, 6, 7, 76, 207, 77, 208, - 0, 209, 210, 211, 0, 212, 213, 214, 0, 215, - 216, 0, 10, 11, 78, 0, 112, 217, 79, 205, - 80, 65, 66, 67, 2, 68, 0, 69, 206, 0, - 70, 0, 71, 0, 182, 183, 0, 72, 0, 0, - 0, 73, 0, 0, 0, 74, 0, 0, 152, 153, - 154, 155, 156, 0, 158, 159, 160, 0, 0, 0, - 0, 0, 0, 0, 0, 75, 169, 170, 5, 0, - 6, 7, 76, 207, 77, 208, 0, 209, 210, 211, - 0, 212, 213, 214, 0, 215, 216, 0, 10, 11, - 78, 0, 112, 0, 79, 0, 80, 65, 66, 67, - 2, 68, 0, 69, 0, 0, 70, 0, 71, 0, - 182, 183, 0, 72, 0, 0, 0, 262, 0, 0, - 0, 74, 0, 0, 0, 0, 0, 0, 0, 65, - 66, 67, 2, 68, 0, 69, 327, 0, 70, 0, - 71, 75, 0, 0, 0, 72, 0, 0, 76, 73, - 77, 114, 0, 74, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 78, 263, 115, 0, - 79, 0, 80, 75, 0, 65, 66, 67, 2, 68, - 76, 69, 77, 114, 70, 0, 71, 0, 0, 0, - 0, 72, 0, 0, 0, 73, 0, 0, 78, 74, - 115, 0, 79, 0, 80, 0, 0, 65, 66, 67, - 2, 68, 0, 69, 0, 0, 70, 0, 71, 75, - 0, 0, 0, 72, 0, 0, 76, 262, 77, 114, - 0, 74, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 78, 0, 115, 0, 79, 0, - 80, 75, 0, 65, 66, 67, 2, 68, 76, 69, - 77, 114, 70, 0, 71, 0, 0, 0, 0, 72, - 0, 0, 0, 73, 0, 0, 78, 74, 115, 0, - 79, 0, 80, 65, 66, 67, 2, 68, 0, 69, - 0, 0, 70, 0, 71, 0, 0, 75, 0, 72, - 0, 0, 0, 73, 76, 0, 77, 74, 0, 65, - 66, 67, 2, 68, 0, 69, 0, 0, 70, 0, - 71, 0, 78, 0, 115, 72, 79, 75, 80, 73, - 0, 0, 0, 74, 76, 0, 77, 114, 0, 65, - 66, 67, 2, 68, 0, 69, 0, 0, 70, 0, - 71, 0, 78, 75, 0, 72, 79, 0, 80, 73, - 76, 0, 77, 74, 0, 0, 0, 0, 0, 0, + 78, 264, 115, 0, 79, 0, 80, 75, 0, 65, + 66, 67, 2, 68, 76, 69, 77, 114, 70, 0, + 71, 0, 0, 0, 0, 72, 0, 0, 0, 73, + 0, 0, 78, 74, 115, 0, 79, 0, 80, 0, + 0, 65, 66, 67, 2, 68, 0, 69, 0, 0, + 70, 0, 71, 75, 0, 0, 0, 72, 0, 0, + 76, 263, 77, 114, 0, 74, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 78, 0, - 0, 0, 79, 75, 80, 0, 0, 0, 0, 0, - 76, 0, 77, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 151, 237, 0, - 0, 0, 79, 0, 80, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, 162, 0, 163, 164, 165, - 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, - 176, 0, 177, 178, 179, 180, 0, 0, 152, 153, - 154, 155, 156, 0, 158, 159, 160, 161, 162, 0, - 163, 164, 165, 166, 167, 168, 169, 170, 0, 0, - 0, 151, 0, 181, 0, 0, 0, 182, 183, 152, - 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, - 0, 163, 164, 165, 166, 167, 168, 169, 170, 171, - 172, 173, 174, 175, 176, 0, 177, 178, 179, 180, - 182, 183, 152, 153, 154, 155, 156, 0, 158, 159, - 160, 161, 0, 0, 163, 164, 165, 166, 167, 168, - 169, 170, 0, 0, 0, 151, 0, 0, 0, 0, - 202, 182, 183, 152, 153, 154, 155, 156, 157, 158, - 159, 160, 161, 162, 0, 163, 164, 165, 166, 167, - 168, 169, 170, 171, 172, 173, 174, 175, 176, 0, - 177, 178, 179, 180, 182, 183, 152, 153, 154, 155, - 156, 0, 158, 159, 160, 0, 0, 0, 163, 164, - 165, 166, 167, 168, 169, 170, 0, 0, 0, 151, - 258, 336, 0, 0, 0, 182, 183, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, 162, 0, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, - 174, 175, 176, 0, 177, 178, 179, 180, 182, 183, - 152, 153, 154, 155, 156, 0, 158, 159, 152, 153, - 154, 155, 156, 0, 0, 159, 0, 0, 169, 170, - 0, 0, 0, 151, 0, 0, 169, 170, 0, 182, - 183, 152, 153, 154, 155, 156, 157, 158, 159, 160, - 161, 162, 0, 163, 164, 165, 166, 167, 168, 169, - 170, 171, 172, 173, 174, 175, 176, 0, 177, 178, - 179, 180, 182, 183, 152, 153, 154, 155, 156, 0, - 182, 183, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 169, 170, 0, 0, 0, 151, 353, 0, - 0, 0, 0, 182, 183, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, 162, 0, 163, 164, 165, - 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, - 176, 0, 177, 178, 179, 180, 182, 183, 0, 0, + 115, 0, 79, 0, 80, 75, 0, 65, 66, 67, + 2, 68, 76, 69, 77, 114, 70, 0, 71, 0, + 0, 0, 0, 72, 0, 0, 0, 73, 0, 0, + 78, 74, 115, 0, 79, 0, 80, 65, 66, 67, + 2, 68, 0, 69, 0, 0, 70, 0, 71, 0, + 0, 75, 0, 72, 0, 0, 0, 73, 76, 0, + 77, 74, 0, 65, 66, 67, 2, 68, 0, 69, + 0, 0, 70, 0, 71, 0, 78, 0, 115, 72, + 79, 75, 80, 73, 0, 0, 0, 74, 76, 0, + 77, 114, 0, 65, 66, 67, 2, 68, 0, 69, + 0, 0, 70, 0, 71, 0, 78, 75, 0, 72, + 79, 0, 80, 73, 76, 0, 77, 74, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 78, 0, 0, 0, 79, 75, 80, 0, + 0, 0, 0, 0, 76, 0, 77, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 151, 0, 370, 0, 0, 0, 182, 183, 152, - 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, - 0, 163, 164, 165, 166, 167, 168, 169, 170, 171, - 172, 173, 174, 175, 176, 0, 177, 178, 179, 180, + 0, 152, 238, 0, 0, 0, 79, 0, 80, 153, + 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, + 0, 164, 165, 166, 167, 168, 169, 170, 171, 172, + 173, 174, 175, 176, 177, 0, 178, 179, 180, 181, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 2, 0, 0, 152, 3, 182, 0, 0, + 0, 183, 184, 153, 154, 155, 156, 157, 158, 159, + 160, 161, 162, 163, 0, 164, 165, 166, 167, 168, + 169, 170, 171, 172, 173, 174, 175, 176, 177, 0, + 178, 179, 180, 181, 0, 4, 5, 0, 6, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 151, 112, 413, 0, - 0, 182, 183, 0, 152, 153, 154, 155, 156, 157, - 158, 159, 160, 161, 162, 0, 163, 164, 165, 166, + 0, 0, 0, 0, 8, 9, 10, 11, 0, 152, + 0, 0, 0, 0, 203, 183, 184, 153, 154, 155, + 156, 157, 158, 159, 160, 161, 162, 163, 0, 164, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, + 175, 176, 177, 0, 178, 179, 180, 181, 0, 0, + 153, 154, 155, 156, 157, 0, 159, 160, 161, 162, + 163, 0, 164, 165, 166, 167, 168, 169, 170, 171, + 0, 0, 0, 152, 259, 338, 0, 0, 0, 183, + 184, 153, 154, 155, 156, 157, 158, 159, 160, 161, + 162, 163, 0, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 173, 174, 175, 176, 177, 0, 178, 179, + 180, 181, 183, 184, 153, 154, 155, 156, 157, 0, + 159, 160, 161, 162, 0, 0, 164, 165, 166, 167, + 168, 169, 170, 171, 0, 0, 0, 152, 0, 0, + 0, 0, 0, 183, 184, 153, 154, 155, 156, 157, + 158, 159, 160, 161, 162, 163, 0, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, - 0, 177, 178, 179, 180, 0, 0, 0, 0, 0, + 177, 0, 178, 179, 180, 181, 183, 184, 153, 154, + 155, 156, 157, 0, 159, 160, 161, 0, 0, 0, + 164, 165, 166, 167, 168, 169, 170, 171, 0, 0, + 0, 152, 355, 0, 0, 0, 0, 183, 184, 153, + 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, + 0, 164, 165, 166, 167, 168, 169, 170, 171, 172, + 173, 174, 175, 176, 177, 0, 178, 179, 180, 181, + 183, 184, 153, 154, 155, 156, 157, 0, 159, 160, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 170, 171, 0, 0, 0, 152, 0, 372, 0, 0, + 0, 183, 184, 153, 154, 155, 156, 157, 158, 159, + 160, 161, 162, 163, 0, 164, 165, 166, 167, 168, + 169, 170, 171, 172, 173, 174, 175, 176, 177, 0, + 178, 179, 180, 181, 183, 184, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 151, 0, 414, 0, 0, 0, 182, 183, 152, 153, - 154, 155, 156, 157, 158, 159, 160, 161, 162, 0, - 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, - 173, 174, 175, 176, 0, 177, 178, 179, 180, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 152, 112, 415, 0, 0, 183, 184, 0, 153, 154, + 155, 156, 157, 158, 159, 160, 161, 162, 163, 0, + 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, + 174, 175, 176, 177, 0, 178, 179, 180, 181, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 151, 0, 0, 420, 0, 0, - 182, 183, 152, 153, 154, 155, 156, 157, 158, 159, - 160, 161, 162, 0, 163, 164, 165, 166, 167, 168, - 169, 170, 171, 172, 173, 174, 175, 176, 0, 177, - 178, 179, 180, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 151, 0, - 0, 0, 0, 0, 182, 183, 152, 153, 154, 155, - 156, 157, 158, 159, 160, 161, 162, 0, 163, 164, - 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, - 175, 176, 0, 177, 178, 179, 180, 0, 424, 0, + 0, 0, 0, 0, 152, 0, 416, 0, 0, 0, + 183, 184, 153, 154, 155, 156, 157, 158, 159, 160, + 161, 162, 163, 0, 164, 165, 166, 167, 168, 169, + 170, 171, 172, 173, 174, 175, 176, 177, 0, 178, + 179, 180, 181, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 152, 0, + 0, 422, 0, 0, 183, 184, 153, 154, 155, 156, + 157, 158, 159, 160, 161, 162, 163, 0, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, + 176, 177, 0, 178, 179, 180, 181, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 151, 0, 0, 0, 0, 0, 182, 183, - 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, - 162, 0, 163, 164, 165, 166, 167, 168, 169, 170, - 171, 172, 173, 174, 175, 176, 0, 177, 178, 179, - 180, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 152, 0, 0, 0, 0, 0, 183, 184, + 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, + 163, 0, 164, 165, 166, 167, 168, 169, 170, 171, + 172, 173, 174, 175, 176, 177, 0, 178, 179, 180, + 181, 0, 426, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 152, 0, 0, 0, + 0, 0, 183, 184, 153, 154, 155, 156, 157, 158, + 159, 160, 161, 162, 163, 0, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, + 0, 178, 179, 180, 181, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 182, 183 + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 183, 184 }; static const yytype_int16 yycheck[] = { - 0, 23, 248, 225, 4, 5, 6, 4, 4, 9, - 10, 11, 12, 4, 4, 78, 50, 4, 4, 237, - 4, 94, 5, 23, 54, 90, 246, 39, 6, 6, - 42, 6, 7, 57, 57, 35, 9, 57, 13, 6, - 57, 57, 42, 11, 44, 45, 46, 63, 6, 7, - 74, 74, 73, 6, 74, 13, 303, 74, 305, 80, - 9, 61, 62, 63, 6, 7, 46, 10, 98, 69, - 100, 13, 10, 51, 6, 7, 78, 79, 78, 79, - 80, 13, 62, 63, 51, 115, 57, 72, 8, 74, - 90, 10, 92, 93, 94, 0, 73, 75, 78, 74, - 73, 76, 348, 103, 104, 351, 74, 80, 10, 109, - 90, 111, 112, 10, 72, 112, 112, 129, 76, 10, - 120, 112, 112, 123, 73, 112, 112, 127, 112, 129, - 350, 196, 132, 72, 76, 200, 72, 72, 6, 7, - 8, 73, 72, 143, 76, 13, 74, 72, 80, 74, - 150, 72, 132, 79, 72, 189, 48, 6, 7, 181, - 378, 10, 48, 78, 13, 48, 6, 7, 8, 73, - 150, 10, 418, 13, 237, 75, 10, 75, 5, 73, - 214, 181, 182, 183, 48, 215, 74, 260, 16, 17, - 18, 19, 20, 77, 194, 195, 196, 197, 420, 199, - 200, 8, 202, 0, 1, 239, 48, 207, 76, 6, - 75, 73, 212, 10, 6, 7, 196, 66, 218, 68, - 200, 13, 48, 72, 10, 225, 73, 76, 225, 225, - 10, 10, 212, 6, 225, 225, 76, 237, 225, 225, - 240, 225, 10, 10, 244, 75, 246, 10, 248, 261, - 78, 79, 49, 50, 48, 52, 53, 237, 75, 74, - 260, 10, 262, 73, 264, 48, 75, 73, 248, 80, - 73, 68, 69, 70, 71, 309, 10, 50, 75, 52, - 53, 73, 262, 64, 76, 10, 320, 58, 73, 8, - 62, 325, 58, 75, 58, 73, 69, 70, 71, 11, - 75, 75, 58, 303, 73, 305, 212, 358, 308, 424, - 75, 73, 344, 74, 344, 75, 75, 317, 151, 208, - 390, 392, 356, 0, 1, 415, 4, 132, 37, 6, - 330, 386, -1, 10, 43, 317, 6, 7, 47, 6, - 7, 375, -1, 13, 378, -1, 13, -1, 348, 379, - 350, 351, -1, -1, 388, -1, 390, -1, 358, 68, - -1, 70, 71, 72, 73, 74, 366, -1, 348, 78, - -1, 351, 49, 50, -1, 52, 53, -1, 358, -1, - -1, 415, 404, 417, -1, -1, -1, 421, -1, -1, - -1, 68, 69, 70, 71, -1, 66, -1, 68, 66, - -1, 68, 72, 112, 404, 114, 76, -1, -1, 76, - -1, -1, -1, -1, 6, 7, -1, -1, 418, 11, - 420, 13, -1, 420, 420, 16, 17, 18, -1, 420, - 420, -1, 141, 420, 420, -1, 420, -1, 418, -1, - -1, -1, 151, 152, 153, 154, 155, 156, 157, 158, - 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, - 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, - 179, 180, 35, -1, 66, -1, 68, -1, -1, 42, - 72, 44, 45, 46, 76, -1, -1, 78, 79, -1, - -1, -1, -1, -1, 3, 4, 5, 6, 7, 208, - 9, -1, 211, 12, 213, 14, -1, -1, -1, -1, - 19, -1, -1, -1, 23, -1, 225, 80, 27, -1, - -1, -1, -1, -1, 6, 7, -1, 90, 237, 92, - -1, 13, -1, -1, -1, -1, -1, -1, 47, -1, - 103, -1, 6, 7, -1, 54, 109, 56, 111, 13, - -1, 6, 7, 262, -1, -1, -1, 120, 13, -1, - -1, -1, -1, 72, -1, -1, -1, 76, 77, 78, - -1, -1, 3, 4, 5, 6, 7, -1, 9, -1, - -1, 12, -1, 14, 66, -1, 68, -1, 19, -1, - 72, -1, 23, -1, 76, 304, 27, -1, -1, -1, - -1, -1, 66, -1, 68, -1, -1, -1, 72, -1, - -1, 66, 76, 68, -1, -1, 47, 72, -1, 182, - 329, 76, -1, 54, -1, 56, 57, -1, -1, -1, - -1, 194, 195, 196, -1, -1, 199, 200, -1, 202, - -1, 72, -1, 74, -1, 76, -1, 78, 79, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 371, -1, 373, -1, -1, 1, -1, 3, - 4, 5, 6, 7, -1, 9, 10, -1, 12, -1, - 14, 244, 391, -1, -1, 19, -1, -1, 397, 23, - -1, -1, -1, 27, -1, -1, -1, -1, -1, -1, - 1, -1, -1, -1, 413, 6, -1, -1, -1, 10, - -1, 420, -1, 47, -1, 424, 50, -1, 52, 53, - 54, 55, 56, 57, -1, 59, 60, 61, 62, 63, + 0, 23, 94, 226, 4, 5, 6, 4, 4, 9, + 10, 11, 12, 4, 4, 78, 50, 4, 4, 238, + 4, 72, 5, 23, 54, 247, 57, 39, 90, 80, + 42, 6, 7, 249, 57, 35, 9, 57, 13, 6, + 6, 9, 42, 74, 44, 45, 46, 57, 6, 7, + 11, 74, 73, 57, 74, 13, 72, 6, 74, 63, + 81, 61, 62, 63, 74, 72, 46, 74, 98, 69, + 100, 305, 57, 307, 6, 7, 8, 10, 78, 79, + 80, 13, 62, 63, 51, 115, 78, 79, 6, 7, + 90, 10, 92, 93, 94, 13, 0, 1, 78, 74, + 73, 76, 6, 103, 104, 73, 10, 73, 81, 109, + 90, 111, 112, 74, 72, 112, 112, 129, 76, 8, + 120, 112, 112, 123, 10, 112, 112, 127, 112, 129, + 352, 0, 132, 6, 350, 197, 10, 353, 10, 201, + 6, 7, 8, 143, 76, 49, 50, 13, 52, 53, + 150, 151, 132, 10, 74, 73, 190, 72, 76, 72, + 182, 380, 72, 81, 68, 69, 70, 71, 79, 261, + 150, 75, 72, 6, 7, 238, 72, 48, 51, 78, + 13, 215, 182, 183, 184, 48, 216, 48, 73, 10, + 10, 75, 75, 5, 73, 195, 196, 197, 198, 422, + 200, 201, 75, 203, 420, 48, 240, 77, 208, 74, + 76, 8, 48, 213, 73, 6, 7, 197, 48, 219, + 75, 201, 13, 73, 6, 7, 226, 6, 7, 226, + 226, 13, 10, 213, 13, 226, 226, 10, 238, 226, + 226, 241, 226, 76, 10, 245, 10, 247, 10, 249, + 262, 75, 6, 7, 10, 6, 7, 11, 238, 13, + 48, 261, 13, 263, 75, 265, 74, 10, 73, 249, + 73, 6, 7, 48, 75, 10, 10, 311, 13, 81, + 73, 64, 73, 263, 66, 76, 68, 66, 322, 68, + 72, 10, 73, 327, 76, 58, 8, 76, 80, 58, + 58, 75, 73, 11, 74, 305, 75, 307, 73, 62, + 310, 58, 66, 73, 68, 66, 346, 68, 72, 319, + 75, 72, 76, 75, 358, 76, 80, 75, 6, 80, + 37, 66, 332, 68, 75, 213, 43, 72, 6, 7, + 47, 76, 360, 377, 426, 13, 380, 16, 17, 18, + 350, 381, 352, 353, 152, 209, 390, 346, 392, 392, + 360, 68, 394, 70, 71, 72, 73, 74, 368, 417, + 350, 78, 50, 353, 52, 53, 4, 319, -1, 388, + 360, -1, 132, 417, 406, 419, -1, -1, -1, 423, + -1, 69, 70, 71, -1, -1, -1, -1, 66, -1, + 68, -1, -1, -1, 72, 112, 406, 114, 76, 78, + 79, -1, -1, -1, -1, -1, -1, 6, 7, -1, + 420, -1, 422, -1, 13, 422, 422, -1, -1, -1, + -1, 422, 422, -1, 141, 422, 422, -1, 422, -1, + 420, -1, -1, -1, -1, 152, 153, 154, 155, 156, + 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, + 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, + 177, 178, 179, 180, 181, 35, -1, 66, -1, 68, + -1, -1, 42, 72, 44, 45, 46, 76, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 3, 4, 5, + 6, 7, 209, 9, -1, 212, 12, 214, 14, -1, + -1, -1, -1, 19, -1, -1, -1, 23, -1, 226, + 80, 27, -1, -1, -1, -1, -1, -1, -1, -1, + 90, 238, 92, -1, -1, 16, 17, 18, 19, 20, + -1, 47, 23, 103, -1, -1, -1, -1, 54, 109, + 56, 111, -1, 34, 35, -1, 263, -1, -1, -1, + 120, -1, -1, 0, 1, -1, 72, -1, -1, 6, + 76, 77, 78, 10, -1, -1, 3, 4, 5, 6, + 7, -1, 9, -1, -1, 12, -1, 14, -1, -1, + -1, 151, 19, -1, -1, -1, 23, 78, 79, 306, + 27, 16, 17, 18, 19, 20, -1, 16, 17, 18, + 19, 20, 49, 50, -1, 52, 53, -1, -1, -1, + 47, -1, -1, 183, 331, 34, 35, 54, -1, 56, + 57, 68, 69, 70, 71, 195, 196, 197, -1, -1, + 200, 201, -1, 203, -1, 72, -1, 74, -1, 76, + -1, 78, 79, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 78, 79, -1, 373, -1, 375, 78, + 79, 1, -1, 3, 4, 5, 6, 7, -1, 9, + 10, -1, 12, -1, 14, 245, 393, -1, -1, 19, + -1, -1, 399, 23, -1, -1, -1, 27, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 415, -1, + -1, -1, -1, -1, -1, 422, -1, 47, -1, 426, + 50, -1, 52, 53, 54, 55, 56, 57, -1, 59, + 60, 61, 62, 63, 64, 65, -1, 67, 68, -1, + 70, 71, 72, -1, 74, 75, 76, 1, 78, 3, + 4, 5, 6, 7, -1, 9, 10, -1, 12, 319, + 14, -1, -1, -1, -1, 19, -1, -1, -1, 23, + -1, -1, -1, 27, -1, -1, 16, 17, 18, 19, + 20, -1, 22, 23, 24, -1, -1, -1, 28, 29, + 30, 31, -1, 47, 34, 35, 50, -1, 52, 53, + 54, 55, 56, 57, -1, 59, 60, 61, 368, 63, 64, 65, -1, 67, 68, -1, 70, 71, 72, -1, - 74, 75, 76, -1, 78, -1, -1, -1, 49, 50, - -1, 52, 53, 1, 317, 3, 4, 5, 6, 7, - -1, 9, 10, -1, 12, -1, 14, 68, 69, 70, - 71, 19, -1, -1, -1, 23, -1, -1, -1, 27, + 74, 75, 76, 1, 78, 3, 4, 5, 6, 7, + -1, 9, 10, -1, 12, -1, 14, -1, 78, 79, + -1, 19, -1, -1, -1, 23, -1, -1, -1, 27, -1, -1, 16, 17, 18, 19, 20, -1, 22, 23, - 24, -1, -1, -1, 28, 29, 30, 31, -1, 47, - 34, 35, 50, 366, 52, 53, 54, 55, 56, 57, + 24, -1, -1, -1, -1, -1, -1, -1, -1, 47, + 34, 35, 50, -1, 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, -1, 63, 64, 65, -1, 67, - 68, -1, 70, 71, 72, -1, 74, 75, 76, 1, - 78, 3, 4, 5, 6, 7, -1, 9, 10, -1, + 68, -1, 70, 71, 72, -1, 74, -1, 76, -1, + 78, 3, 4, 5, 6, 7, -1, 9, -1, -1, 12, -1, 14, -1, 78, 79, -1, 19, -1, -1, - -1, 23, -1, -1, -1, 27, -1, -1, 16, 17, - 18, 19, 20, -1, 22, 23, 24, -1, -1, -1, - -1, -1, -1, -1, -1, 47, 34, 35, 50, -1, - 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, - -1, 63, 64, 65, -1, 67, 68, -1, 70, 71, - 72, -1, 74, -1, 76, -1, 78, 3, 4, 5, - 6, 7, -1, 9, -1, -1, 12, -1, 14, -1, - 78, 79, -1, 19, -1, -1, -1, 23, -1, -1, - -1, 27, -1, -1, -1, -1, -1, -1, -1, 3, - 4, 5, 6, 7, -1, 9, 10, -1, 12, -1, - 14, 47, -1, -1, -1, 19, -1, -1, 54, 23, - 56, 57, -1, 27, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 72, 73, 74, -1, - 76, -1, 78, 47, -1, 3, 4, 5, 6, 7, - 54, 9, 56, 57, 12, -1, 14, -1, -1, -1, - -1, 19, -1, -1, -1, 23, -1, -1, 72, 27, - 74, -1, 76, -1, 78, -1, -1, 3, 4, 5, - 6, 7, -1, 9, -1, -1, 12, -1, 14, 47, - -1, -1, -1, 19, -1, -1, 54, 23, 56, 57, - -1, 27, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 72, -1, 74, -1, 76, -1, - 78, 47, -1, 3, 4, 5, 6, 7, 54, 9, - 56, 57, 12, -1, 14, -1, -1, -1, -1, 19, - -1, -1, -1, 23, -1, -1, 72, 27, 74, -1, - 76, -1, 78, 3, 4, 5, 6, 7, -1, 9, - -1, -1, 12, -1, 14, -1, -1, 47, -1, 19, - -1, -1, -1, 23, 54, -1, 56, 27, -1, 3, - 4, 5, 6, 7, -1, 9, -1, -1, 12, -1, - 14, -1, 72, -1, 74, 19, 76, 47, 78, 23, - -1, -1, -1, 27, 54, -1, 56, 57, -1, 3, - 4, 5, 6, 7, -1, 9, -1, -1, 12, -1, - 14, -1, 72, 47, -1, 19, 76, -1, 78, 23, - 54, -1, 56, 27, -1, -1, -1, -1, -1, -1, + -1, 23, -1, -1, -1, 27, -1, -1, -1, -1, + -1, -1, -1, 3, 4, 5, 6, 7, -1, 9, + 10, -1, 12, -1, 14, 47, -1, -1, -1, 19, + -1, -1, 54, 23, 56, 57, -1, 27, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 72, 73, 74, -1, 76, -1, 78, 47, -1, 3, + 4, 5, 6, 7, 54, 9, 56, 57, 12, -1, + 14, -1, -1, -1, -1, 19, -1, -1, -1, 23, + -1, -1, 72, 27, 74, -1, 76, -1, 78, -1, + -1, 3, 4, 5, 6, 7, -1, 9, -1, -1, + 12, -1, 14, 47, -1, -1, -1, 19, -1, -1, + 54, 23, 56, 57, -1, 27, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 72, -1, - -1, -1, 76, 47, 78, -1, -1, -1, -1, -1, - 54, -1, 56, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 8, 72, -1, - -1, -1, 76, -1, 78, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 26, -1, 28, 29, 30, - 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, - 41, -1, 43, 44, 45, 46, -1, -1, 16, 17, - 18, 19, 20, -1, 22, 23, 24, 25, 26, -1, - 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, - -1, 8, -1, 74, -1, -1, -1, 78, 79, 16, + 74, -1, 76, -1, 78, 47, -1, 3, 4, 5, + 6, 7, 54, 9, 56, 57, 12, -1, 14, -1, + -1, -1, -1, 19, -1, -1, -1, 23, -1, -1, + 72, 27, 74, -1, 76, -1, 78, 3, 4, 5, + 6, 7, -1, 9, -1, -1, 12, -1, 14, -1, + -1, 47, -1, 19, -1, -1, -1, 23, 54, -1, + 56, 27, -1, 3, 4, 5, 6, 7, -1, 9, + -1, -1, 12, -1, 14, -1, 72, -1, 74, 19, + 76, 47, 78, 23, -1, -1, -1, 27, 54, -1, + 56, 57, -1, 3, 4, 5, 6, 7, -1, 9, + -1, -1, 12, -1, 14, -1, 72, 47, -1, 19, + 76, -1, 78, 23, 54, -1, 56, 27, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 72, -1, -1, -1, 76, 47, 78, -1, + -1, -1, -1, -1, 54, -1, 56, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 8, 72, -1, -1, -1, 76, -1, 78, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, -1, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, -1, 43, 44, 45, 46, - 78, 79, 16, 17, 18, 19, 20, -1, 22, 23, - 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, - 34, 35, -1, -1, -1, 8, -1, -1, -1, -1, - 77, 78, 79, 16, 17, 18, 19, 20, 21, 22, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, + -1, -1, 6, -1, -1, 8, 10, 74, -1, -1, + -1, 78, 79, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, -1, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, -1, - 43, 44, 45, 46, 78, 79, 16, 17, 18, 19, - 20, -1, 22, 23, 24, -1, -1, -1, 28, 29, - 30, 31, 32, 33, 34, 35, -1, -1, -1, 8, - 73, 10, -1, -1, -1, 78, 79, 16, 17, 18, + 43, 44, 45, 46, -1, 49, 50, -1, 52, 53, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 68, 69, 70, 71, -1, 8, + -1, -1, -1, -1, 77, 78, 79, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, -1, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, - 39, 40, 41, -1, 43, 44, 45, 46, 78, 79, - 16, 17, 18, 19, 20, -1, 22, 23, 16, 17, - 18, 19, 20, -1, -1, 23, -1, -1, 34, 35, - -1, -1, -1, 8, -1, -1, 34, 35, -1, 78, + 39, 40, 41, -1, 43, 44, 45, 46, -1, -1, + 16, 17, 18, 19, 20, -1, 22, 23, 24, 25, + 26, -1, 28, 29, 30, 31, 32, 33, 34, 35, + -1, -1, -1, 8, 73, 10, -1, -1, -1, 78, 79, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, -1, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, -1, 43, 44, 45, 46, 78, 79, 16, 17, 18, 19, 20, -1, - 78, 79, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 34, 35, -1, -1, -1, 8, 73, -1, + 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, + 32, 33, 34, 35, -1, -1, -1, 8, -1, -1, -1, -1, -1, 78, 79, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, -1, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, - 41, -1, 43, 44, 45, 46, 78, 79, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 8, -1, 74, -1, -1, -1, 78, 79, 16, + 41, -1, 43, 44, 45, 46, 78, 79, 16, 17, + 18, 19, 20, -1, 22, 23, 24, -1, -1, -1, + 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, + -1, 8, 73, -1, -1, -1, -1, 78, 79, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, -1, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, -1, 43, 44, 45, 46, + 78, 79, 16, 17, 18, 19, 20, -1, 22, 23, -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, 8, 74, 10, -1, - -1, 78, 79, -1, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, -1, 28, 29, 30, 31, - 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, - -1, 43, 44, 45, 46, -1, -1, -1, -1, -1, + 34, 35, -1, -1, -1, 8, -1, 74, -1, -1, + -1, 78, 79, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, -1, 28, 29, 30, 31, 32, + 33, 34, 35, 36, 37, 38, 39, 40, 41, -1, + 43, 44, 45, 46, 78, 79, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 8, -1, 10, -1, -1, -1, 78, 79, 16, 17, + 8, 74, 10, -1, -1, 78, 79, -1, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, -1, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, -1, 43, 44, 45, 46, -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, 8, -1, -1, 11, -1, -1, + -1, -1, -1, -1, 8, -1, 10, -1, -1, -1, 78, 79, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, -1, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, -1, 43, 44, 45, 46, -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, 8, -1, - -1, -1, -1, -1, 78, 79, 16, 17, 18, 19, + -1, 11, -1, -1, 78, 79, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, -1, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, - 40, 41, -1, 43, 44, 45, 46, -1, 48, -1, + 40, 41, -1, 43, 44, 45, 46, -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, 8, -1, -1, -1, -1, -1, 78, 79, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, -1, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, -1, 43, 44, 45, - 46, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 46, -1, 48, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 8, -1, -1, -1, + -1, -1, 78, 79, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, -1, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + -1, 43, 44, 45, 46, -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, 78, 79 + -1, -1, -1, -1, -1, -1, 78, 79 }; /* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of @@ -1272,76 +1269,76 @@ static const yytype_int16 yycheck[] = static const yytype_uint8 yystos[] = { 0, 1, 6, 10, 49, 50, 52, 53, 68, 69, - 70, 71, 82, 83, 85, 103, 122, 123, 124, 131, - 135, 136, 139, 141, 142, 143, 83, 85, 103, 124, - 131, 135, 136, 139, 82, 82, 5, 57, 140, 82, - 82, 82, 7, 13, 66, 68, 72, 76, 82, 119, - 120, 121, 10, 10, 8, 10, 142, 0, 10, 10, - 10, 72, 74, 74, 121, 3, 4, 5, 7, 9, + 70, 71, 83, 84, 86, 104, 123, 124, 125, 132, + 136, 137, 140, 142, 143, 144, 84, 86, 104, 125, + 132, 136, 137, 140, 83, 83, 5, 57, 141, 83, + 83, 83, 7, 13, 66, 68, 72, 76, 83, 120, + 121, 122, 10, 10, 8, 10, 143, 0, 10, 10, + 10, 72, 74, 74, 122, 3, 4, 5, 7, 9, 12, 14, 19, 23, 27, 47, 54, 56, 72, 76, - 78, 82, 84, 86, 87, 88, 93, 94, 95, 125, - 72, 119, 11, 74, 72, 119, 121, 95, 8, 121, - 8, 121, 73, 80, 82, 91, 92, 121, 122, 77, - 95, 72, 74, 101, 57, 74, 95, 107, 108, 110, - 82, 129, 130, 82, 122, 126, 127, 51, 75, 82, - 122, 128, 132, 133, 95, 82, 95, 95, 95, 95, - 95, 72, 72, 82, 95, 122, 123, 82, 102, 121, - 72, 8, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 28, 29, 30, 31, 32, 33, 34, - 35, 36, 37, 38, 39, 40, 41, 43, 44, 45, - 46, 74, 78, 79, 92, 121, 82, 137, 138, 73, - 102, 108, 108, 121, 66, 68, 48, 9, 73, 80, - 48, 121, 77, 121, 134, 1, 10, 55, 57, 59, - 60, 61, 63, 64, 65, 67, 68, 75, 82, 83, - 85, 95, 96, 97, 98, 99, 100, 101, 103, 111, - 112, 115, 118, 131, 135, 136, 139, 72, 95, 109, - 79, 105, 106, 108, 78, 121, 48, 73, 10, 75, - 82, 10, 119, 10, 133, 75, 95, 5, 73, 73, - 48, 77, 23, 73, 82, 89, 90, 108, 122, 95, - 107, 95, 95, 95, 95, 95, 95, 95, 95, 95, - 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, - 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, - 142, 121, 82, 74, 8, 48, 75, 101, 9, 73, - 73, 92, 82, 73, 121, 92, 121, 48, 73, 82, - 109, 10, 10, 95, 89, 95, 101, 10, 108, 57, - 63, 116, 117, 11, 10, 10, 10, 10, 100, 75, - 10, 110, 101, 82, 48, 75, 121, 130, 74, 127, - 72, 74, 10, 73, 73, 102, 119, 122, 48, 73, - 75, 138, 95, 138, 82, 101, 80, 73, 134, 101, - 74, 10, 101, 64, 10, 95, 82, 73, 58, 8, - 106, 127, 130, 127, 101, 90, 58, 75, 73, 121, - 58, 62, 113, 114, 95, 95, 101, 11, 101, 110, - 108, 75, 73, 75, 74, 140, 101, 73, 101, 111, - 95, 114, 75, 10, 10, 58, 95, 104, 74, 142, - 11, 95, 101, 117, 48, 101, 127, 75, 100, 101, - 104, 75 + 78, 83, 85, 87, 88, 89, 94, 95, 96, 126, + 72, 120, 11, 74, 72, 120, 122, 96, 8, 122, + 8, 122, 73, 81, 83, 92, 93, 122, 123, 77, + 96, 72, 74, 102, 57, 74, 96, 108, 109, 111, + 83, 130, 131, 83, 123, 127, 128, 51, 75, 83, + 123, 129, 133, 134, 96, 83, 96, 96, 96, 96, + 96, 72, 72, 83, 96, 123, 124, 83, 103, 122, + 72, 80, 8, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 43, 44, + 45, 46, 74, 78, 79, 93, 122, 83, 138, 139, + 73, 103, 109, 109, 122, 66, 68, 48, 9, 73, + 81, 48, 122, 77, 122, 135, 1, 10, 55, 57, + 59, 60, 61, 63, 64, 65, 67, 68, 75, 83, + 84, 86, 96, 97, 98, 99, 100, 101, 102, 104, + 112, 113, 116, 119, 132, 136, 137, 140, 72, 96, + 110, 79, 106, 107, 109, 78, 122, 48, 73, 10, + 75, 83, 10, 120, 10, 134, 75, 96, 5, 73, + 73, 48, 77, 23, 73, 83, 90, 91, 109, 123, + 122, 96, 108, 96, 96, 96, 96, 96, 96, 96, + 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, + 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, + 96, 96, 143, 122, 83, 74, 8, 48, 75, 102, + 9, 73, 73, 93, 83, 73, 122, 93, 122, 48, + 73, 83, 110, 10, 10, 96, 90, 96, 102, 10, + 109, 57, 63, 117, 118, 11, 10, 10, 10, 10, + 101, 75, 10, 111, 102, 83, 48, 75, 122, 131, + 74, 128, 72, 74, 10, 73, 73, 103, 120, 123, + 48, 73, 75, 139, 96, 139, 83, 102, 81, 73, + 135, 102, 74, 10, 102, 64, 10, 96, 83, 73, + 58, 8, 107, 128, 131, 128, 102, 91, 58, 75, + 73, 122, 58, 62, 114, 115, 96, 96, 102, 11, + 102, 111, 109, 75, 73, 75, 74, 141, 102, 73, + 102, 112, 96, 115, 75, 10, 10, 58, 96, 105, + 74, 143, 11, 96, 102, 118, 48, 102, 128, 75, + 101, 102, 105, 75 }; /* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM. */ static const yytype_uint8 yyr1[] = { - 0, 81, 82, 83, 83, 84, 85, 86, 86, 87, - 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, - 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, - 87, 87, 87, 87, 87, 87, 87, 87, 88, 88, - 88, 88, 88, 89, 89, 89, 90, 90, 91, 92, - 92, 92, 92, 93, 93, 94, 95, 95, 95, 95, - 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, - 95, 95, 95, 95, 95, 96, 97, 98, 99, 99, - 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, - 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, - 99, 100, 100, 101, 101, 102, 102, 103, 103, 103, - 104, 104, 105, 105, 106, 106, 107, 108, 108, 108, - 108, 109, 109, 110, 110, 111, 111, 111, 112, 113, - 114, 114, 115, 116, 117, 117, 117, 118, 118, 119, - 119, 119, 119, 119, 120, 120, 121, 121, 121, 121, - 121, 121, 121, 122, 122, 122, 123, 123, 123, 124, - 124, 125, 126, 127, 127, 128, 128, 129, 130, 130, - 131, 131, 132, 132, 132, 132, 133, 133, 134, 134, - 135, 136, 136, 137, 137, 138, 138, 138, 139, 139, - 140, 140, 140, 141, 141, 141, 141, 141, 141, 141, - 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, - 141, 141, 142, 142, 143, 143 + 0, 82, 83, 84, 84, 85, 86, 87, 87, 88, + 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, + 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, + 88, 88, 88, 88, 88, 88, 88, 88, 89, 89, + 89, 89, 89, 90, 90, 90, 91, 91, 92, 93, + 93, 93, 93, 94, 94, 95, 96, 96, 96, 96, + 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, + 96, 96, 96, 96, 96, 96, 97, 98, 99, 100, + 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, + 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, + 100, 100, 101, 101, 102, 102, 103, 103, 104, 104, + 104, 105, 105, 106, 106, 107, 107, 108, 109, 109, + 109, 109, 110, 110, 111, 111, 112, 112, 112, 113, + 114, 115, 115, 116, 117, 118, 118, 118, 119, 119, + 120, 120, 120, 120, 120, 121, 121, 122, 122, 122, + 122, 122, 122, 122, 123, 123, 123, 124, 124, 124, + 125, 125, 126, 127, 128, 128, 129, 129, 130, 131, + 131, 132, 132, 133, 133, 133, 133, 134, 134, 135, + 135, 136, 137, 137, 138, 138, 139, 139, 139, 140, + 140, 141, 141, 141, 142, 142, 142, 142, 142, 142, + 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, + 142, 142, 142, 143, 143, 144, 144 }; /* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM. */ @@ -1354,21 +1351,21 @@ static const yytype_int8 yyr2[] = 2, 2, 2, 2, 1, 1, 3, 1, 1, 3, 3, 1, 1, 4, 3, 4, 1, 3, 2, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 3, - 2, 3, 2, 1, 1, 3, 5, 2, 2, 3, - 2, 2, 2, 2, 2, 1, 2, 2, 1, 1, - 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, - 1, 2, 1, 3, 2, 3, 1, 6, 8, 5, - 3, 1, 1, 4, 3, 1, 3, 1, 1, 1, - 3, 1, 3, 5, 5, 3, 5, 5, 7, 4, - 2, 1, 5, 5, 3, 5, 5, 2, 2, 5, - 3, 4, 4, 2, 1, 7, 1, 2, 4, 2, - 3, 4, 2, 3, 3, 2, 3, 4, 4, 3, - 3, 5, 1, 3, 2, 5, 8, 2, 3, 1, - 5, 8, 2, 3, 2, 1, 2, 1, 3, 1, - 3, 5, 4, 1, 3, 3, 2, 1, 7, 5, - 5, 9, 7, 1, 1, 1, 1, 1, 2, 2, - 2, 1, 2, 2, 2, 2, 3, 3, 2, 2, - 3, 1, 1, 2, 1, 0 + 2, 3, 3, 2, 1, 1, 3, 5, 2, 2, + 3, 2, 2, 2, 2, 2, 1, 2, 2, 1, + 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, + 1, 1, 2, 1, 3, 2, 3, 1, 6, 8, + 5, 3, 1, 1, 4, 3, 1, 3, 1, 1, + 1, 3, 1, 3, 5, 5, 3, 5, 5, 7, + 4, 2, 1, 5, 5, 3, 5, 5, 2, 2, + 5, 3, 4, 4, 2, 1, 7, 1, 2, 4, + 2, 3, 4, 2, 3, 3, 2, 3, 4, 4, + 3, 3, 5, 1, 3, 2, 5, 8, 2, 3, + 1, 5, 8, 2, 3, 2, 1, 2, 1, 3, + 1, 3, 5, 4, 1, 3, 3, 2, 1, 7, + 5, 5, 9, 7, 1, 1, 1, 1, 1, 2, + 2, 2, 1, 2, 2, 2, 2, 3, 3, 2, + 2, 3, 1, 1, 2, 1, 0 }; @@ -1932,393 +1929,393 @@ yydestruct (const char *yymsg, switch (yykind) { case YYSYMBOL_INT: /* INT */ -#line 143 "src/parser.y" +#line 145 "src/parser.y" {} -#line 1936 "gen/gen_parser.c" +#line 1935 "gen/gen_parser.c" break; case YYSYMBOL_FLOAT: /* FLOAT */ -#line 143 "src/parser.y" +#line 145 "src/parser.y" {} -#line 1942 "gen/gen_parser.c" +#line 1941 "gen/gen_parser.c" break; case YYSYMBOL_STRING: /* STRING */ -#line 143 "src/parser.y" +#line 145 "src/parser.y" {} -#line 1948 "gen/gen_parser.c" +#line 1947 "gen/gen_parser.c" break; case YYSYMBOL_ID: /* ID */ -#line 143 "src/parser.y" +#line 145 "src/parser.y" {} -#line 1954 "gen/gen_parser.c" +#line 1953 "gen/gen_parser.c" break; case YYSYMBOL_id: /* id */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 1960 "gen/gen_parser.c" +#line 1959 "gen/gen_parser.c" break; case YYSYMBOL_var: /* var */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 1966 "gen/gen_parser.c" +#line 1965 "gen/gen_parser.c" break; case YYSYMBOL_embed: /* embed */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 1972 "gen/gen_parser.c" +#line 1971 "gen/gen_parser.c" break; case YYSYMBOL_import: /* import */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 1978 "gen/gen_parser.c" +#line 1977 "gen/gen_parser.c" break; case YYSYMBOL_assign: /* assign */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 1984 "gen/gen_parser.c" +#line 1983 "gen/gen_parser.c" break; case YYSYMBOL_binary_op: /* binary_op */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 1990 "gen/gen_parser.c" +#line 1989 "gen/gen_parser.c" break; case YYSYMBOL_unary_op: /* unary_op */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 1996 "gen/gen_parser.c" +#line 1995 "gen/gen_parser.c" break; case YYSYMBOL_arg: /* arg */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2002 "gen/gen_parser.c" +#line 2001 "gen/gen_parser.c" break; case YYSYMBOL_arg_list: /* arg_list */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2008 "gen/gen_parser.c" +#line 2007 "gen/gen_parser.c" break; case YYSYMBOL_param_decl: /* param_decl */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2014 "gen/gen_parser.c" +#line 2013 "gen/gen_parser.c" break; case YYSYMBOL_decl_list: /* decl_list */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2020 "gen/gen_parser.c" +#line 2019 "gen/gen_parser.c" break; case YYSYMBOL_call: /* call */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2026 "gen/gen_parser.c" +#line 2025 "gen/gen_parser.c" break; case YYSYMBOL_defer: /* defer */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2032 "gen/gen_parser.c" +#line 2031 "gen/gen_parser.c" break; case YYSYMBOL_expr: /* expr */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2038 "gen/gen_parser.c" +#line 2037 "gen/gen_parser.c" break; case YYSYMBOL_while: /* while */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2044 "gen/gen_parser.c" +#line 2043 "gen/gen_parser.c" break; case YYSYMBOL_do_while: /* do_while */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2050 "gen/gen_parser.c" +#line 2049 "gen/gen_parser.c" break; case YYSYMBOL_goto: /* goto */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2056 "gen/gen_parser.c" +#line 2055 "gen/gen_parser.c" break; case YYSYMBOL_statement: /* statement */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2062 "gen/gen_parser.c" +#line 2061 "gen/gen_parser.c" break; case YYSYMBOL_statement_list: /* statement_list */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2068 "gen/gen_parser.c" +#line 2067 "gen/gen_parser.c" break; case YYSYMBOL_body: /* body */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2074 "gen/gen_parser.c" +#line 2073 "gen/gen_parser.c" break; case YYSYMBOL_macro_list: /* macro_list */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2080 "gen/gen_parser.c" +#line 2079 "gen/gen_parser.c" break; case YYSYMBOL_macro: /* macro */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2086 "gen/gen_parser.c" +#line 2085 "gen/gen_parser.c" break; case YYSYMBOL_expr_list: /* expr_list */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2092 "gen/gen_parser.c" +#line 2091 "gen/gen_parser.c" break; case YYSYMBOL_struct_init: /* struct_init */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2098 "gen/gen_parser.c" +#line 2097 "gen/gen_parser.c" break; case YYSYMBOL_struct_inits: /* struct_inits */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2104 "gen/gen_parser.c" +#line 2103 "gen/gen_parser.c" break; case YYSYMBOL_struct_construct: /* struct_construct */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2110 "gen/gen_parser.c" +#line 2109 "gen/gen_parser.c" break; case YYSYMBOL_init_expr: /* init_expr */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2116 "gen/gen_parser.c" +#line 2115 "gen/gen_parser.c" break; case YYSYMBOL_cond: /* cond */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2122 "gen/gen_parser.c" +#line 2121 "gen/gen_parser.c" break; case YYSYMBOL_expr_if: /* expr_if */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2128 "gen/gen_parser.c" +#line 2127 "gen/gen_parser.c" break; case YYSYMBOL_if: /* if */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2134 "gen/gen_parser.c" +#line 2133 "gen/gen_parser.c" break; case YYSYMBOL_for: /* for */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2140 "gen/gen_parser.c" +#line 2139 "gen/gen_parser.c" break; case YYSYMBOL_case: /* case */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2146 "gen/gen_parser.c" +#line 2145 "gen/gen_parser.c" break; case YYSYMBOL_case_list: /* case_list */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2152 "gen/gen_parser.c" +#line 2151 "gen/gen_parser.c" break; case YYSYMBOL_switch: /* switch */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2158 "gen/gen_parser.c" +#line 2157 "gen/gen_parser.c" break; case YYSYMBOL_const_for: /* const_for */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2164 "gen/gen_parser.c" +#line 2163 "gen/gen_parser.c" break; case YYSYMBOL_const_if: /* const_if */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2170 "gen/gen_parser.c" +#line 2169 "gen/gen_parser.c" break; case YYSYMBOL_const: /* const */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2176 "gen/gen_parser.c" +#line 2175 "gen/gen_parser.c" break; case YYSYMBOL_func_sign: /* func_sign */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2182 "gen/gen_parser.c" +#line 2181 "gen/gen_parser.c" break; case YYSYMBOL_variadic_sign: /* variadic_sign */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2188 "gen/gen_parser.c" +#line 2187 "gen/gen_parser.c" break; case YYSYMBOL_type: /* type */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2194 "gen/gen_parser.c" +#line 2193 "gen/gen_parser.c" break; case YYSYMBOL_var_decl: /* var_decl */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2200 "gen/gen_parser.c" +#line 2199 "gen/gen_parser.c" break; case YYSYMBOL_var_init: /* var_init */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2206 "gen/gen_parser.c" +#line 2205 "gen/gen_parser.c" break; case YYSYMBOL_proc: /* proc */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2212 "gen/gen_parser.c" +#line 2211 "gen/gen_parser.c" break; case YYSYMBOL_lambda: /* lambda */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2218 "gen/gen_parser.c" +#line 2217 "gen/gen_parser.c" break; case YYSYMBOL_struct_elem: /* struct_elem */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2224 "gen/gen_parser.c" +#line 2223 "gen/gen_parser.c" break; case YYSYMBOL_struct_list: /* struct_list */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2230 "gen/gen_parser.c" +#line 2229 "gen/gen_parser.c" break; case YYSYMBOL_union: /* union */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2236 "gen/gen_parser.c" +#line 2235 "gen/gen_parser.c" break; case YYSYMBOL_generic: /* generic */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2242 "gen/gen_parser.c" +#line 2241 "gen/gen_parser.c" break; case YYSYMBOL_generic_list: /* generic_list */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2248 "gen/gen_parser.c" +#line 2247 "gen/gen_parser.c" break; case YYSYMBOL_struct: /* struct */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2254 "gen/gen_parser.c" +#line 2253 "gen/gen_parser.c" break; case YYSYMBOL_template_elem: /* template_elem */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2260 "gen/gen_parser.c" +#line 2259 "gen/gen_parser.c" break; case YYSYMBOL_template_list: /* template_list */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2266 "gen/gen_parser.c" +#line 2265 "gen/gen_parser.c" break; case YYSYMBOL_type_list: /* type_list */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2272 "gen/gen_parser.c" +#line 2271 "gen/gen_parser.c" break; case YYSYMBOL_type_alias: /* type_alias */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2278 "gen/gen_parser.c" +#line 2277 "gen/gen_parser.c" break; case YYSYMBOL_type_template: /* type_template */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2284 "gen/gen_parser.c" +#line 2283 "gen/gen_parser.c" break; case YYSYMBOL_enum_val: /* enum_val */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2290 "gen/gen_parser.c" +#line 2289 "gen/gen_parser.c" break; case YYSYMBOL_enum_list: /* enum_list */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2296 "gen/gen_parser.c" +#line 2295 "gen/gen_parser.c" break; case YYSYMBOL_enum: /* enum */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2302 "gen/gen_parser.c" +#line 2301 "gen/gen_parser.c" break; case YYSYMBOL_top_if: /* top_if */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2308 "gen/gen_parser.c" +#line 2307 "gen/gen_parser.c" break; case YYSYMBOL_top: /* top */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2314 "gen/gen_parser.c" +#line 2313 "gen/gen_parser.c" break; case YYSYMBOL_unit: /* unit */ -#line 144 "src/parser.y" +#line 146 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2320 "gen/gen_parser.c" +#line 2319 "gen/gen_parser.c" break; default: @@ -2622,609 +2619,615 @@ yyreduce: switch (yyn) { case 2: /* id: ID */ -#line 148 "src/parser.y" +#line 150 "src/parser.y" { (yyval.node) = gen_id(strdup((yyvsp[0].str))); (yyval.node)->loc = to_src_loc(&yylloc); } -#line 2629 "gen/gen_parser.c" +#line 2628 "gen/gen_parser.c" break; case 3: /* var: var_decl */ -#line 154 "src/parser.y" +#line 156 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 2635 "gen/gen_parser.c" +#line 2634 "gen/gen_parser.c" break; case 4: /* var: var_init */ -#line 155 "src/parser.y" +#line 157 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 2641 "gen/gen_parser.c" +#line 2640 "gen/gen_parser.c" break; case 5: /* embed: "embed" "(" STRING ")" */ -#line 158 "src/parser.y" +#line 160 "src/parser.y" { (yyval.node) = gen_embed(clone_string((yyvsp[-1].str))); } -#line 2647 "gen/gen_parser.c" +#line 2646 "gen/gen_parser.c" break; case 6: /* import: "import" STRING */ -#line 161 "src/parser.y" +#line 163 "src/parser.y" { (yyval.node) = gen_import(clone_string((yyvsp[0].str))); } -#line 2653 "gen/gen_parser.c" +#line 2652 "gen/gen_parser.c" break; case 7: /* assign: expr "=" expr */ -#line 164 "src/parser.y" +#line 166 "src/parser.y" { (yyval.node) = gen_assign((yyvsp[-2].node), (yyvsp[0].node)); } -#line 2659 "gen/gen_parser.c" +#line 2658 "gen/gen_parser.c" break; case 8: /* assign: expr "=" struct_construct */ -#line 165 "src/parser.y" +#line 167 "src/parser.y" { (yyval.node) = gen_assign((yyvsp[-2].node), (yyvsp[0].node)); } -#line 2665 "gen/gen_parser.c" +#line 2664 "gen/gen_parser.c" break; case 9: /* binary_op: expr "+" expr */ -#line 168 "src/parser.y" +#line 170 "src/parser.y" { (yyval.node) = gen_binop(AST_ADD, (yyvsp[-2].node), (yyvsp[0].node)); } -#line 2671 "gen/gen_parser.c" +#line 2670 "gen/gen_parser.c" break; case 10: /* binary_op: expr "-" expr */ -#line 169 "src/parser.y" +#line 171 "src/parser.y" { (yyval.node) = gen_binop(AST_SUB, (yyvsp[-2].node), (yyvsp[0].node)); } -#line 2677 "gen/gen_parser.c" +#line 2676 "gen/gen_parser.c" break; case 11: /* binary_op: expr "*" expr */ -#line 170 "src/parser.y" +#line 172 "src/parser.y" { (yyval.node) = gen_binop(AST_MUL, (yyvsp[-2].node), (yyvsp[0].node)); } -#line 2683 "gen/gen_parser.c" +#line 2682 "gen/gen_parser.c" break; case 12: /* binary_op: expr "/" expr */ -#line 171 "src/parser.y" +#line 173 "src/parser.y" { (yyval.node) = gen_binop(AST_DIV, (yyvsp[-2].node), (yyvsp[0].node)); } -#line 2689 "gen/gen_parser.c" +#line 2688 "gen/gen_parser.c" break; case 13: /* binary_op: expr "%" expr */ -#line 172 "src/parser.y" +#line 174 "src/parser.y" { (yyval.node) = gen_binop(AST_REM, (yyvsp[-2].node), (yyvsp[0].node)); } -#line 2695 "gen/gen_parser.c" +#line 2694 "gen/gen_parser.c" break; case 14: /* binary_op: expr "^" expr */ -#line 173 "src/parser.y" +#line 175 "src/parser.y" { (yyval.node) = gen_binop(AST_XOR, (yyvsp[-2].node), (yyvsp[0].node)); } -#line 2701 "gen/gen_parser.c" +#line 2700 "gen/gen_parser.c" break; case 15: /* binary_op: expr "^^" expr */ -#line 174 "src/parser.y" +#line 176 "src/parser.y" { (yyval.node) = gen_binop(AST_POW, (yyvsp[-2].node), (yyvsp[0].node)); } -#line 2707 "gen/gen_parser.c" +#line 2706 "gen/gen_parser.c" break; case 16: /* binary_op: expr "&" expr */ -#line 175 "src/parser.y" +#line 177 "src/parser.y" { (yyval.node) = gen_binop(AST_AND, (yyvsp[-2].node), (yyvsp[0].node)); } -#line 2713 "gen/gen_parser.c" +#line 2712 "gen/gen_parser.c" break; case 17: /* binary_op: expr "&&" expr */ -#line 176 "src/parser.y" +#line 178 "src/parser.y" { (yyval.node) = gen_binop(AST_LAND, (yyvsp[-2].node), (yyvsp[0].node)); } -#line 2719 "gen/gen_parser.c" +#line 2718 "gen/gen_parser.c" break; case 18: /* binary_op: expr "|" expr */ -#line 177 "src/parser.y" +#line 179 "src/parser.y" { (yyval.node) = gen_binop(AST_OR, (yyvsp[-2].node), (yyvsp[0].node)); } -#line 2725 "gen/gen_parser.c" +#line 2724 "gen/gen_parser.c" break; case 19: /* binary_op: expr "||" expr */ -#line 178 "src/parser.y" +#line 180 "src/parser.y" { (yyval.node) = gen_binop(AST_LOR, (yyvsp[-2].node), (yyvsp[0].node)); } -#line 2731 "gen/gen_parser.c" +#line 2730 "gen/gen_parser.c" break; case 20: /* binary_op: expr "<<" expr */ -#line 179 "src/parser.y" +#line 181 "src/parser.y" { (yyval.node) = gen_binop(AST_LSHIFT, (yyvsp[-2].node), (yyvsp[0].node)); } -#line 2737 "gen/gen_parser.c" +#line 2736 "gen/gen_parser.c" break; case 21: /* binary_op: expr ">>" expr */ -#line 180 "src/parser.y" +#line 182 "src/parser.y" { (yyval.node) = gen_binop(AST_RSHIFT, (yyvsp[-2].node), (yyvsp[0].node)); } -#line 2743 "gen/gen_parser.c" +#line 2742 "gen/gen_parser.c" break; case 22: /* binary_op: expr "+=" expr */ -#line 181 "src/parser.y" +#line 183 "src/parser.y" { (yyval.node) = gen_binop(AST_ASSIGN_ADD, (yyvsp[-2].node), (yyvsp[0].node)); } -#line 2749 "gen/gen_parser.c" +#line 2748 "gen/gen_parser.c" break; case 23: /* binary_op: expr "-=" expr */ -#line 182 "src/parser.y" +#line 184 "src/parser.y" { (yyval.node) = gen_binop(AST_ASSIGN_SUB, (yyvsp[-2].node), (yyvsp[0].node)); } -#line 2755 "gen/gen_parser.c" +#line 2754 "gen/gen_parser.c" break; case 24: /* binary_op: expr "*=" expr */ -#line 183 "src/parser.y" +#line 185 "src/parser.y" { (yyval.node) = gen_binop(AST_ASSIGN_MUL, (yyvsp[-2].node), (yyvsp[0].node)); } -#line 2761 "gen/gen_parser.c" +#line 2760 "gen/gen_parser.c" break; case 25: /* binary_op: expr "/=" expr */ -#line 184 "src/parser.y" +#line 186 "src/parser.y" { (yyval.node) = gen_binop(AST_ASSIGN_DIV, (yyvsp[-2].node), (yyvsp[0].node)); } -#line 2767 "gen/gen_parser.c" +#line 2766 "gen/gen_parser.c" break; case 26: /* binary_op: expr "%=" expr */ -#line 185 "src/parser.y" +#line 187 "src/parser.y" { (yyval.node) = gen_binop(AST_ASSIGN_REM, (yyvsp[-2].node), (yyvsp[0].node)); } -#line 2773 "gen/gen_parser.c" +#line 2772 "gen/gen_parser.c" break; case 27: /* binary_op: expr "&=" expr */ -#line 186 "src/parser.y" +#line 188 "src/parser.y" { (yyval.node) = gen_binop(AST_ASSIGN_AND, (yyvsp[-2].node), (yyvsp[0].node)); } -#line 2779 "gen/gen_parser.c" +#line 2778 "gen/gen_parser.c" break; case 28: /* binary_op: expr "|=" expr */ -#line 187 "src/parser.y" +#line 189 "src/parser.y" { (yyval.node) = gen_binop(AST_ASSIGN_OR, (yyvsp[-2].node), (yyvsp[0].node)); } -#line 2785 "gen/gen_parser.c" +#line 2784 "gen/gen_parser.c" break; case 29: /* binary_op: expr "^=" expr */ -#line 188 "src/parser.y" +#line 190 "src/parser.y" { (yyval.node) = gen_binop(AST_ASSIGN_XOR, (yyvsp[-2].node), (yyvsp[0].node)); } -#line 2791 "gen/gen_parser.c" +#line 2790 "gen/gen_parser.c" break; case 30: /* binary_op: expr "<<=" expr */ -#line 189 "src/parser.y" +#line 191 "src/parser.y" { (yyval.node) = gen_binop(AST_ASSIGN_LSHIFT, (yyvsp[-2].node), (yyvsp[0].node)); } -#line 2799 "gen/gen_parser.c" +#line 2798 "gen/gen_parser.c" break; case 31: /* binary_op: expr ">>=" expr */ -#line 192 "src/parser.y" +#line 194 "src/parser.y" { (yyval.node) = gen_binop(AST_ASSIGN_RSHIFT, (yyvsp[-2].node), (yyvsp[0].node)); } -#line 2807 "gen/gen_parser.c" +#line 2806 "gen/gen_parser.c" break; case 32: /* binary_op: expr "<" expr */ -#line 195 "src/parser.y" +#line 197 "src/parser.y" { (yyval.node) = gen_binop(AST_LT, (yyvsp[-2].node), (yyvsp[0].node)); } -#line 2813 "gen/gen_parser.c" +#line 2812 "gen/gen_parser.c" break; case 33: /* binary_op: expr ">" expr */ -#line 196 "src/parser.y" +#line 198 "src/parser.y" { (yyval.node) = gen_binop(AST_GT, (yyvsp[-2].node), (yyvsp[0].node)); } -#line 2819 "gen/gen_parser.c" +#line 2818 "gen/gen_parser.c" break; case 34: /* binary_op: expr "<=" expr */ -#line 197 "src/parser.y" +#line 199 "src/parser.y" { (yyval.node) = gen_binop(AST_LE, (yyvsp[-2].node), (yyvsp[0].node)); } -#line 2825 "gen/gen_parser.c" +#line 2824 "gen/gen_parser.c" break; case 35: /* binary_op: expr ">=" expr */ -#line 198 "src/parser.y" +#line 200 "src/parser.y" { (yyval.node) = gen_binop(AST_GE, (yyvsp[-2].node), (yyvsp[0].node)); } -#line 2831 "gen/gen_parser.c" +#line 2830 "gen/gen_parser.c" break; case 36: /* binary_op: expr "!=" expr */ -#line 199 "src/parser.y" +#line 201 "src/parser.y" { (yyval.node) = gen_binop(AST_NE, (yyvsp[-2].node), (yyvsp[0].node)); } -#line 2837 "gen/gen_parser.c" +#line 2836 "gen/gen_parser.c" break; case 37: /* binary_op: expr "==" expr */ -#line 200 "src/parser.y" +#line 202 "src/parser.y" { (yyval.node) = gen_binop(AST_EQ, (yyvsp[-2].node), (yyvsp[0].node)); } -#line 2843 "gen/gen_parser.c" +#line 2842 "gen/gen_parser.c" break; case 38: /* unary_op: "-" expr */ -#line 203 "src/parser.y" +#line 205 "src/parser.y" { (yyval.node) = gen_unop(AST_NEG, (yyvsp[0].node)); } -#line 2849 "gen/gen_parser.c" +#line 2848 "gen/gen_parser.c" break; case 39: /* unary_op: "!" expr */ -#line 204 "src/parser.y" +#line 206 "src/parser.y" { (yyval.node) = gen_unop(AST_LNOT, (yyvsp[0].node)); } -#line 2855 "gen/gen_parser.c" +#line 2854 "gen/gen_parser.c" break; case 40: /* unary_op: "&" expr */ -#line 205 "src/parser.y" +#line 207 "src/parser.y" { (yyval.node) = gen_unop(AST_REF, (yyvsp[0].node)); } -#line 2861 "gen/gen_parser.c" +#line 2860 "gen/gen_parser.c" break; case 41: /* unary_op: "'" expr */ -#line 206 "src/parser.y" +#line 208 "src/parser.y" { (yyval.node) = gen_unop(AST_DEREF, (yyvsp[0].node)); } -#line 2867 "gen/gen_parser.c" +#line 2866 "gen/gen_parser.c" break; case 42: /* unary_op: "~" expr */ -#line 207 "src/parser.y" +#line 209 "src/parser.y" { (yyval.node) = gen_unop(AST_NOT, (yyvsp[0].node)); } -#line 2873 "gen/gen_parser.c" +#line 2872 "gen/gen_parser.c" break; case 43: /* arg: "&" var_decl */ -#line 210 "src/parser.y" +#line 212 "src/parser.y" { (yyval.node) = gen_unop(AST_REF, (yyvsp[0].node)); } -#line 2879 "gen/gen_parser.c" +#line 2878 "gen/gen_parser.c" break; case 44: /* arg: var_decl */ -#line 211 "src/parser.y" +#line 213 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 2885 "gen/gen_parser.c" +#line 2884 "gen/gen_parser.c" break; case 45: /* arg: init_expr */ -#line 212 "src/parser.y" +#line 214 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 2891 "gen/gen_parser.c" +#line 2890 "gen/gen_parser.c" break; case 46: /* arg_list: arg "," arg_list */ -#line 215 "src/parser.y" +#line 217 "src/parser.y" { (yyval.node) = (yyvsp[-2].node); (yyvsp[-2].node)->next = (yyvsp[0].node); } -#line 2897 "gen/gen_parser.c" +#line 2896 "gen/gen_parser.c" break; case 47: /* arg_list: arg */ -#line 216 "src/parser.y" +#line 218 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 2903 "gen/gen_parser.c" +#line 2902 "gen/gen_parser.c" break; case 48: /* param_decl: type */ -#line 219 "src/parser.y" +#line 221 "src/parser.y" { (yyval.node) = gen_var(NULL, (yyvsp[0].node), NULL); } -#line 2909 "gen/gen_parser.c" +#line 2908 "gen/gen_parser.c" break; case 49: /* decl_list: var_decl "," decl_list */ -#line 221 "src/parser.y" +#line 223 "src/parser.y" { (yyval.node) = (yyvsp[-2].node); (yyvsp[-2].node)->next = (yyvsp[0].node); } -#line 2915 "gen/gen_parser.c" +#line 2914 "gen/gen_parser.c" break; case 50: /* decl_list: param_decl "," decl_list */ -#line 222 "src/parser.y" +#line 224 "src/parser.y" { (yyval.node) = (yyvsp[-2].node); (yyvsp[-2].node)->next = (yyvsp[0].node); } -#line 2921 "gen/gen_parser.c" +#line 2920 "gen/gen_parser.c" break; case 51: /* decl_list: var_decl */ -#line 223 "src/parser.y" +#line 225 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 2927 "gen/gen_parser.c" +#line 2926 "gen/gen_parser.c" break; case 52: /* decl_list: param_decl */ -#line 224 "src/parser.y" +#line 226 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 2933 "gen/gen_parser.c" +#line 2932 "gen/gen_parser.c" break; case 53: /* call: id "(" arg_list ")" */ -#line 228 "src/parser.y" +#line 230 "src/parser.y" { (yyval.node) = gen_call((yyvsp[-3].node), (yyvsp[-1].node)); } -#line 2939 "gen/gen_parser.c" +#line 2938 "gen/gen_parser.c" break; case 54: /* call: id "(" ")" */ -#line 229 "src/parser.y" +#line 231 "src/parser.y" { (yyval.node) = gen_call((yyvsp[-2].node), NULL); } -#line 2945 "gen/gen_parser.c" +#line 2944 "gen/gen_parser.c" break; case 55: /* defer: "defer" "(" expr ")" */ -#line 232 "src/parser.y" +#line 234 "src/parser.y" { (yyval.node) = gen_defer((yyvsp[-1].node)); } -#line 2951 "gen/gen_parser.c" +#line 2950 "gen/gen_parser.c" break; case 56: /* expr: id */ -#line 236 "src/parser.y" +#line 238 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 2957 "gen/gen_parser.c" +#line 2956 "gen/gen_parser.c" break; case 57: /* expr: expr "." id */ -#line 237 "src/parser.y" +#line 239 "src/parser.y" { (yyval.node) = gen_dot((yyvsp[-2].node), (yyvsp[0].node)); } -#line 2963 "gen/gen_parser.c" +#line 2962 "gen/gen_parser.c" break; case 58: /* expr: "..." id */ -#line 238 "src/parser.y" +#line 240 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 2969 "gen/gen_parser.c" +#line 2968 "gen/gen_parser.c" break; case 59: /* expr: "@" */ -#line 239 "src/parser.y" +#line 241 "src/parser.y" { (yyval.node) = gen_last(); } -#line 2975 "gen/gen_parser.c" +#line 2974 "gen/gen_parser.c" break; case 60: /* expr: INT */ -#line 240 "src/parser.y" +#line 242 "src/parser.y" { (yyval.node) = gen_int((yyvsp[0].integer)); (yyval.node)->loc = to_src_loc(&yylloc); } -#line 2981 "gen/gen_parser.c" +#line 2980 "gen/gen_parser.c" break; case 61: /* expr: FLOAT */ -#line 241 "src/parser.y" +#line 243 "src/parser.y" { (yyval.node) = gen_float((yyvsp[0].dbl)); (yyval.node)->loc = to_src_loc(&yylloc); } -#line 2987 "gen/gen_parser.c" +#line 2986 "gen/gen_parser.c" break; case 62: /* expr: STRING */ -#line 242 "src/parser.y" +#line 244 "src/parser.y" { (yyval.node) = gen_string(clone_string((yyvsp[0].str))); (yyval.node)->loc = to_src_loc(&yylloc); } -#line 2996 "gen/gen_parser.c" +#line 2995 "gen/gen_parser.c" break; case 63: /* expr: "(" expr ")" */ -#line 246 "src/parser.y" +#line 248 "src/parser.y" { (yyval.node) = (yyvsp[-1].node); } -#line 3002 "gen/gen_parser.c" +#line 3001 "gen/gen_parser.c" break; case 64: /* expr: assign */ -#line 247 "src/parser.y" +#line 249 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3008 "gen/gen_parser.c" +#line 3007 "gen/gen_parser.c" break; case 65: /* expr: call */ -#line 248 "src/parser.y" +#line 250 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3014 "gen/gen_parser.c" +#line 3013 "gen/gen_parser.c" break; case 66: /* expr: defer */ -#line 249 "src/parser.y" +#line 251 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3020 "gen/gen_parser.c" +#line 3019 "gen/gen_parser.c" break; case 67: /* expr: binary_op */ -#line 250 "src/parser.y" +#line 252 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3026 "gen/gen_parser.c" +#line 3025 "gen/gen_parser.c" break; case 68: /* expr: unary_op */ -#line 251 "src/parser.y" +#line 253 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3032 "gen/gen_parser.c" +#line 3031 "gen/gen_parser.c" break; case 69: /* expr: "(" var_init ")" */ -#line 252 "src/parser.y" +#line 254 "src/parser.y" { (yyval.node) = (yyvsp[-1].node); } -#line 3038 "gen/gen_parser.c" +#line 3037 "gen/gen_parser.c" break; case 70: /* expr: "sizeof" expr */ -#line 253 "src/parser.y" +#line 255 "src/parser.y" { (yyval.node) = gen_sizeof((yyvsp[0].node)); } -#line 3044 "gen/gen_parser.c" +#line 3043 "gen/gen_parser.c" break; case 71: /* expr: expr "as" type */ -#line 254 "src/parser.y" +#line 256 "src/parser.y" { (yyval.node) = gen_cast((yyvsp[-2].node), (yyvsp[0].node)); } -#line 3050 "gen/gen_parser.c" +#line 3049 "gen/gen_parser.c" break; - case 72: /* expr: "as" type */ -#line 255 "src/parser.y" + case 72: /* expr: id "::" type */ +#line 257 "src/parser.y" + { (yyval.node) = gen_fetch((yyvsp[-2].node), (yyvsp[0].node)); } +#line 3055 "gen/gen_parser.c" + break; + + case 73: /* expr: "as" type */ +#line 258 "src/parser.y" { (yyval.node) = gen_as((yyvsp[0].node)); } -#line 3056 "gen/gen_parser.c" +#line 3061 "gen/gen_parser.c" break; - case 73: /* expr: embed */ -#line 256 "src/parser.y" + case 74: /* expr: embed */ +#line 259 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3062 "gen/gen_parser.c" +#line 3067 "gen/gen_parser.c" break; - case 74: /* expr: lambda */ -#line 257 "src/parser.y" + case 75: /* expr: lambda */ +#line 260 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3068 "gen/gen_parser.c" +#line 3073 "gen/gen_parser.c" break; - case 75: /* while: "while" expr body */ -#line 260 "src/parser.y" + case 76: /* while: "while" expr body */ +#line 263 "src/parser.y" { (yyval.node) = gen_while((yyvsp[-1].node), (yyvsp[0].node)); } -#line 3074 "gen/gen_parser.c" +#line 3079 "gen/gen_parser.c" break; - case 76: /* do_while: "do" body "while" expr ";" */ -#line 263 "src/parser.y" + case 77: /* do_while: "do" body "while" expr ";" */ +#line 266 "src/parser.y" { (yyval.node) = gen_while((yyvsp[-3].node), (yyvsp[-1].node)); ast_set_flags((yyval.node), AST_FLAG_DELAYED); } -#line 3083 "gen/gen_parser.c" +#line 3088 "gen/gen_parser.c" break; - case 77: /* goto: "goto" id */ -#line 269 "src/parser.y" + case 78: /* goto: "goto" id */ +#line 272 "src/parser.y" { (yyval.node) = gen_goto(gen_label((yyvsp[0].node))); } -#line 3089 "gen/gen_parser.c" +#line 3094 "gen/gen_parser.c" break; - case 78: /* statement: expr ";" */ -#line 271 "src/parser.y" + case 79: /* statement: expr ";" */ +#line 274 "src/parser.y" { (yyval.node) = (yyvsp[-1].node); } -#line 3095 "gen/gen_parser.c" +#line 3100 "gen/gen_parser.c" break; - case 79: /* statement: "return" init_expr ";" */ -#line 272 "src/parser.y" + case 80: /* statement: "return" init_expr ";" */ +#line 275 "src/parser.y" { (yyval.node) = gen_return((yyvsp[-1].node)); } -#line 3101 "gen/gen_parser.c" +#line 3106 "gen/gen_parser.c" break; - case 80: /* statement: "return" ";" */ -#line 273 "src/parser.y" + case 81: /* statement: "return" ";" */ +#line 276 "src/parser.y" { (yyval.node) = gen_return(NULL); } -#line 3107 "gen/gen_parser.c" +#line 3112 "gen/gen_parser.c" break; - case 81: /* statement: "break" ";" */ -#line 274 "src/parser.y" + case 82: /* statement: "break" ";" */ +#line 277 "src/parser.y" { (yyval.node) = gen_ctrl(AST_CTRL_BREAK, to_src_loc(&yylloc)); } -#line 3113 "gen/gen_parser.c" +#line 3118 "gen/gen_parser.c" break; - case 82: /* statement: "continue" ";" */ -#line 275 "src/parser.y" + case 83: /* statement: "continue" ";" */ +#line 278 "src/parser.y" { (yyval.node) = gen_ctrl(AST_CTRL_CONTINUE, to_src_loc(&yylloc)); } -#line 3120 "gen/gen_parser.c" +#line 3125 "gen/gen_parser.c" break; - case 83: /* statement: import ";" */ -#line 277 "src/parser.y" + case 84: /* statement: import ";" */ +#line 280 "src/parser.y" { (yyval.node) = (yyvsp[-1].node); } -#line 3126 "gen/gen_parser.c" +#line 3131 "gen/gen_parser.c" break; - case 84: /* statement: var ";" */ -#line 278 "src/parser.y" + case 85: /* statement: var ";" */ +#line 281 "src/parser.y" { (yyval.node) = (yyvsp[-1].node); } -#line 3132 "gen/gen_parser.c" +#line 3137 "gen/gen_parser.c" break; - case 85: /* statement: if */ -#line 279 "src/parser.y" + case 86: /* statement: if */ +#line 282 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3138 "gen/gen_parser.c" +#line 3143 "gen/gen_parser.c" break; - case 86: /* statement: goto ";" */ -#line 280 "src/parser.y" + case 87: /* statement: goto ";" */ +#line 283 "src/parser.y" { (yyval.node) = (yyvsp[-1].node); } -#line 3144 "gen/gen_parser.c" +#line 3149 "gen/gen_parser.c" break; - case 87: /* statement: id ":" */ -#line 281 "src/parser.y" + case 88: /* statement: id ":" */ +#line 284 "src/parser.y" { (yyval.node) = gen_label((yyvsp[-1].node)); } -#line 3150 "gen/gen_parser.c" +#line 3155 "gen/gen_parser.c" break; - case 88: /* statement: for */ -#line 282 "src/parser.y" + case 89: /* statement: for */ +#line 285 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3156 "gen/gen_parser.c" +#line 3161 "gen/gen_parser.c" break; - case 89: /* statement: const */ -#line 283 "src/parser.y" + case 90: /* statement: const */ +#line 286 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3162 "gen/gen_parser.c" +#line 3167 "gen/gen_parser.c" break; - case 90: /* statement: while */ -#line 284 "src/parser.y" + case 91: /* statement: while */ +#line 287 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3168 "gen/gen_parser.c" +#line 3173 "gen/gen_parser.c" break; - case 91: /* statement: do_while */ -#line 285 "src/parser.y" + case 92: /* statement: do_while */ +#line 288 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3174 "gen/gen_parser.c" +#line 3179 "gen/gen_parser.c" break; - case 92: /* statement: switch */ -#line 286 "src/parser.y" + case 93: /* statement: switch */ +#line 289 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3180 "gen/gen_parser.c" +#line 3185 "gen/gen_parser.c" break; - case 93: /* statement: macro */ -#line 287 "src/parser.y" + case 94: /* statement: macro */ +#line 290 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3186 "gen/gen_parser.c" +#line 3191 "gen/gen_parser.c" break; - case 94: /* statement: struct */ -#line 288 "src/parser.y" + case 95: /* statement: struct */ +#line 291 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3192 "gen/gen_parser.c" +#line 3197 "gen/gen_parser.c" break; - case 95: /* statement: type_alias ";" */ -#line 289 "src/parser.y" + case 96: /* statement: type_alias ";" */ +#line 292 "src/parser.y" { (yyval.node) = (yyvsp[-1].node); } -#line 3198 "gen/gen_parser.c" +#line 3203 "gen/gen_parser.c" break; - case 96: /* statement: type_template */ -#line 290 "src/parser.y" + case 97: /* statement: type_template */ +#line 293 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3204 "gen/gen_parser.c" +#line 3209 "gen/gen_parser.c" break; - case 97: /* statement: enum */ -#line 291 "src/parser.y" + case 98: /* statement: enum */ +#line 294 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3210 "gen/gen_parser.c" +#line 3215 "gen/gen_parser.c" break; - case 98: /* statement: body */ -#line 292 "src/parser.y" + case 99: /* statement: body */ +#line 295 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3216 "gen/gen_parser.c" +#line 3221 "gen/gen_parser.c" break; - case 99: /* statement: ";" */ -#line 293 "src/parser.y" + case 100: /* statement: ";" */ +#line 296 "src/parser.y" { (yyval.node) = gen_empty(); } -#line 3222 "gen/gen_parser.c" +#line 3227 "gen/gen_parser.c" break; - case 100: /* statement: error */ -#line 294 "src/parser.y" + case 101: /* statement: error */ +#line 297 "src/parser.y" { /* TODO: figure out how to destroy any and all possible ast nodes we * may have generated up until the error */ @@ -3239,56 +3242,56 @@ yyreduce: yyclearin; yyerrok; } -#line 3241 "gen/gen_parser.c" +#line 3246 "gen/gen_parser.c" break; - case 101: /* statement_list: statement statement_list */ -#line 310 "src/parser.y" + case 102: /* statement_list: statement statement_list */ +#line 313 "src/parser.y" { (yyval.node) = (yyvsp[-1].node); (yyvsp[-1].node)->next = (yyvsp[0].node); } -#line 3247 "gen/gen_parser.c" +#line 3252 "gen/gen_parser.c" break; - case 102: /* statement_list: statement */ -#line 311 "src/parser.y" + case 103: /* statement_list: statement */ +#line 314 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3253 "gen/gen_parser.c" +#line 3258 "gen/gen_parser.c" break; - case 103: /* body: "{" statement_list "}" */ -#line 314 "src/parser.y" + case 104: /* body: "{" statement_list "}" */ +#line 317 "src/parser.y" { (yyval.node) = gen_block((yyvsp[-1].node)); } -#line 3259 "gen/gen_parser.c" +#line 3264 "gen/gen_parser.c" break; - case 104: /* body: "{" "}" */ -#line 315 "src/parser.y" + case 105: /* body: "{" "}" */ +#line 318 "src/parser.y" { (yyval.node) = gen_block(gen_empty()); } -#line 3265 "gen/gen_parser.c" +#line 3270 "gen/gen_parser.c" break; - case 105: /* macro_list: id "," macro_list */ -#line 318 "src/parser.y" + case 106: /* macro_list: id "," macro_list */ +#line 321 "src/parser.y" { (yyval.node) = (yyvsp[-2].node); (yyval.node)->next = (yyvsp[0].node); } -#line 3271 "gen/gen_parser.c" +#line 3276 "gen/gen_parser.c" break; - case 106: /* macro_list: id */ -#line 319 "src/parser.y" + case 107: /* macro_list: id */ +#line 322 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3277 "gen/gen_parser.c" +#line 3282 "gen/gen_parser.c" break; - case 107: /* macro: "define" id "(" macro_list ")" body */ -#line 322 "src/parser.y" + case 108: /* macro: "define" id "(" macro_list ")" body */ +#line 325 "src/parser.y" { (yyval.node) = gen_macro((yyvsp[-4].node), (yyvsp[-2].node), (yyvsp[0].node)); ast_set_flags((yyvsp[0].node), AST_FLAG_UNHYGIENIC); } -#line 3286 "gen/gen_parser.c" +#line 3291 "gen/gen_parser.c" break; - case 108: /* macro: "define" id "(" macro_list "..." id ")" body */ -#line 326 "src/parser.y" + case 109: /* macro: "define" id "(" macro_list "..." id ")" body */ +#line 329 "src/parser.y" { /* TODO: the location data of the variadic ID is way off */ ast_append((yyvsp[-4].node), (yyvsp[-2].node)); @@ -3296,711 +3299,711 @@ yyreduce: ast_set_flags((yyval.node), AST_FLAG_VARIADIC); ast_set_flags((yyvsp[0].node), AST_FLAG_UNHYGIENIC); } -#line 3298 "gen/gen_parser.c" +#line 3303 "gen/gen_parser.c" break; - case 109: /* macro: "define" id "(" ")" body */ -#line 333 "src/parser.y" + case 110: /* macro: "define" id "(" ")" body */ +#line 336 "src/parser.y" { (yyval.node) = gen_macro((yyvsp[-3].node), NULL, (yyvsp[0].node)); ast_set_flags((yyvsp[0].node), AST_FLAG_UNHYGIENIC); } -#line 3307 "gen/gen_parser.c" +#line 3312 "gen/gen_parser.c" break; - case 110: /* expr_list: expr "," expr_list */ -#line 339 "src/parser.y" + case 111: /* expr_list: expr "," expr_list */ +#line 342 "src/parser.y" { (yyval.node) = (yyvsp[-2].node); (yyvsp[-2].node)->next = (yyvsp[0].node); } -#line 3313 "gen/gen_parser.c" +#line 3318 "gen/gen_parser.c" break; - case 111: /* expr_list: expr */ -#line 340 "src/parser.y" + case 112: /* expr_list: expr */ +#line 343 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3319 "gen/gen_parser.c" +#line 3324 "gen/gen_parser.c" break; - case 112: /* struct_init: init_expr */ -#line 343 "src/parser.y" + case 113: /* struct_init: init_expr */ +#line 346 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3325 "gen/gen_parser.c" +#line 3330 "gen/gen_parser.c" break; - case 113: /* struct_init: "." id "=" init_expr */ -#line 344 "src/parser.y" + case 114: /* struct_init: "." id "=" init_expr */ +#line 347 "src/parser.y" { (yyval.node) = gen_var((yyvsp[-2].node), NULL, (yyvsp[0].node)); ast_set_flags((yyval.node), AST_FLAG_MEMBER); } -#line 3334 "gen/gen_parser.c" +#line 3339 "gen/gen_parser.c" break; - case 114: /* struct_inits: struct_init "," struct_inits */ -#line 350 "src/parser.y" + case 115: /* struct_inits: struct_init "," struct_inits */ +#line 353 "src/parser.y" { (yyval.node) = (yyvsp[-2].node); (yyvsp[-2].node)->next = (yyvsp[0].node); } -#line 3340 "gen/gen_parser.c" +#line 3345 "gen/gen_parser.c" break; - case 115: /* struct_inits: struct_init */ -#line 351 "src/parser.y" + case 116: /* struct_inits: struct_init */ +#line 354 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3346 "gen/gen_parser.c" +#line 3351 "gen/gen_parser.c" break; - case 116: /* struct_construct: "{" struct_inits "}" */ -#line 354 "src/parser.y" + case 117: /* struct_construct: "{" struct_inits "}" */ +#line 357 "src/parser.y" { (yyval.node) = gen_init((yyvsp[-1].node)); } -#line 3352 "gen/gen_parser.c" +#line 3357 "gen/gen_parser.c" break; - case 117: /* init_expr: expr */ -#line 357 "src/parser.y" + case 118: /* init_expr: expr */ +#line 360 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3358 "gen/gen_parser.c" +#line 3363 "gen/gen_parser.c" break; - case 118: /* init_expr: expr_if */ -#line 358 "src/parser.y" + case 119: /* init_expr: expr_if */ +#line 361 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3364 "gen/gen_parser.c" +#line 3369 "gen/gen_parser.c" break; - case 119: /* init_expr: struct_construct */ -#line 359 "src/parser.y" + case 120: /* init_expr: struct_construct */ +#line 362 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3370 "gen/gen_parser.c" +#line 3375 "gen/gen_parser.c" break; - case 120: /* init_expr: struct_construct "as" type */ -#line 360 "src/parser.y" + case 121: /* init_expr: struct_construct "as" type */ +#line 363 "src/parser.y" { (yyval.node) = gen_cast((yyvsp[-2].node), (yyvsp[0].node)); } -#line 3376 "gen/gen_parser.c" +#line 3381 "gen/gen_parser.c" break; - case 121: /* cond: expr */ -#line 363 "src/parser.y" + case 122: /* cond: expr */ +#line 366 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3382 "gen/gen_parser.c" +#line 3387 "gen/gen_parser.c" break; - case 122: /* cond: "(" expr_if ")" */ -#line 364 "src/parser.y" + case 123: /* cond: "(" expr_if ")" */ +#line 367 "src/parser.y" { (yyval.node) = (yyvsp[-1].node); } -#line 3388 "gen/gen_parser.c" +#line 3393 "gen/gen_parser.c" break; - case 123: /* expr_if: "if" cond body "else" body */ -#line 368 "src/parser.y" + case 124: /* expr_if: "if" cond body "else" body */ +#line 371 "src/parser.y" { (yyval.node) = gen_if((yyvsp[-3].node), (yyvsp[-2].node), (yyvsp[0].node)); } -#line 3394 "gen/gen_parser.c" +#line 3399 "gen/gen_parser.c" break; - case 124: /* expr_if: "if" cond body "else" expr_if */ -#line 369 "src/parser.y" + case 125: /* expr_if: "if" cond body "else" expr_if */ +#line 372 "src/parser.y" { (yyval.node) = gen_if((yyvsp[-3].node), (yyvsp[-2].node), (yyvsp[0].node)); } -#line 3400 "gen/gen_parser.c" +#line 3405 "gen/gen_parser.c" break; - case 125: /* if: "if" cond body */ -#line 372 "src/parser.y" + case 126: /* if: "if" cond body */ +#line 375 "src/parser.y" { (yyval.node) = gen_if((yyvsp[-1].node), (yyvsp[0].node), NULL); } -#line 3406 "gen/gen_parser.c" +#line 3411 "gen/gen_parser.c" break; - case 126: /* if: "if" cond body "else" body */ -#line 373 "src/parser.y" + case 127: /* if: "if" cond body "else" body */ +#line 376 "src/parser.y" { (yyval.node) = gen_if((yyvsp[-3].node), (yyvsp[-2].node), (yyvsp[0].node)); } -#line 3412 "gen/gen_parser.c" +#line 3417 "gen/gen_parser.c" break; - case 127: /* if: "if" cond body "else" if */ -#line 374 "src/parser.y" + case 128: /* if: "if" cond body "else" if */ +#line 377 "src/parser.y" { (yyval.node) = gen_if((yyvsp[-3].node), (yyvsp[-2].node), (yyvsp[0].node)); } -#line 3418 "gen/gen_parser.c" +#line 3423 "gen/gen_parser.c" break; - case 128: /* for: "for" arg ";" expr ";" expr body */ -#line 377 "src/parser.y" + case 129: /* for: "for" arg ";" expr ";" expr body */ +#line 380 "src/parser.y" { (yyval.node) = gen_for((yyvsp[-5].node), (yyvsp[-3].node), (yyvsp[-1].node), (yyvsp[0].node)); } -#line 3424 "gen/gen_parser.c" +#line 3429 "gen/gen_parser.c" break; - case 129: /* case: "case" expr ":" statement_list */ -#line 380 "src/parser.y" + case 130: /* case: "case" expr ":" statement_list */ +#line 383 "src/parser.y" { (yyval.node) = gen_case((yyvsp[-2].node), (yyvsp[0].node)); } -#line 3430 "gen/gen_parser.c" +#line 3435 "gen/gen_parser.c" break; - case 130: /* case_list: case case_list */ -#line 383 "src/parser.y" + case 131: /* case_list: case case_list */ +#line 386 "src/parser.y" { (yyval.node) = (yyvsp[-1].node); (yyvsp[-1].node)->next = (yyvsp[0].node); } -#line 3436 "gen/gen_parser.c" +#line 3441 "gen/gen_parser.c" break; - case 131: /* case_list: case */ -#line 384 "src/parser.y" + case 132: /* case_list: case */ +#line 387 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3442 "gen/gen_parser.c" +#line 3447 "gen/gen_parser.c" break; - case 132: /* switch: "switch" expr "{" case_list "}" */ -#line 387 "src/parser.y" + case 133: /* switch: "switch" expr "{" case_list "}" */ +#line 390 "src/parser.y" { (yyval.node) = gen_switch((yyvsp[-3].node), (yyvsp[-1].node)); } -#line 3448 "gen/gen_parser.c" +#line 3453 "gen/gen_parser.c" break; - case 133: /* const_for: "for" id ":" expr_list body */ -#line 390 "src/parser.y" + case 134: /* const_for: "for" id ":" expr_list body */ +#line 393 "src/parser.y" { /* TODO: should id be a separate rule? */ (yyval.node) = gen_for((yyvsp[-3].node), NULL, (yyvsp[-1].node), (yyvsp[0].node)); ast_set_flags((yyvsp[0].node), AST_FLAG_UNHYGIENIC); } -#line 3458 "gen/gen_parser.c" +#line 3463 "gen/gen_parser.c" break; - case 134: /* const_if: "if" expr body */ -#line 397 "src/parser.y" + case 135: /* const_if: "if" expr body */ +#line 400 "src/parser.y" { (yyval.node) = gen_if((yyvsp[-1].node), (yyvsp[0].node), NULL); ast_set_flags((yyvsp[0].node), AST_FLAG_UNHYGIENIC); } -#line 3467 "gen/gen_parser.c" +#line 3472 "gen/gen_parser.c" break; - case 135: /* const_if: "if" expr body "else" body */ -#line 401 "src/parser.y" + case 136: /* const_if: "if" expr body "else" body */ +#line 404 "src/parser.y" { (yyval.node) = gen_if((yyvsp[-3].node), (yyvsp[-2].node), (yyvsp[0].node)); ast_set_flags((yyvsp[-2].node), AST_FLAG_UNHYGIENIC); ast_set_flags((yyvsp[0].node), AST_FLAG_UNHYGIENIC); } -#line 3477 "gen/gen_parser.c" +#line 3482 "gen/gen_parser.c" break; - case 136: /* const_if: "if" expr body "else" const_if */ -#line 406 "src/parser.y" + case 137: /* const_if: "if" expr body "else" const_if */ +#line 409 "src/parser.y" { (yyval.node) = gen_if((yyvsp[-3].node), (yyvsp[-2].node), (yyvsp[0].node)); ast_set_flags((yyvsp[-2].node), AST_FLAG_UNHYGIENIC); } -#line 3486 "gen/gen_parser.c" +#line 3491 "gen/gen_parser.c" break; - case 137: /* const: "const" const_if */ -#line 414 "src/parser.y" + case 138: /* const: "const" const_if */ +#line 417 "src/parser.y" { (yyval.node) = (yyvsp[0].node); ast_set_flags((yyval.node), AST_FLAG_CONST); } -#line 3493 "gen/gen_parser.c" +#line 3498 "gen/gen_parser.c" break; - case 138: /* const: "const" const_for */ -#line 416 "src/parser.y" + case 139: /* const: "const" const_for */ +#line 419 "src/parser.y" { (yyval.node) = (yyvsp[0].node); ast_set_flags((yyval.node), AST_FLAG_CONST); } -#line 3500 "gen/gen_parser.c" +#line 3505 "gen/gen_parser.c" break; - case 139: /* func_sign: "(" decl_list "=>" type ")" */ -#line 420 "src/parser.y" + case 140: /* func_sign: "(" decl_list "=>" type ")" */ +#line 423 "src/parser.y" { (yyval.node) = gen_type(AST_TYPE_SIGN, NULL, (yyvsp[-3].node), (yyvsp[-1].node)); } -#line 3508 "gen/gen_parser.c" +#line 3513 "gen/gen_parser.c" break; - case 140: /* func_sign: "(" decl_list ")" */ -#line 423 "src/parser.y" + case 141: /* func_sign: "(" decl_list ")" */ +#line 426 "src/parser.y" { (yyval.node) = gen_type(AST_TYPE_SIGN, NULL, (yyvsp[-1].node), NULL); } -#line 3515 "gen/gen_parser.c" +#line 3520 "gen/gen_parser.c" break; - case 141: /* func_sign: "(" decl_list "=>" ")" */ -#line 425 "src/parser.y" + case 142: /* func_sign: "(" decl_list "=>" ")" */ +#line 428 "src/parser.y" { (yyval.node) = gen_type(AST_TYPE_SIGN, NULL, (yyvsp[-2].node), NULL); } -#line 3522 "gen/gen_parser.c" +#line 3527 "gen/gen_parser.c" break; - case 142: /* func_sign: "(" "=>" type ")" */ -#line 427 "src/parser.y" + case 143: /* func_sign: "(" "=>" type ")" */ +#line 430 "src/parser.y" { (yyval.node) = gen_type(AST_TYPE_SIGN, NULL, NULL, (yyvsp[-1].node)); } -#line 3529 "gen/gen_parser.c" +#line 3534 "gen/gen_parser.c" break; - case 143: /* func_sign: "(" ")" */ -#line 429 "src/parser.y" + case 144: /* func_sign: "(" ")" */ +#line 432 "src/parser.y" { (yyval.node) = gen_type(AST_TYPE_SIGN, NULL, NULL, NULL); } -#line 3536 "gen/gen_parser.c" +#line 3541 "gen/gen_parser.c" break; - case 144: /* variadic_sign: func_sign */ -#line 433 "src/parser.y" + case 145: /* variadic_sign: func_sign */ +#line 436 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3542 "gen/gen_parser.c" +#line 3547 "gen/gen_parser.c" break; - case 145: /* variadic_sign: "(" decl_list "..." id "=>" type ")" */ -#line 434 "src/parser.y" + case 146: /* variadic_sign: "(" decl_list "..." id "=>" type ")" */ +#line 437 "src/parser.y" { ast_append((yyvsp[-5].node), (yyvsp[-3].node)); (yyval.node) = gen_type(AST_TYPE_SIGN, NULL, (yyvsp[-5].node), (yyvsp[-1].node)); ast_set_flags((yyval.node), AST_FLAG_VARIADIC); } -#line 3552 "gen/gen_parser.c" +#line 3557 "gen/gen_parser.c" break; - case 146: /* type: id */ -#line 441 "src/parser.y" + case 147: /* type: id */ +#line 444 "src/parser.y" { (yyval.node) = gen_type(AST_TYPE_ID, (yyvsp[0].node), NULL, NULL); } -#line 3558 "gen/gen_parser.c" +#line 3563 "gen/gen_parser.c" break; - case 147: /* type: "'" func_sign */ -#line 442 "src/parser.y" + case 148: /* type: "'" func_sign */ +#line 445 "src/parser.y" { (yyval.node) = gen_type(AST_TYPE_POINTER, NULL, NULL, NULL); (yyval.node)->next = (yyvsp[0].node); } -#line 3567 "gen/gen_parser.c" +#line 3572 "gen/gen_parser.c" break; - case 148: /* type: id "(" type_list ")" */ -#line 446 "src/parser.y" + case 149: /* type: id "(" type_list ")" */ +#line 449 "src/parser.y" { (yyval.node) = gen_type(AST_TYPE_STRUCT, (yyvsp[-3].node), (yyvsp[-1].node), NULL); } -#line 3575 "gen/gen_parser.c" +#line 3580 "gen/gen_parser.c" break; - case 149: /* type: "'" type */ -#line 449 "src/parser.y" + case 150: /* type: "'" type */ +#line 452 "src/parser.y" { (yyval.node) = gen_type(AST_TYPE_POINTER, NULL, NULL, NULL); (yyval.node)->_type.next = (yyvsp[0].node); } -#line 3584 "gen/gen_parser.c" +#line 3589 "gen/gen_parser.c" break; - case 150: /* type: "[" "]" type */ -#line 453 "src/parser.y" + case 151: /* type: "[" "]" type */ +#line 456 "src/parser.y" { (yyval.node) = gen_type(AST_TYPE_ARR, NULL, NULL, NULL); (yyval.node)->_type.next = (yyvsp[0].node); } -#line 3593 "gen/gen_parser.c" +#line 3598 "gen/gen_parser.c" break; - case 151: /* type: "[" expr "]" type */ -#line 457 "src/parser.y" + case 152: /* type: "[" expr "]" type */ +#line 460 "src/parser.y" { (yyval.node) = gen_type(AST_TYPE_ARR, NULL, (yyvsp[-2].node), NULL); (yyval.node)->_type.next = (yyvsp[0].node); } -#line 3602 "gen/gen_parser.c" +#line 3607 "gen/gen_parser.c" break; - case 152: /* type: "typeof" expr */ -#line 461 "src/parser.y" + case 153: /* type: "typeof" expr */ +#line 464 "src/parser.y" { (yyval.node) = gen_type(AST_TYPE_TYPEOF, NULL, (yyvsp[0].node), NULL); } -#line 3610 "gen/gen_parser.c" +#line 3615 "gen/gen_parser.c" break; - case 153: /* var_decl: id "mut" type */ -#line 466 "src/parser.y" + case 154: /* var_decl: id "mut" type */ +#line 469 "src/parser.y" { (yyval.node) = gen_var((yyvsp[-2].node), (yyvsp[0].node), NULL); ast_set_flags((yyval.node), AST_FLAG_MUTABLE); } -#line 3619 "gen/gen_parser.c" +#line 3624 "gen/gen_parser.c" break; - case 154: /* var_decl: id "const" type */ -#line 470 "src/parser.y" + case 155: /* var_decl: id "const" type */ +#line 473 "src/parser.y" { (yyval.node) = gen_var((yyvsp[-2].node), (yyvsp[0].node), NULL); } -#line 3625 "gen/gen_parser.c" +#line 3630 "gen/gen_parser.c" break; - case 155: /* var_decl: id type */ -#line 471 "src/parser.y" + case 156: /* var_decl: id type */ +#line 474 "src/parser.y" { (yyval.node) = gen_var((yyvsp[-1].node), (yyvsp[0].node), NULL); } -#line 3631 "gen/gen_parser.c" +#line 3636 "gen/gen_parser.c" break; - case 156: /* var_init: var_decl "=" init_expr */ -#line 474 "src/parser.y" + case 157: /* var_init: var_decl "=" init_expr */ +#line 477 "src/parser.y" { (yyval.node) = (yyvsp[-2].node); (yyvsp[-2].node)->_var.init = (yyvsp[0].node); } -#line 3637 "gen/gen_parser.c" +#line 3642 "gen/gen_parser.c" break; - case 157: /* var_init: id "mut" "=" init_expr */ -#line 475 "src/parser.y" + case 158: /* var_init: id "mut" "=" init_expr */ +#line 478 "src/parser.y" { (yyval.node) = gen_var((yyvsp[-3].node), NULL, (yyvsp[0].node)); ast_set_flags((yyval.node), AST_FLAG_UNTYPED | AST_FLAG_MUTABLE); } -#line 3646 "gen/gen_parser.c" +#line 3651 "gen/gen_parser.c" break; - case 158: /* var_init: id "const" "=" init_expr */ -#line 479 "src/parser.y" + case 159: /* var_init: id "const" "=" init_expr */ +#line 482 "src/parser.y" { (yyval.node) = gen_var((yyvsp[-3].node), NULL, (yyvsp[0].node)); ast_set_flags((yyval.node), AST_FLAG_UNTYPED); } -#line 3655 "gen/gen_parser.c" +#line 3660 "gen/gen_parser.c" break; - case 159: /* proc: id variadic_sign body */ -#line 485 "src/parser.y" + case 160: /* proc: id variadic_sign body */ +#line 488 "src/parser.y" { (yyval.node) = gen_proc((yyvsp[-2].node), (yyvsp[-1].node), (yyvsp[0].node)); ast_set_flags((yyval.node), (yyvsp[-1].node)->flags); } -#line 3664 "gen/gen_parser.c" +#line 3669 "gen/gen_parser.c" break; - case 160: /* proc: "extern" id func_sign */ -#line 489 "src/parser.y" + case 161: /* proc: "extern" id func_sign */ +#line 492 "src/parser.y" { (yyval.node) = gen_proc((yyvsp[-1].node), (yyvsp[0].node), NULL); ast_set_flags((yyval.node), AST_FLAG_EXTERN); } -#line 3673 "gen/gen_parser.c" +#line 3678 "gen/gen_parser.c" break; - case 161: /* lambda: "[" macro_list "]" func_sign body */ -#line 495 "src/parser.y" + case 162: /* lambda: "[" macro_list "]" func_sign body */ +#line 498 "src/parser.y" { (yyval.node) = gen_lambda((yyvsp[-3].node), (yyvsp[-1].node), (yyvsp[0].node)); } -#line 3679 "gen/gen_parser.c" +#line 3684 "gen/gen_parser.c" break; - case 162: /* struct_elem: var_decl */ -#line 498 "src/parser.y" + case 163: /* struct_elem: var_decl */ +#line 501 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3685 "gen/gen_parser.c" +#line 3690 "gen/gen_parser.c" break; - case 163: /* struct_list: struct_elem ";" struct_list */ -#line 501 "src/parser.y" + case 164: /* struct_list: struct_elem ";" struct_list */ +#line 504 "src/parser.y" { (yyval.node) = (yyvsp[-2].node); (yyvsp[-2].node)->next = (yyvsp[0].node); } -#line 3691 "gen/gen_parser.c" +#line 3696 "gen/gen_parser.c" break; - case 164: /* struct_list: struct_elem ";" */ -#line 502 "src/parser.y" + case 165: /* struct_list: struct_elem ";" */ +#line 505 "src/parser.y" { (yyval.node) = (yyvsp[-1].node); } -#line 3697 "gen/gen_parser.c" +#line 3702 "gen/gen_parser.c" break; - case 165: /* union: "union" id "{" struct_list "}" */ -#line 505 "src/parser.y" + case 166: /* union: "union" id "{" struct_list "}" */ +#line 508 "src/parser.y" { (yyval.node) = gen_union((yyvsp[-3].node), NULL, (yyvsp[-1].node)); } -#line 3705 "gen/gen_parser.c" +#line 3710 "gen/gen_parser.c" break; - case 166: /* union: "union" id "(" generic_list ")" "{" struct_list "}" */ -#line 508 "src/parser.y" + case 167: /* union: "union" id "(" generic_list ")" "{" struct_list "}" */ +#line 511 "src/parser.y" { (yyval.node) = gen_union((yyvsp[-6].node), (yyvsp[-4].node), (yyvsp[-1].node)); } -#line 3713 "gen/gen_parser.c" +#line 3718 "gen/gen_parser.c" break; - case 167: /* generic: id type */ -#line 513 "src/parser.y" + case 168: /* generic: id type */ +#line 516 "src/parser.y" { (yyval.node) = gen_alias((yyvsp[-1].node), (yyvsp[0].node)); } -#line 3719 "gen/gen_parser.c" +#line 3724 "gen/gen_parser.c" break; - case 168: /* generic_list: generic "," generic_list */ -#line 514 "src/parser.y" + case 169: /* generic_list: generic "," generic_list */ +#line 517 "src/parser.y" { (yyval.node) = (yyvsp[-2].node); (yyval.node)->next = (yyvsp[0].node); } -#line 3725 "gen/gen_parser.c" +#line 3730 "gen/gen_parser.c" break; - case 169: /* generic_list: generic */ -#line 515 "src/parser.y" + case 170: /* generic_list: generic */ +#line 518 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3731 "gen/gen_parser.c" +#line 3736 "gen/gen_parser.c" break; - case 170: /* struct: "struct" id "{" struct_list "}" */ -#line 518 "src/parser.y" + case 171: /* struct: "struct" id "{" struct_list "}" */ +#line 521 "src/parser.y" { (yyval.node) = gen_struct((yyvsp[-3].node), NULL, (yyvsp[-1].node)); } -#line 3739 "gen/gen_parser.c" +#line 3744 "gen/gen_parser.c" break; - case 171: /* struct: "struct" id "(" generic_list ")" "{" struct_list "}" */ -#line 521 "src/parser.y" + case 172: /* struct: "struct" id "(" generic_list ")" "{" struct_list "}" */ +#line 524 "src/parser.y" { (yyval.node) = gen_struct((yyvsp[-6].node), (yyvsp[-4].node), (yyvsp[-1].node)); } -#line 3747 "gen/gen_parser.c" +#line 3752 "gen/gen_parser.c" break; - case 172: /* template_elem: id ";" */ -#line 528 "src/parser.y" + case 173: /* template_elem: id ";" */ +#line 531 "src/parser.y" { (yyval.node) = (yyvsp[-1].node); } -#line 3753 "gen/gen_parser.c" +#line 3758 "gen/gen_parser.c" break; - case 173: /* template_elem: id func_sign ";" */ -#line 529 "src/parser.y" + case 174: /* template_elem: id func_sign ";" */ +#line 532 "src/parser.y" { (yyval.node) = gen_proc((yyvsp[-2].node), (yyvsp[-1].node), NULL); } -#line 3759 "gen/gen_parser.c" +#line 3764 "gen/gen_parser.c" break; - case 174: /* template_elem: var_decl ";" */ -#line 530 "src/parser.y" + case 175: /* template_elem: var_decl ";" */ +#line 533 "src/parser.y" { (yyval.node) = (yyvsp[-1].node); } -#line 3765 "gen/gen_parser.c" +#line 3770 "gen/gen_parser.c" break; - case 175: /* template_elem: union */ -#line 531 "src/parser.y" + case 176: /* template_elem: union */ +#line 534 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3771 "gen/gen_parser.c" +#line 3776 "gen/gen_parser.c" break; - case 176: /* template_list: template_elem template_list */ -#line 534 "src/parser.y" + case 177: /* template_list: template_elem template_list */ +#line 537 "src/parser.y" { (yyval.node) = (yyvsp[-1].node); (yyvsp[-1].node)->next = (yyvsp[0].node); } -#line 3777 "gen/gen_parser.c" +#line 3782 "gen/gen_parser.c" break; - case 177: /* template_list: template_elem */ -#line 535 "src/parser.y" + case 178: /* template_list: template_elem */ +#line 538 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3783 "gen/gen_parser.c" +#line 3788 "gen/gen_parser.c" break; - case 178: /* type_list: type "," type_list */ -#line 538 "src/parser.y" + case 179: /* type_list: type "," type_list */ +#line 541 "src/parser.y" { (yyval.node) = (yyvsp[-2].node); (yyvsp[-2].node)->next = (yyvsp[0].node); } -#line 3789 "gen/gen_parser.c" +#line 3794 "gen/gen_parser.c" break; - case 179: /* type_list: type */ -#line 539 "src/parser.y" + case 180: /* type_list: type */ +#line 542 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3795 "gen/gen_parser.c" +#line 3800 "gen/gen_parser.c" break; - case 180: /* type_alias: "type" id type */ -#line 542 "src/parser.y" + case 181: /* type_alias: "type" id type */ +#line 545 "src/parser.y" { (yyval.node) = gen_alias((yyvsp[-1].node), (yyvsp[0].node)); } -#line 3801 "gen/gen_parser.c" +#line 3806 "gen/gen_parser.c" break; - case 181: /* type_template: "type" id "{" template_list "}" */ -#line 547 "src/parser.y" + case 182: /* type_template: "type" id "{" template_list "}" */ +#line 550 "src/parser.y" { (yyval.node) = gen_template((yyvsp[-3].node), (yyvsp[-1].node)); } -#line 3809 "gen/gen_parser.c" +#line 3814 "gen/gen_parser.c" break; - case 182: /* type_template: "type" id "{" "}" */ -#line 550 "src/parser.y" + case 183: /* type_template: "type" id "{" "}" */ +#line 553 "src/parser.y" { /* should match anything, but doesn't implement anything */ (yyval.node) = gen_template((yyvsp[-2].node), NULL); } -#line 3818 "gen/gen_parser.c" +#line 3823 "gen/gen_parser.c" break; - case 183: /* enum_val: id */ -#line 556 "src/parser.y" - { (yyval.node) = gen_val((yyvsp[0].node), gen_int(0)); } -#line 3824 "gen/gen_parser.c" + case 184: /* enum_val: id */ +#line 559 "src/parser.y" + { (yyval.node) = gen_val((yyvsp[0].node), NULL); } +#line 3829 "gen/gen_parser.c" break; - case 184: /* enum_val: id "=" expr */ -#line 557 "src/parser.y" + case 185: /* enum_val: id "=" expr */ +#line 560 "src/parser.y" { (yyval.node) = gen_val((yyvsp[-2].node), (yyvsp[0].node)); } -#line 3830 "gen/gen_parser.c" +#line 3835 "gen/gen_parser.c" break; - case 185: /* enum_list: enum_val "," enum_list */ -#line 560 "src/parser.y" + case 186: /* enum_list: enum_val "," enum_list */ +#line 563 "src/parser.y" { (yyval.node) = (yyvsp[-2].node); (yyvsp[-2].node)->next = (yyvsp[0].node); } -#line 3836 "gen/gen_parser.c" +#line 3841 "gen/gen_parser.c" break; - case 186: /* enum_list: enum_val "," */ -#line 561 "src/parser.y" + case 187: /* enum_list: enum_val "," */ +#line 564 "src/parser.y" { (yyval.node) = (yyvsp[-1].node); } -#line 3842 "gen/gen_parser.c" +#line 3847 "gen/gen_parser.c" break; - case 187: /* enum_list: enum_val */ -#line 562 "src/parser.y" + case 188: /* enum_list: enum_val */ +#line 565 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3848 "gen/gen_parser.c" +#line 3853 "gen/gen_parser.c" break; - case 188: /* enum: "enum" id ":" type "{" enum_list "}" */ -#line 565 "src/parser.y" + case 189: /* enum: "enum" id ":" type "{" enum_list "}" */ +#line 568 "src/parser.y" { (yyval.node) = gen_enum((yyvsp[-5].node), (yyvsp[-3].node), (yyvsp[-1].node)); } -#line 3854 "gen/gen_parser.c" +#line 3859 "gen/gen_parser.c" break; - case 189: /* enum: "enum" id "{" enum_list "}" */ -#line 566 "src/parser.y" + case 190: /* enum: "enum" id "{" enum_list "}" */ +#line 569 "src/parser.y" { (yyval.node) = gen_enum((yyvsp[-3].node), NULL, (yyvsp[-1].node)); ast_set_flags((yyval.node), AST_FLAG_UNTYPED); } -#line 3863 "gen/gen_parser.c" +#line 3868 "gen/gen_parser.c" break; - case 190: /* top_if: "if" expr "{" unit "}" */ -#line 572 "src/parser.y" + case 191: /* top_if: "if" expr "{" unit "}" */ +#line 575 "src/parser.y" { (yyval.node) = gen_if((yyvsp[-3].node), (yyvsp[-1].node), NULL); ast_set_flags((yyval.node), AST_FLAG_UNHYGIENIC); } -#line 3872 "gen/gen_parser.c" +#line 3877 "gen/gen_parser.c" break; - case 191: /* top_if: "if" expr "{" unit "}" "else" "{" unit "}" */ -#line 576 "src/parser.y" + case 192: /* top_if: "if" expr "{" unit "}" "else" "{" unit "}" */ +#line 579 "src/parser.y" { (yyval.node) = gen_if((yyvsp[-7].node), (yyvsp[-5].node), (yyvsp[-1].node)); ast_set_flags((yyval.node), AST_FLAG_UNHYGIENIC); } -#line 3881 "gen/gen_parser.c" +#line 3886 "gen/gen_parser.c" break; - case 192: /* top_if: "if" expr "{" unit "}" "else" top_if */ -#line 580 "src/parser.y" + case 193: /* top_if: "if" expr "{" unit "}" "else" top_if */ +#line 583 "src/parser.y" { (yyval.node) = gen_if((yyvsp[-5].node), (yyvsp[-3].node), (yyvsp[0].node)); ast_set_flags((yyval.node), AST_FLAG_UNHYGIENIC); } -#line 3890 "gen/gen_parser.c" +#line 3895 "gen/gen_parser.c" break; - case 193: /* top: ";" */ -#line 588 "src/parser.y" + case 194: /* top: ";" */ +#line 591 "src/parser.y" { (yyval.node) = gen_empty(); } -#line 3896 "gen/gen_parser.c" +#line 3901 "gen/gen_parser.c" break; - case 194: /* top: enum */ -#line 589 "src/parser.y" + case 195: /* top: enum */ +#line 592 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3902 "gen/gen_parser.c" +#line 3907 "gen/gen_parser.c" break; - case 195: /* top: proc */ -#line 590 "src/parser.y" + case 196: /* top: proc */ +#line 593 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3908 "gen/gen_parser.c" +#line 3913 "gen/gen_parser.c" break; - case 196: /* top: struct */ -#line 591 "src/parser.y" + case 197: /* top: struct */ +#line 594 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3914 "gen/gen_parser.c" +#line 3919 "gen/gen_parser.c" break; - case 197: /* top: macro */ -#line 592 "src/parser.y" + case 198: /* top: macro */ +#line 595 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3920 "gen/gen_parser.c" +#line 3925 "gen/gen_parser.c" break; - case 198: /* top: "const" top_if */ -#line 593 "src/parser.y" + case 199: /* top: "const" top_if */ +#line 596 "src/parser.y" { (yyval.node) = (yyvsp[0].node); ast_set_flags((yyval.node), AST_FLAG_CONST); } -#line 3926 "gen/gen_parser.c" +#line 3931 "gen/gen_parser.c" break; - case 199: /* top: import ";" */ -#line 594 "src/parser.y" + case 200: /* top: import ";" */ +#line 597 "src/parser.y" { (yyval.node) = (yyvsp[-1].node); } -#line 3932 "gen/gen_parser.c" +#line 3937 "gen/gen_parser.c" break; - case 200: /* top: type_alias ";" */ -#line 595 "src/parser.y" + case 201: /* top: type_alias ";" */ +#line 598 "src/parser.y" { (yyval.node) = (yyvsp[-1].node); } -#line 3938 "gen/gen_parser.c" +#line 3943 "gen/gen_parser.c" break; - case 201: /* top: type_template */ -#line 596 "src/parser.y" + case 202: /* top: type_template */ +#line 599 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3944 "gen/gen_parser.c" +#line 3949 "gen/gen_parser.c" break; - case 202: /* top: "pub" enum */ -#line 597 "src/parser.y" + case 203: /* top: "pub" enum */ +#line 600 "src/parser.y" { (yyval.node) = (yyvsp[0].node); ast_set_flags((yyvsp[0].node), AST_FLAG_PUBLIC); } -#line 3950 "gen/gen_parser.c" +#line 3955 "gen/gen_parser.c" break; - case 203: /* top: "pub" struct */ -#line 598 "src/parser.y" + case 204: /* top: "pub" struct */ +#line 601 "src/parser.y" { (yyval.node) = (yyvsp[0].node); ast_set_flags((yyvsp[0].node), AST_FLAG_PUBLIC); } -#line 3956 "gen/gen_parser.c" +#line 3961 "gen/gen_parser.c" break; - case 204: /* top: "pub" proc */ -#line 599 "src/parser.y" + case 205: /* top: "pub" proc */ +#line 602 "src/parser.y" { (yyval.node) = (yyvsp[0].node); ast_set_flags((yyvsp[0].node), AST_FLAG_PUBLIC); } -#line 3962 "gen/gen_parser.c" +#line 3967 "gen/gen_parser.c" break; - case 205: /* top: "pub" macro */ -#line 600 "src/parser.y" + case 206: /* top: "pub" macro */ +#line 603 "src/parser.y" { (yyval.node) = (yyvsp[0].node); ast_set_flags((yyvsp[0].node), AST_FLAG_PUBLIC); } -#line 3968 "gen/gen_parser.c" +#line 3973 "gen/gen_parser.c" break; - case 206: /* top: "pub" import ";" */ -#line 601 "src/parser.y" + case 207: /* top: "pub" import ";" */ +#line 604 "src/parser.y" { (yyval.node) = (yyvsp[-1].node); ast_set_flags((yyvsp[-1].node), AST_FLAG_PUBLIC); } -#line 3974 "gen/gen_parser.c" +#line 3979 "gen/gen_parser.c" break; - case 207: /* top: "pub" type_alias ";" */ -#line 602 "src/parser.y" + case 208: /* top: "pub" type_alias ";" */ +#line 605 "src/parser.y" { (yyval.node) = (yyvsp[-1].node); ast_set_flags((yyvsp[-1].node), AST_FLAG_PUBLIC); } -#line 3980 "gen/gen_parser.c" +#line 3985 "gen/gen_parser.c" break; - case 208: /* top: "pub" type_template */ -#line 603 "src/parser.y" + case 209: /* top: "pub" type_template */ +#line 606 "src/parser.y" { (yyval.node) = (yyvsp[0].node); ast_set_flags((yyvsp[0].node), AST_FLAG_PUBLIC); } -#line 3986 "gen/gen_parser.c" +#line 3991 "gen/gen_parser.c" break; - case 209: /* top: var ";" */ -#line 604 "src/parser.y" + case 210: /* top: var ";" */ +#line 607 "src/parser.y" { (yyval.node) = (yyvsp[-1].node); } -#line 3992 "gen/gen_parser.c" +#line 3997 "gen/gen_parser.c" break; - case 210: /* top: "pub" var ";" */ -#line 605 "src/parser.y" + case 211: /* top: "pub" var ";" */ +#line 608 "src/parser.y" { (yyval.node) = (yyvsp[-1].node); ast_set_flags((yyvsp[-1].node), AST_FLAG_PUBLIC); } -#line 3998 "gen/gen_parser.c" +#line 4003 "gen/gen_parser.c" break; - case 211: /* top: error */ -#line 606 "src/parser.y" + case 212: /* top: error */ +#line 609 "src/parser.y" { (yyval.node) = gen_empty(); parser->failed = true; @@ -4014,29 +4017,29 @@ yyreduce: yyclearin; yyerrok; } -#line 4016 "gen/gen_parser.c" +#line 4021 "gen/gen_parser.c" break; - case 212: /* unit: top */ -#line 621 "src/parser.y" + case 213: /* unit: top */ +#line 624 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 4022 "gen/gen_parser.c" +#line 4027 "gen/gen_parser.c" break; - case 213: /* unit: top unit */ -#line 622 "src/parser.y" + case 214: /* unit: top unit */ +#line 625 "src/parser.y" { (yyval.node) = (yyvsp[-1].node); (yyvsp[-1].node)->next = (yyvsp[0].node); } -#line 4028 "gen/gen_parser.c" +#line 4033 "gen/gen_parser.c" break; - case 214: /* input: unit */ -#line 625 "src/parser.y" + case 215: /* input: unit */ +#line 628 "src/parser.y" { parser->tree = (yyvsp[0].node); } -#line 4034 "gen/gen_parser.c" +#line 4039 "gen/gen_parser.c" break; -#line 4038 "gen/gen_parser.c" +#line 4043 "gen/gen_parser.c" default: break; } @@ -4265,5 +4268,5 @@ yyreturnlab: return yyresult; } -#line 628 "src/parser.y" +#line 631 "src/parser.y" diff --git a/gen/gen_parser.c.uncrustify b/gen/gen_parser.c.uncrustify deleted file mode 100644 index e69de29..0000000 --- a/gen/gen_parser.c.uncrustify +++ /dev/null diff --git a/gen/gen_parser.h b/gen/gen_parser.h index fb8e85b..0753292 100644 --- a/gen/gen_parser.h +++ b/gen/gen_parser.h @@ -1,5 +1,3 @@ -/* SPDX-License-Identifier: GPL-3.0-or-later */ - /* A Bison parser, made by GNU Bison 3.8.2. */ /* Bison interface for Yacc-like parsers in C @@ -133,7 +131,8 @@ extern int yydebug; RBRACKET = 332, /* "]" */ AS = 333, /* "as" */ DOT = 334, /* "." */ - FATARROW = 335 /* "=>" */ + SCOPE = 335, /* "::" */ + FATARROW = 336 /* "=>" */ }; typedef enum yytokentype yytoken_kind_t; #endif @@ -149,7 +148,7 @@ union YYSTYPE double dbl; char *str; -#line 151 "gen/gen_parser.h" +#line 152 "gen/gen_parser.h" }; typedef union YYSTYPE YYSTYPE; |