/* A Bison parser, made from parser.yy by GNU bison 1.35. */ #define YYBISON 1 /* Identify Bison output. */ # define ABSTRACT 257 # define BOOLEAN 258 # define BREAK 259 # define BROADCAST 260 # define BYTE 261 # define CASE 262 # define CATCH 263 # define CHAR 264 # define CLASS 265 # define CONTINUE 266 # define DEFAULT 267 # define DO 268 # define DOUBLE 269 # define _DOMAIN 270 # define ELSE 271 # define EXTENDS 272 # define FINAL 273 # define FINALLY 274 # define FLOAT 275 # define FOR 276 # define FROM 277 # define FOREACH 278 # define IF 279 # define IMPLEMENTS 280 # define IMPORT 281 # define INSTANCEOF 282 # define INT 283 # define INTERFACE 284 # define IMMUTABLE 285 # define IN 286 # define INLINE 287 # define LOCAL 288 # define LONG 289 # define NATIVE 290 # define NEW 291 # define NULL_VAL 292 # define OPERATOR 293 # define OVERLAP 294 # define _PACKAGE 295 # define PRIVATE 296 # define PROTECTED 297 # define PUBLIC 298 # define POLYSHARED 299 # define NONSHARED 300 # define PARTITION 301 # define POINT 302 # define RECTDOMAIN 303 # define RETURN 304 # define SHORT 305 # define STATIC 306 # define SUPER 307 # define SWITCH 308 # define SYNCHRONIZED 309 # define SINGLE 310 # define SGLOBAL 311 # define TEMPLATE 312 # define THIS 313 # define THROW 314 # define THROWS 315 # define TRANSIENT 316 # define TRY 317 # define VOID 318 # define VOLATILE 319 # define WHILE 320 # define TRUE_LITERAL 321 # define FALSE_LITERAL 322 # define IDENTIFIER 323 # define INT_LITERAL 324 # define LONG_LITERAL 325 # define FLOAT_LITERAL 326 # define DOUBLE_LITERAL 327 # define CHARACTER_LITERAL 328 # define STRING_LITERAL 329 # define CAND 330 # define COR 331 # define EQ 332 # define NE 333 # define LE 334 # define GE 335 # define LSHIFTL 336 # define ASHIFTR 337 # define LSHIFTR 338 # define PLUS_ASG 339 # define MINUS_ASG 340 # define MULT_ASG 341 # define DIV_ASG 342 # define REM_ASG 343 # define LSHIFTL_ASG 344 # define ASHIFTR_ASG 345 # define LSHIFTR_ASG 346 # define AND_ASG 347 # define XOR_ASG 348 # define OR_ASG 349 # define PLUSPLUS 350 # define MINUSMINUS 351 # define GUARDS 352 #line 135 "parser.yy" #include #include #include "AST.h" #include "config.h" #include "errors.h" #include "parse.h" #include "tokens.h" #define YYDEBUG 1 #ifdef HAVE_ALLOCA # define YYSTACK_USE_ALLOCA 1 # if HAVE_ALLOCA_H # include # endif // HAVE_ALLOCA_H #if defined(__GNUC__) #ifndef alloca #define alloca __builtin_alloca #endif #else extern "C" char *alloca(size_t size); #endif #endif // HAVE_ALLOCA static void yyerror(const char* msg); static TreeNode *newOperator(char *op, SourcePosn p); /* Routines to check the validity of modifier flags. Each routine */ /* takes a logical `or' of flag values and a source position to which */ /* to refer error messages. */ static void checkFieldModifiers (Common::Modifiers flags, SourcePosn posn); static void checkConstantFieldModifiers (Common::Modifiers flags, SourcePosn posn); static void checkMethodModifiers (Common::Modifiers flags, SourcePosn posn); static void checkConstructorModifiers (Common::Modifiers flags, SourcePosn posn); static void checkMethodSignatureModifiers (Common::Modifiers flags, SourcePosn posn); static void checkInterfaceModifiers(Common::Modifiers flags, SourcePosn posn); static TreeNode *addSynchronized(Common::Modifiers modifiers, TreeNode *body); #line 182 "parser.yy" #ifndef YYSTYPE typedef union { SimpTerminalInfo SimpTerminal; /* Terminal symbols with only position. */ TerminalInfo Terminal; /* Terminal symbols with ASCII string data. */ StrTerminalInfo StrTerminal; /* Terminal symbols with Unicode string data. */ CharTerminalInfo CharTerminal; /* Terminal symbols with Unicode char data. */ long Int; /* Simple integer values */ bool Bool; CompileUnitNode* CompileUnit; TreeNode* Tree; TypeNode* Type; CatchNode* Catch; llist* TreeList; llist* TypeList; llist* CatchList; Common::Modifiers Modifiers; llist* DeclaratorList; TryNode *Try; TypeDeclNode *TypeDecl; } yystype; # define YYSTYPE yystype # define YYSTYPE_IS_TRIVIAL 1 #endif #ifndef YYDEBUG # define YYDEBUG 0 #endif #define YYFINAL 703 #define YYFLAG -32768 #define YYNTBASE 123 /* YYTRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */ #define YYTRANSLATE(x) ((unsigned)(x) <= 352 ? yytranslate[x] : 281) /* YYTRANSLATE[YYLEX] -- Bison token number corresponding to YYLEX. */ static const char yytranslate[] = { 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 88, 2, 2, 2, 99, 96, 2, 76, 77, 94, 92, 82, 93, 83, 95, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 91, 84, 87, 85, 86, 90, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 80, 2, 81, 98, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 78, 97, 79, 89, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 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, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122 }; #if YYDEBUG static const short yyprhs[] = { 0, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 27, 31, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 55, 59, 64, 70, 71, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 103, 108, 113, 117, 121, 122, 123, 126, 127, 130, 133, 135, 137, 139, 141, 143, 145, 149, 155, 162, 164, 165, 167, 170, 172, 174, 176, 178, 181, 182, 185, 186, 190, 192, 193, 195, 198, 200, 202, 204, 206, 211, 213, 214, 216, 219, 221, 223, 225, 227, 229, 231, 233, 235, 237, 239, 241, 243, 245, 247, 249, 251, 253, 257, 260, 265, 267, 269, 280, 291, 293, 295, 297, 298, 301, 308, 310, 311, 313, 317, 322, 324, 325, 327, 328, 331, 333, 337, 339, 341, 352, 362, 364, 366, 372, 378, 381, 387, 389, 390, 393, 397, 398, 401, 403, 405, 410, 420, 430, 436, 438, 442, 445, 448, 454, 456, 460, 462, 464, 466, 470, 475, 478, 480, 484, 486, 488, 492, 494, 495, 497, 500, 502, 504, 509, 513, 515, 517, 519, 521, 523, 525, 527, 529, 531, 533, 537, 540, 542, 544, 546, 548, 550, 552, 554, 560, 568, 574, 578, 579, 583, 585, 588, 592, 595, 601, 609, 618, 620, 623, 625, 627, 628, 630, 631, 633, 637, 644, 646, 647, 651, 657, 659, 661, 665, 669, 673, 677, 679, 680, 686, 689, 692, 696, 699, 701, 704, 710, 713, 718, 724, 725, 730, 732, 734, 736, 738, 740, 742, 744, 748, 752, 754, 756, 758, 761, 763, 767, 769, 771, 773, 777, 781, 784, 787, 790, 793, 796, 799, 802, 805, 808, 811, 814, 817, 820, 823, 826, 829, 832, 835, 838, 841, 844, 847, 850, 853, 856, 859, 862, 865, 868, 871, 875, 880, 885, 887, 891, 895, 899, 903, 905, 910, 915, 917, 918, 920, 924, 931, 936, 940, 941, 943, 946, 948, 951, 953, 954, 957, 961, 965, 970, 972, 974, 976, 978, 980, 982, 985, 988, 990, 992, 994, 996, 998, 1000, 1003, 1006, 1008, 1010, 1013, 1016, 1018, 1020, 1022, 1024, 1027, 1030, 1032, 1037, 1042, 1046, 1050, 1054, 1056, 1060, 1064, 1066, 1070, 1076, 1078, 1079, 1081, 1083, 1087, 1091, 1095, 1099, 1103, 1107, 1111, 1115, 1119, 1123, 1127, 1131, 1137, 1139, 1141, 1143, 1145, 1147, 1151, 1155, 1159, 1163, 1167, 1171, 1175, 1179, 1183, 1187, 1191, 1195, 1199, 1203, 1207, 1211, 1215, 1219, 1223, 1227, 1229, 1234, 1238, 1242, 1246, 1249, 1252, 1255 }; static const short yyrhs[] = { 138, 0, 70, 0, 71, 0, 72, 0, 73, 0, 67, 0, 68, 0, 74, 0, 75, 0, 235, 0, 127, 0, 127, 0, 131, 134, 0, 131, 134, 132, 0, 129, 134, 0, 136, 0, 130, 0, 137, 0, 193, 0, 237, 0, 136, 0, 137, 0, 193, 0, 133, 0, 133, 132, 0, 80, 81, 134, 0, 80, 242, 81, 134, 0, 80, 274, 69, 81, 134, 0, 0, 134, 135, 0, 56, 0, 34, 0, 46, 0, 45, 0, 4, 0, 10, 0, 7, 0, 51, 0, 29, 0, 21, 0, 35, 0, 15, 0, 48, 87, 275, 86, 0, 49, 87, 275, 86, 0, 16, 87, 275, 86, 0, 139, 140, 141, 0, 41, 237, 84, 0, 0, 0, 140, 144, 0, 0, 142, 141, 0, 84, 141, 0, 143, 0, 190, 0, 147, 0, 182, 0, 145, 0, 146, 0, 27, 237, 84, 0, 27, 237, 83, 94, 84, 0, 148, 11, 238, 151, 152, 153, 0, 149, 0, 0, 150, 0, 149, 150, 0, 3, 0, 19, 0, 44, 0, 31, 0, 18, 125, 0, 0, 26, 175, 0, 0, 78, 154, 79, 0, 155, 0, 0, 156, 0, 155, 156, 0, 157, 0, 164, 0, 177, 0, 181, 0, 158, 125, 161, 84, 0, 159, 0, 0, 160, 0, 159, 160, 0, 44, 0, 43, 0, 42, 0, 52, 0, 19, 0, 56, 0, 57, 0, 3, 0, 36, 0, 55, 0, 62, 0, 65, 0, 34, 0, 46, 0, 45, 0, 33, 0, 162, 0, 161, 82, 162, 0, 238, 251, 0, 238, 251, 85, 163, 0, 274, 0, 196, 0, 158, 125, 165, 76, 169, 77, 251, 173, 167, 176, 0, 158, 166, 165, 76, 169, 77, 251, 173, 167, 176, 0, 238, 0, 240, 0, 64, 0, 0, 168, 167, 0, 40, 76, 238, 82, 238, 77, 0, 170, 0, 0, 171, 0, 171, 82, 170, 0, 172, 125, 238, 251, 0, 19, 0, 0, 174, 0, 0, 61, 175, 0, 125, 0, 125, 82, 175, 0, 199, 0, 84, 0, 158, 238, 76, 169, 77, 173, 78, 178, 200, 79, 0, 158, 238, 76, 169, 77, 173, 78, 200, 79, 0, 179, 0, 180, 0, 59, 76, 245, 77, 84, 0, 53, 76, 245, 77, 84, 0, 52, 199, 0, 148, 30, 238, 183, 185, 0, 184, 0, 0, 18, 175, 0, 78, 186, 79, 0, 0, 187, 186, 0, 188, 0, 189, 0, 158, 125, 161, 84, 0, 158, 125, 165, 76, 169, 77, 251, 173, 84, 0, 158, 166, 165, 76, 169, 77, 251, 173, 84, 0, 58, 87, 191, 86, 143, 0, 192, 0, 192, 82, 191, 0, 11, 238, 0, 125, 238, 0, 58, 130, 87, 194, 86, 0, 195, 0, 195, 82, 194, 0, 126, 0, 276, 0, 235, 0, 78, 197, 79, 0, 78, 197, 82, 79, 0, 78, 79, 0, 198, 0, 197, 82, 198, 0, 274, 0, 196, 0, 78, 200, 79, 0, 201, 0, 0, 202, 0, 201, 202, 0, 203, 0, 204, 0, 19, 125, 161, 84, 0, 125, 161, 84, 0, 205, 0, 206, 0, 207, 0, 209, 0, 214, 0, 223, 0, 225, 0, 199, 0, 230, 0, 84, 0, 238, 91, 204, 0, 208, 84, 0, 278, 0, 261, 0, 262, 0, 256, 0, 257, 0, 244, 0, 247, 0, 25, 76, 274, 77, 204, 0, 25, 76, 274, 77, 204, 17, 204, 0, 54, 76, 274, 77, 210, 0, 78, 211, 79, 0, 0, 212, 201, 211, 0, 213, 0, 213, 212, 0, 8, 279, 91, 0, 13, 91, 0, 66, 76, 274, 77, 204, 0, 14, 204, 66, 76, 274, 77, 84, 0, 22, 76, 215, 273, 84, 216, 77, 204, 0, 219, 0, 217, 84, 0, 203, 0, 218, 0, 0, 218, 0, 0, 208, 0, 208, 82, 218, 0, 24, 76, 221, 77, 220, 204, 0, 33, 0, 0, 238, 222, 274, 0, 238, 222, 274, 82, 221, 0, 32, 0, 69, 0, 5, 224, 84, 0, 12, 224, 84, 0, 50, 273, 84, 0, 60, 274, 84, 0, 238, 0, 0, 55, 76, 274, 77, 204, 0, 226, 229, 0, 226, 227, 0, 226, 227, 229, 0, 63, 199, 0, 228, 0, 228, 227, 0, 9, 76, 171, 77, 199, 0, 20, 199, 0, 47, 78, 231, 79, 0, 47, 238, 78, 231, 79, 0, 0, 274, 122, 204, 231, 0, 235, 0, 233, 0, 247, 0, 234, 0, 124, 0, 38, 0, 59, 0, 76, 274, 77, 0, 76, 235, 77, 0, 241, 0, 243, 0, 244, 0, 237, 134, 0, 236, 0, 237, 134, 132, 0, 238, 0, 239, 0, 69, 0, 237, 83, 69, 0, 237, 83, 240, 0, 39, 88, 0, 39, 89, 0, 39, 87, 0, 39, 86, 0, 39, 104, 0, 39, 105, 0, 39, 102, 0, 39, 103, 0, 39, 92, 0, 39, 93, 0, 39, 94, 0, 39, 95, 0, 39, 96, 0, 39, 97, 0, 39, 98, 0, 39, 99, 0, 39, 106, 0, 39, 107, 0, 39, 108, 0, 39, 109, 0, 39, 110, 0, 39, 111, 0, 39, 112, 0, 39, 113, 0, 39, 114, 0, 39, 115, 0, 39, 116, 0, 39, 117, 0, 39, 118, 0, 39, 119, 0, 39, 80, 81, 0, 39, 80, 81, 85, 0, 234, 80, 242, 81, 0, 246, 0, 233, 83, 165, 0, 53, 83, 165, 0, 131, 83, 165, 0, 236, 83, 165, 0, 240, 0, 243, 76, 245, 77, 0, 235, 76, 245, 77, 0, 246, 0, 0, 274, 0, 274, 82, 246, 0, 37, 248, 128, 76, 245, 77, 0, 37, 248, 128, 249, 0, 76, 274, 77, 0, 0, 250, 0, 250, 249, 0, 133, 0, 268, 134, 0, 252, 0, 0, 80, 81, 0, 80, 81, 34, 0, 252, 80, 81, 0, 252, 80, 81, 34, 0, 232, 0, 255, 0, 233, 0, 255, 0, 256, 0, 257, 0, 253, 120, 0, 253, 121, 0, 263, 0, 260, 0, 264, 0, 260, 0, 261, 0, 262, 0, 92, 258, 0, 93, 258, 0, 267, 0, 268, 0, 120, 258, 0, 121, 258, 0, 253, 0, 265, 0, 254, 0, 265, 0, 89, 258, 0, 88, 258, 0, 266, 0, 76, 125, 77, 258, 0, 76, 235, 77, 263, 0, 80, 246, 81, 0, 80, 269, 81, 0, 80, 271, 81, 0, 270, 0, 270, 82, 269, 0, 274, 91, 274, 0, 272, 0, 272, 82, 271, 0, 274, 91, 274, 91, 274, 0, 274, 0, 0, 275, 0, 280, 0, 274, 87, 274, 0, 274, 86, 274, 0, 274, 104, 274, 0, 274, 105, 274, 0, 274, 28, 125, 0, 274, 102, 274, 0, 274, 103, 274, 0, 274, 96, 274, 0, 274, 97, 274, 0, 274, 98, 274, 0, 274, 100, 274, 0, 274, 101, 274, 0, 274, 90, 274, 91, 274, 0, 278, 0, 258, 0, 277, 0, 259, 0, 277, 0, 275, 94, 275, 0, 275, 95, 275, 0, 275, 99, 275, 0, 275, 92, 275, 0, 275, 93, 275, 0, 275, 106, 275, 0, 275, 108, 275, 0, 275, 107, 275, 0, 258, 85, 274, 0, 258, 111, 274, 0, 258, 112, 274, 0, 258, 113, 274, 0, 258, 109, 274, 0, 258, 110, 274, 0, 258, 114, 274, 0, 258, 116, 274, 0, 258, 115, 274, 0, 258, 117, 274, 0, 258, 118, 274, 0, 258, 119, 274, 0, 274, 0, 6, 274, 23, 274, 0, 27, 1, 84, 0, 41, 1, 84, 0, 78, 1, 79, 0, 1, 84, 0, 1, 199, 0, 1, 84, 0, 1, 153, 0 }; #endif #if YYDEBUG /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ static const short yyrline[] = { 0, 308, 314, 317, 319, 321, 323, 325, 327, 329, 336, 338, 341, 345, 347, 352, 356, 358, 359, 360, 363, 368, 370, 371, 374, 376, 379, 381, 383, 395, 397, 405, 407, 408, 409, 412, 415, 417, 419, 421, 423, 425, 427, 433, 436, 438, 447, 452, 455, 459, 462, 467, 470, 477, 481, 484, 488, 491, 498, 500, 503, 512, 524, 532, 534, 538, 540, 548, 551, 553, 555, 562, 565, 572, 575, 583, 588, 590, 594, 596, 603, 605, 607, 609, 616, 639, 641, 645, 647, 654, 658, 660, 663, 665, 667, 669, 672, 674, 676, 679, 681, 683, 685, 687, 689, 697, 699, 703, 706, 713, 715, 720, 727, 736, 738, 741, 746, 748, 751, 761, 763, 767, 770, 774, 779, 781, 787, 789, 793, 798, 801, 808, 810, 817, 824, 838, 840, 843, 848, 856, 864, 874, 876, 880, 887, 892, 895, 899, 901, 905, 921, 928, 939, 944, 947, 951, 954, 958, 963, 966, 970, 973, 975, 983, 986, 988, 994, 997, 1001, 1003, 1011, 1016, 1018, 1022, 1025, 1029, 1032, 1040, 1043, 1049, 1051, 1052, 1053, 1054, 1055, 1056, 1057, 1058, 1063, 1071, 1079, 1084, 1087, 1089, 1091, 1093, 1095, 1097, 1104, 1107, 1109, 1113, 1118, 1120, 1124, 1127, 1131, 1134, 1141, 1144, 1146, 1148, 1151, 1154, 1158, 1160, 1164, 1166, 1170, 1173, 1179, 1184, 1186, 1189, 1192, 1196, 1198, 1206, 1209, 1211, 1213, 1218, 1220, 1227, 1230, 1233, 1235, 1239, 1244, 1247, 1251, 1256, 1263, 1266, 1270, 1272, 1283, 1286, 1289, 1291, 1294, 1296, 1298, 1300, 1302, 1304, 1305, 1307, 1314, 1316, 1319, 1323, 1325, 1328, 1334, 1337, 1341, 1343, 1344, 1345, 1346, 1347, 1348, 1349, 1350, 1351, 1352, 1353, 1354, 1355, 1356, 1357, 1358, 1359, 1360, 1361, 1362, 1363, 1364, 1365, 1366, 1367, 1368, 1369, 1370, 1371, 1372, 1373, 1378, 1383, 1390, 1394, 1396, 1398, 1400, 1407, 1410, 1414, 1416, 1420, 1423, 1430, 1433, 1437, 1440, 1444, 1447, 1451, 1454, 1458, 1460, 1464, 1467, 1469, 1471, 1478, 1480, 1483, 1485, 1488, 1490, 1493, 1498, 1506, 1508, 1511, 1513, 1516, 1518, 1519, 1521, 1523, 1524, 1527, 1532, 1537, 1539, 1542, 1544, 1547, 1550, 1552, 1555, 1558, 1568, 1572, 1574, 1577, 1579, 1582, 1588, 1590, 1593, 1601, 1603, 1607, 1609, 1610, 1612, 1614, 1616, 1618, 1620, 1622, 1624, 1626, 1628, 1630, 1632, 1634, 1636, 1639, 1641, 1644, 1646, 1649, 1652, 1654, 1656, 1658, 1660, 1662, 1664, 1671, 1674, 1676, 1678, 1680, 1682, 1684, 1686, 1688, 1690, 1692, 1694, 1701, 1705, 1714, 1719, 1724, 1729, 1732, 1736, 1741 }; #endif #if (YYDEBUG) || defined YYERROR_VERBOSE /* YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */ static const char *const yytname[] = { "$", "error", "$undefined.", "ABSTRACT", "BOOLEAN", "BREAK", "BROADCAST", "BYTE", "CASE", "CATCH", "CHAR", "CLASS", "CONTINUE", "DEFAULT", "DO", "DOUBLE", "_DOMAIN", "ELSE", "EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "FROM", "FOREACH", "IF", "IMPLEMENTS", "IMPORT", "INSTANCEOF", "INT", "INTERFACE", "IMMUTABLE", "IN", "INLINE", "LOCAL", "LONG", "NATIVE", "NEW", "NULL_VAL", "OPERATOR", "OVERLAP", "_PACKAGE", "PRIVATE", "PROTECTED", "PUBLIC", "POLYSHARED", "NONSHARED", "PARTITION", "POINT", "RECTDOMAIN", "RETURN", "SHORT", "STATIC", "SUPER", "SWITCH", "SYNCHRONIZED", "SINGLE", "SGLOBAL", "TEMPLATE", "THIS", "THROW", "THROWS", "TRANSIENT", "TRY", "VOID", "VOLATILE", "WHILE", "TRUE_LITERAL", "FALSE_LITERAL", "IDENTIFIER", "INT_LITERAL", "LONG_LITERAL", "FLOAT_LITERAL", "DOUBLE_LITERAL", "CHARACTER_LITERAL", "STRING_LITERAL", "'('", "')'", "'{'", "'}'", "'['", "']'", "','", "'.'", "';'", "'='", "'>'", "'<'", "'!'", "'~'", "'?'", "':'", "'+'", "'-'", "'*'", "'/'", "'&'", "'|'", "'^'", "'%'", "CAND", "COR", "EQ", "NE", "LE", "GE", "LSHIFTL", "ASHIFTR", "LSHIFTR", "PLUS_ASG", "MINUS_ASG", "MULT_ASG", "DIV_ASG", "REM_ASG", "LSHIFTL_ASG", "ASHIFTR_ASG", "LSHIFTR_ASG", "AND_ASG", "XOR_ASG", "OR_ASG", "PLUSPLUS", "MINUSMINUS", "GUARDS", "Start", "Literal", "Type", "NoNameType", "OtherType", "QualifiedBaseType", "BaseType", "TypeName", "ComplexBaseType", "ArraySpecifiers", "ArraySpecifier", "QualifiersOpt", "Qualifier", "PrimitiveType", "TitaniumType", "CompilationUnit", "PackageDeclarationOpt", "ImportStatementsOpt", "TypeDeclarationsOpt", "TypeDeclaration", "BasicTypeDeclaration", "ImportStatement", "TypeImportStatement", "TypeImportOnDemandStatement", "ClassDeclaration", "ClassModifiersOpt", "ClassModifiers", "ClassModifier", "SuperOpt", "InterfacesOpt", "ClassBody", "FieldDeclarationsOpt", "FieldDeclarations", "FieldDeclaration", "FieldVariableDeclaration", "FieldModifiersOpt", "FieldModifiers", "FieldModifier", "VariableDeclarators", "VariableDeclarator", "VariableInitializer", "MethodDeclaration", "MethodName", "Void", "OverlapsOpt", "OverlapDecl", "ParameterListOpt", "ParameterList", "Parameter", "OptionalFinal", "ThrowsOpt", "Throws", "TypeNameList", "MethodBody", "ConstructorDeclaration", "ConstructorCallStatement", "ExplicitThisConstructorCallStatement", "ExplicitSuperConstructorCallStatement", "StaticInitializer", "InterfaceDeclaration", "ExtendsInterfacesOpt", "ExtendsInterfaces", "InterfaceBody", "InterfaceMemberDeclarationsOpt", "InterfaceMemberDeclaration", "ConstantFieldDeclaration", "MethodSignatureDeclaration", "TemplateDeclaration", "TemplateFormalList", "TemplateFormal", "TemplateInstance", "TemplateActualList", "TemplateActual", "ArrayInitializer", "ElementInitializers", "Element", "Block", "BlockStatementsOpt", "BlockStatements", "BlockStatement", "LocalVariableDeclarationStatement", "Statement", "EmptyStatement", "LabeledStatement", "ExpressionStatement", "StatementExpression", "SelectionStatement", "SwitchBlock", "SwitchBlockStatementsOpt", "SwitchLabels", "SwitchLabel", "IterationStatement", "ForInit", "ForUpdateOpt", "StatementExpressionsOpt", "StatementExpressions", "ForEachStatement", "OptionalInline", "ForEachClauses", "SpecialIn", "JumpStatement", "LabelOpt", "GuardingStatement", "TryBlock", "Catches", "Catch", "Finally", "PartitionStatement", "PartitionClauses", "PrimaryExpression", "NotJustName", "ComplexPrimary", "ArrayName", "FullArrayName", "Name", "SimpleName", "QualifiedName", "OperatorName", "ArrayAccess", "IndexExpression", "FieldAccess", "MethodCall", "ArgumentListOpt", "ArgumentList", "AllocationExpression", "RegionOpt", "DimExprs", "DimExpr", "DimsOpt", "Dims", "PostfixExpression", "NoNamePostfixExpression", "OtherPostfixExpression", "PostIncrement", "PostDecrement", "UnaryExpression", "NoNameUnaryExpression", "OtherUnaryExpression", "PreIncrement", "PreDecrement", "RestrictedUnaryExpression", "NoNameRestrictedUnaryExpression", "OtherRestrictedPostfixExpression", "CastExpression", "PointLiteral", "DomainLiteral", "DomainPairs", "DomainPair", "DomainTriples", "DomainTriple", "ExpressionOpt", "Expression", "Expression1", "NoNameExpression1", "BinaryExpression1", "Assignment", "ConstantExpression", "BroadcastExpression", 0 }; #endif /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ static const short yyr1[] = { 0, 123, 124, 124, 124, 124, 124, 124, 124, 124, 125, 125, 126, 127, 127, 128, 129, 129, 129, 129, 130, 131, 131, 131, 132, 132, 133, 133, 133, 134, 134, 135, 135, 135, 135, 136, 136, 136, 136, 136, 136, 136, 136, 137, 137, 137, 138, 139, 139, 140, 140, 141, 141, 141, 142, 142, 143, 143, 144, 144, 145, 146, 147, 148, 148, 149, 149, 150, 150, 150, 150, 151, 151, 152, 152, 153, 154, 154, 155, 155, 156, 156, 156, 156, 157, 158, 158, 159, 159, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 161, 161, 162, 162, 163, 163, 164, 164, 165, 165, 166, 167, 167, 168, 169, 169, 170, 170, 171, 172, 172, 173, 173, 174, 175, 175, 176, 176, 177, 177, 178, 178, 179, 180, 181, 182, 183, 183, 184, 185, 186, 186, 187, 187, 188, 189, 189, 190, 191, 191, 192, 192, 193, 194, 194, 195, 195, 195, 196, 196, 196, 197, 197, 198, 198, 199, 200, 200, 201, 201, 202, 202, 203, 203, 204, 204, 204, 204, 204, 204, 204, 204, 204, 205, 206, 207, 208, 208, 208, 208, 208, 208, 208, 209, 209, 209, 210, 211, 211, 212, 212, 213, 213, 214, 214, 214, 214, 215, 215, 216, 216, 217, 217, 218, 218, 219, 220, 220, 221, 221, 222, 222, 223, 223, 223, 223, 224, 224, 225, 225, 225, 225, 226, 227, 227, 228, 229, 230, 230, 231, 231, 232, 232, 233, 233, 234, 234, 234, 234, 234, 234, 234, 234, 235, 235, 236, 237, 237, 238, 239, 239, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 241, 242, 243, 243, 243, 243, 243, 244, 244, 245, 245, 246, 246, 247, 247, 248, 248, 249, 249, 250, 250, 251, 251, 252, 252, 252, 252, 253, 253, 254, 254, 255, 255, 256, 257, 258, 258, 259, 259, 260, 260, 260, 260, 260, 260, 261, 262, 263, 263, 264, 264, 265, 265, 265, 266, 266, 267, 268, 268, 269, 269, 270, 271, 271, 272, 273, 273, 274, 274, 274, 274, 274, 274, 274, 274, 274, 274, 274, 274, 274, 274, 274, 274, 275, 275, 276, 276, 277, 277, 277, 277, 277, 277, 277, 277, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 279, 280, 144, 139, 199, 204, 204, 156, 142 }; /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ static const short yyr2[] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 4, 5, 0, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 4, 4, 3, 3, 0, 0, 2, 0, 2, 2, 1, 1, 1, 1, 1, 1, 3, 5, 6, 1, 0, 1, 2, 1, 1, 1, 1, 2, 0, 2, 0, 3, 1, 0, 1, 2, 1, 1, 1, 1, 4, 1, 0, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 2, 4, 1, 1, 10, 10, 1, 1, 1, 0, 2, 6, 1, 0, 1, 3, 4, 1, 0, 1, 0, 2, 1, 3, 1, 1, 10, 9, 1, 1, 5, 5, 2, 5, 1, 0, 2, 3, 0, 2, 1, 1, 4, 9, 9, 5, 1, 3, 2, 2, 5, 1, 3, 1, 1, 1, 3, 4, 2, 1, 3, 1, 1, 3, 1, 0, 1, 2, 1, 1, 4, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 2, 1, 1, 1, 1, 1, 1, 1, 5, 7, 5, 3, 0, 3, 1, 2, 3, 2, 5, 7, 8, 1, 2, 1, 1, 0, 1, 0, 1, 3, 6, 1, 0, 3, 5, 1, 1, 3, 3, 3, 3, 1, 0, 5, 2, 2, 3, 2, 1, 2, 5, 2, 4, 5, 0, 4, 1, 1, 1, 1, 1, 1, 1, 3, 3, 1, 1, 1, 2, 1, 3, 1, 1, 1, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 4, 4, 1, 3, 3, 3, 3, 1, 4, 4, 1, 0, 1, 3, 6, 4, 3, 0, 1, 2, 1, 2, 1, 0, 2, 3, 3, 4, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 2, 2, 1, 1, 1, 1, 2, 2, 1, 4, 4, 3, 3, 3, 1, 3, 3, 1, 3, 5, 1, 0, 1, 1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, 1, 1, 1, 1, 1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 1, 4, 3, 3, 3, 2, 2, 2, 2 }; /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE doesn't specify something else to do. Zero means the default is an error. */ static const short yydefact[] = { 48, 0, 1, 49, 0, 263, 0, 261, 262, 0, 408, 0, 47, 0, 67, 68, 0, 70, 69, 0, 0, 46, 0, 54, 50, 58, 59, 56, 0, 63, 65, 57, 55, 0, 264, 265, 0, 413, 0, 0, 0, 53, 52, 0, 0, 66, 0, 269, 268, 266, 267, 274, 275, 276, 277, 278, 279, 280, 281, 272, 273, 270, 271, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 0, 96, 93, 104, 101, 97, 91, 90, 89, 103, 102, 92, 98, 94, 95, 99, 100, 0, 0, 78, 80, 0, 85, 87, 81, 82, 83, 407, 0, 60, 35, 37, 36, 0, 42, 0, 40, 39, 41, 0, 0, 38, 0, 0, 11, 29, 21, 22, 0, 153, 23, 10, 259, 29, 72, 142, 296, 412, 0, 139, 75, 79, 115, 0, 0, 261, 92, 88, 0, 155, 0, 0, 0, 0, 20, 156, 13, 64, 0, 258, 0, 74, 0, 0, 141, 297, 0, 232, 232, 0, 0, 0, 0, 0, 314, 251, 0, 364, 0, 0, 0, 252, 0, 0, 0, 6, 7, 2, 3, 4, 5, 8, 9, 0, 0, 188, 0, 0, 0, 0, 0, 0, 250, 0, 29, 186, 0, 0, 173, 175, 176, 179, 180, 181, 0, 182, 183, 211, 184, 185, 0, 187, 325, 247, 249, 246, 259, 261, 304, 255, 256, 257, 248, 345, 326, 329, 330, 0, 334, 337, 338, 333, 346, 351, 341, 342, 191, 0, 105, 0, 320, 114, 0, 113, 125, 61, 0, 246, 257, 248, 329, 330, 381, 337, 338, 0, 382, 0, 0, 0, 32, 34, 33, 31, 0, 14, 24, 30, 152, 154, 260, 71, 0, 0, 129, 143, 86, 140, 409, 410, 411, 0, 231, 0, 0, 0, 0, 217, 0, 0, 0, 0, 244, 0, 0, 381, 0, 363, 365, 380, 366, 0, 0, 0, 0, 237, 0, 0, 246, 0, 0, 0, 357, 0, 360, 309, 350, 349, 339, 340, 343, 344, 0, 320, 0, 170, 174, 190, 0, 0, 235, 238, 234, 0, 0, 308, 0, 0, 308, 331, 332, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 84, 125, 0, 107, 319, 125, 124, 0, 119, 121, 0, 45, 0, 0, 0, 0, 0, 0, 0, 0, 43, 44, 160, 12, 0, 158, 247, 246, 347, 326, 383, 334, 335, 346, 0, 161, 382, 29, 0, 299, 309, 25, 73, 62, 0, 0, 0, 86, 147, 148, 227, 228, 0, 0, 213, 218, 364, 0, 216, 0, 0, 0, 0, 0, 29, 17, 16, 18, 19, 0, 0, 244, 0, 229, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 301, 0, 0, 230, 0, 0, 254, 253, 354, 355, 0, 356, 0, 0, 0, 178, 302, 125, 241, 236, 239, 300, 0, 309, 0, 307, 303, 189, 0, 393, 397, 398, 394, 395, 396, 399, 401, 400, 402, 403, 404, 106, 0, 321, 0, 0, 0, 127, 125, 0, 388, 389, 385, 386, 387, 390, 392, 391, 157, 0, 26, 29, 0, 130, 0, 0, 144, 146, 0, 177, 0, 0, 212, 222, 225, 226, 0, 0, 313, 308, 0, 317, 312, 315, 29, 15, 242, 0, 0, 0, 371, 368, 367, 0, 374, 375, 376, 377, 378, 372, 373, 369, 370, 0, 0, 0, 352, 353, 358, 0, 361, 0, 310, 359, 0, 298, 306, 305, 320, 322, 0, 108, 110, 109, 323, 320, 0, 0, 126, 122, 320, 159, 27, 29, 0, 0, 0, 0, 219, 215, 221, 0, 223, 198, 0, 309, 316, 318, 244, 243, 406, 0, 202, 200, 233, 208, 0, 0, 0, 0, 127, 165, 169, 0, 166, 168, 324, 127, 128, 0, 123, 28, 149, 125, 125, 0, 0, 214, 220, 0, 0, 311, 245, 379, 0, 0, 0, 0, 204, 359, 0, 362, 240, 116, 163, 0, 116, 0, 252, 0, 135, 136, 0, 0, 0, 209, 0, 224, 199, 405, 0, 207, 201, 0, 205, 0, 0, 116, 164, 167, 0, 308, 308, 0, 134, 320, 320, 210, 206, 203, 0, 132, 111, 131, 117, 112, 0, 0, 133, 127, 127, 0, 0, 0, 0, 0, 0, 138, 137, 150, 151, 0, 118, 0, 0, 0 }; static const short yydefgoto[] = { 701, 199, 200, 383, 121, 424, 425, 150, 253, 272, 273, 153, 274, 123, 124, 2, 3, 9, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 158, 280, 37, 94, 95, 96, 97, 98, 99, 100, 244, 245, 569, 101, 246, 141, 664, 665, 368, 369, 370, 371, 575, 576, 282, 680, 102, 647, 648, 649, 103, 31, 160, 161, 284, 407, 408, 409, 410, 32, 125, 126, 127, 385, 386, 610, 611, 612, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 601, 634, 635, 636, 213, 417, 624, 418, 419, 214, 589, 420, 524, 215, 288, 216, 217, 337, 338, 339, 218, 430, 219, 220, 221, 254, 223, 130, 7, 8, 225, 226, 399, 227, 255, 472, 473, 256, 298, 530, 531, 364, 365, 230, 389, 231, 257, 258, 302, 391, 235, 260, 261, 238, 393, 239, 240, 241, 242, 318, 319, 320, 321, 303, 471, 305, 396, 263, 306, 658, 307 }; static const short yypact[] = { 15, 42,-32768,-32768, -13,-32768, 26,-32768,-32768, 35, -32768, 21,-32768, 18,-32768,-32768, 46,-32768,-32768, 69, 186,-32768, 186,-32768,-32768,-32768,-32768,-32768, 74, 160, -32768,-32768,-32768, 2855,-32768,-32768, 2409,-32768, 34, 140, 519,-32768,-32768, 146, 146,-32768, 161,-32768,-32768,-32768, -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, -32768,-32768,-32768,-32768,-32768,-32768,-32768, 150,-32768,-32768, -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 169,-32768, -32768,-32768,-32768,-32768, 182, 2476,-32768,-32768, 2852, 879, -32768,-32768,-32768,-32768,-32768, 22,-32768,-32768,-32768,-32768, 146,-32768, 167,-32768,-32768,-32768, 179, 189,-32768, 146, 146,-32768,-32768,-32768,-32768, 207, 221,-32768,-32768,-32768, 240, 316, 321, 257,-32768, 1268,-32768,-32768,-32768,-32768, 25, 25, 273,-32768,-32768, 274,-32768, 2258, 2258, 2258, 269, 240,-32768, 3, 160, 519, 3, 2876, 342, 2876, 294,-32768,-32768, 194, 146, 146, 1718, 2876, 293, 301, 308, 319,-32768, -38, 2108, 314, 324, 325,-32768, 2108, 169, 328,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 2108, 2108,-32768, 2258, 2258, 2258, 2258, 2258, 2258,-32768, 146, 323,-32768, 329, 1358,-32768,-32768,-32768,-32768,-32768, -32768, 326,-32768,-32768,-32768,-32768,-32768, 54,-32768,-32768, 331, 335, 93, 333, 320,-32768,-32768, 344, 156, 164, 166,-32768, 176, 237, 885,-32768, 263, 278,-32768,-32768, -32768,-32768,-32768,-32768, 84,-32768, 346, 4,-32768, 348, -32768, 10,-32768, 323, 349,-32768,-32768,-32768,-32768,-32768, -32768,-32768, 258,-32768, 611, 979, 2258,-32768,-32768,-32768, -32768, 1953,-32768, 352,-32768,-32768,-32768,-32768,-32768, 2876, 18, 347,-32768, 2809,-32768,-32768,-32768,-32768, 350,-32768, 358, 36, 360, 146, 2183, 146, 2108, 2108, 2876, 2108, 365, 2108, 885, 364, 790, 119,-32768,-32768, 25, 2108, 2108, 543,-32768, 2108, 351, 315, 959, 368, 369, 370, 375, 384, 668,-32768,-32768,-32768,-32768,-32768,-32768, 153, 371, 25,-32768,-32768,-32768, 392, 169, 452, 466,-32768, 25, 2108, 2108, 25, 1718, 2108,-32768,-32768, 2108, 2108, 2108, 2108, 2108, 2108, 2108, 2108, 2108, 2108, 2108, 2108, 146,-32768, 10, 398, 395, 401, 10,-32768, 414,-32768, 412, 2876,-32768, 2258, 2258, 2258, 2258, 2258, 2258, 2258, 2258,-32768,-32768,-32768,-32768, 411, 416, 94, 31,-32768, 72,-32768, 210,-32768, 213, 119,-32768, 234,-32768, 418, -32768, 770,-32768,-32768,-32768, 2876, 2852, 423, 2809,-32768, -32768,-32768,-32768, 428, 220,-32768, 425, 2108, 421,-32768, 431, 1, 1135, 2462, 298,-32768,-32768,-32768,-32768,-32768, 432, 635, 2108, 888,-32768, 2876, 2108, 2108, 2108, 2108, 2108, 2108, 2108, 2108, 2108, 2108, 2108, 2108,-32768, 2495, 2525,-32768, 2547, 2258, 2333,-32768,-32768,-32768, 2108,-32768, 2108, 2108, 2108,-32768,-32768, 495,-32768,-32768,-32768,-32768, 434, 1026, 440,-32768,-32768,-32768, 441, 790, 790, 790, 790, 790, 790, 790, 790, 790, 790, 790, 790,-32768, 443, 487, 2033, 446, 447, 467, 495, 146, 291, 291, -32768,-32768,-32768, 190, 190, 190,-32768, 2258, 175,-32768, 455,-32768, 25, 25,-32768,-32768, 2108,-32768, 2258, 449, -32768, 504,-32768,-32768, 2108, 1718,-32768, 2108, 1953,-32768, -32768, 461,-32768, 175,-32768, 1718, 468, 2108,-32768,-32768, -32768, 2573, 204, 359, 1731, 98, 2729, 78, 78,-32768, -32768, 471, 1718, 1718,-32768,-32768,-32768, 2603,-32768, 2625, -32768, 2651, 473,-32768,-32768,-32768, 371,-32768, 1793,-32768, -32768, 790, 518, 371, 2876, 475,-32768,-32768, 371,-32768, 175,-32768, 229, 479, 480, 2681,-32768, 2258,-32768, 1718, 2705, 542, 483, 937,-32768, 175, 2108,-32768, 790, 2108, 45,-32768,-32768,-32768, 2108, 2108, 2108, 169, 467,-32768, -32768, 49,-32768, 790,-32768, 467,-32768, 1448,-32768, 175, -32768, 10, 10, 477, 486,-32768,-32768, 146, 1718,-32768, -32768, 790, 2108, 474, 485, 1628, 45, 790, 2651, 790, -32768, 529,-32768, 1873, 529, 116, 496, 1538,-32768,-32768, 494, 498, 499,-32768, 1718,-32768,-32768, 790, 489,-32768, -32768, 1131,-32768, 502, 191, 529,-32768,-32768, 191, 2108, 2108, 503,-32768, 371, 371,-32768,-32768,-32768, 146,-32768, -32768,-32768,-32768,-32768, 512, 513,-32768, 467, 467, 511, 497, 515, 516, 517, 146,-32768,-32768,-32768,-32768, 520, -32768, 595, 596,-32768 }; static const short yypgoto[] = { -32768,-32768, -17,-32768, -262,-32768,-32768, 304, -30, -149, -392, -88,-32768, 305, 309,-32768,-32768,-32768, 302,-32768, 456,-32768,-32768,-32768,-32768,-32768,-32768, 580,-32768,-32768, 334,-32768,-32768, 524,-32768, -257,-32768, 514, -194, 255, -32768,-32768, -133, 214, -593,-32768, -341, 125, 157,-32768, -539,-32768, -259, -45,-32768,-32768,-32768,-32768,-32768,-32768, -32768,-32768,-32768, 224,-32768,-32768,-32768,-32768, 482,-32768, 330, 127,-32768, 158,-32768, -1, -85, -544, 17, -202, 355, -154,-32768,-32768,-32768, -289,-32768,-32768, -8, 19, -32768,-32768,-32768,-32768,-32768, -479,-32768,-32768, 27,-32768, -32768, 493,-32768,-32768, 337,-32768, 322,-32768, -408,-32768, -252,-32768, -23, -12, 14, -43,-32768, 30,-32768, 332, -32768, -122, -334, -182, -116,-32768, 130,-32768, -521,-32768, -32768,-32768, -250, 73, 139, 292,-32768, -248, 159, 272, 222,-32768, -244,-32768,-32768, -390, 223,-32768, 218,-32768, 262, 659, -47,-32768, -239, 312,-32768,-32768 }; #define YYLAST 2974 static const short yytable[] = { 131, 132, 333, 136, 384, 416, 329, 277, 249, 317, 122, 476, 292, 228, 387, 6, 390, 128, 392, 229, 403, 490, 394, 120, 536, 494, 406, 397, 129, 367, 39, 5, 529, 522, 532, -51, 13, 267, 14, 586, 299, 35, 156, 4, 228, 608, -64, 38, 268, 269, 229, 668, 615, 632, 15, 142, 1, 618, 633, 270, 33, 33, 16, 335, 33, -64, 17, 146, 122, 641, 523, 10, 682, 650, 336, 128, 644, 152, 287, 18, -113, 140, 228, 271, 363, 43, 129, -120, 229, 400, 34, 34, 224, 19, 5, 312, 36, 247, 250, 414, 262, 264, 265, 671, 44, 201, 435, 342, 625, 11, 12, 5, 222, -162, 135, 5, 145, -162, 104, 20, 286, 289, 289, 224, 402, 122, 435, 122, 642, 122, 300, 643, 128, 151, 128, 35, 128, 122, 120, 529, 278, 532, 281, 129, 128, 129, 511, 129, 692, 693, 293, 406, 687, 688, -328, 129, 40, 330, -328, 400, 201, 224, -10, 14, 436, 437, 360, 315, 361, 342, 248, 248, 228, 314, 201, 448, -327, 340, 229, 15, -327, 222, 446, 447, 436, 437, -51, 13, 630, 14, 475, 17, 669, 592, 439, 440, 441, -64, 464, 308, 444, 445, 446, 447, 18, 15, 287, 469, 232, 267, 474, 373, 374, 375, 376, 5, -64, 17, 377, 395, 268, 269, 228, 105, 106, 378, 379, 380, 229, 416, 18, 270, 435, -196, 134, 360, 201, 463, -196, 232, -196, -197, 133, 388, 19, 384, -197, 135, -197, 122, 330, 466, 421, -194, 147, 387, 128, 390, -194, 392, -194, 137, 281, 394, 201, 250, 148, 129, 397, 135, 20, 222, 135, 285, 233, 679, 149, 232, 286, 560, 651, 652, 373, 374, 375, 376, 346, 347, 250, 377, 436, 437, -336, 154, 236, -348, -336, 250, 416, -348, 250, 224, 360, 155, 517, 233, 444, 445, 446, 447, 508, 360, 151, 620, -195, 616, -384, 330, 582, -195, -384, -195, 41, 11, 42, 236, 498, 499, 500, 501, 502, 503, 504, 505, 157, 684, 685, 533, 248, 159, -192, 122, 162, 233, 372, -192, 400, -192, 128, 251, 373, 374, 375, 376, 497, -193, 266, 377, 252, 129, -193, 248, -193, 236, 378, 379, 380, 232, 279, 294, 248, 591, 283, 248, 527, 122, 122, 295, 528, 583, 584, 596, 128, 128, 296, 375, 376, 435, 281, 512, 377, 342, 454, 129, 129, 297, 228, 308, 602, 603, 309, 310, 229, 228, 313, 122, 331, 237, 332, 229, 334, 344, 128, 228, 340, 341, 343, 232, 538, 229, 345, 580, 362, 129, 366, 342, 413, 234, 453, 405, 228, 228, 271, 233, 411, 626, 229, 229, 237, 259, 259, 259, 412, 432, 595, 436, 437, 243, 434, 456, 457, 363, 458, 236, 578, 439, 459, 441, 234, 333, 395, 444, 445, 446, 447, 228, 460, 228, 465, 247, 250, 229, 336, 229, 656, 335, 237, 201, 243, 491, 492, 493, 224, 233, 388, 323, 324, 325, 326, 327, 328, 495, 224, 619, 496, 228, 234, 506, 507, 509, 675, 229, 514, 236, 516, 520, 228, 518, 521, 224, 224, 534, 229, 228, 367, 563, 243, 564, 565, 229, 566, 567, 640, 107, 573, 228, 108, 572, 574, 109, 110, 229, 228, 587, 111, 112, 581, 588, 229, 228, 113, 528, 248, 248, 122, 229, 224, 597, 114, 600, 607, 128, 614, 617, 115, 621, 622, 281, 259, 628, 629, 653, 129, 654, 660, 659, 237, 116, 117, 663, 118, 435, 670, 672, 224, 673, 674, 119, 678, 681, 676, 695, 686, 681, 421, 224, 234, 201, 5, 690, 691, 232, 224, 694, 222, 702, 703, 700, 232, 696, 697, 698, 426, 427, 224, 201, 243, 428, 232, 45, 275, 224, 222, 144, 404, 489, 237, 201, 224, 138, 513, 577, 562, 683, 222, 232, 232, 451, 429, 436, 437, 201, 515, 438, 579, 689, 234, 276, 222, 439, 440, 441, 667, 442, 443, 444, 445, 446, 447, 415, 570, 699, 661, 677, 655, 662, 243, 233, 290, 467, 232, 594, 232, 435, 233, 259, 259, 259, 259, 259, 259, 259, 259, 470, 233, 468, 555, 236, 558, 519, 0, 556, 0, 0, 236, 0, 0, 0, 0, 0, 232, 233, 233, 0, 236, 0, 435, 381, 0, 0, 0, 232, 0, 373, 374, 375, 376, 0, 232, 0, 377, 236, 236, 0, 0, 0, 0, 378, 379, 380, 232, 436, 437, 0, 0, 438, 233, 232, 233, 0, 0, 439, 440, 441, 232, 442, 443, 444, 445, 446, 447, 0, 0, 0, 0, 554, 236, 0, 236, 0, 461, 0, 0, 0, 436, 437, 233, 535, 438, 462, 0, 0, 0, 0, 439, 440, 441, 233, 442, 443, 444, 445, 446, 447, 233, 0, 236, 0, 0, 0, 0, 0, 0, 0, 0, 0, 233, 236, 0, 0, 237, 0, 0, 233, 236, 0, 0, 237, 435, 259, 233, 0, 0, 0, 0, 0, 236, 237, 0, 0, 234, 0, 0, 236, 0, 0, 0, 234, 435, 0, 236, 0, 0, 0, 237, 237, 0, 234, 0, 0, 243, 0, 0, 304, 0, 0, 0, 243, 311, 510, 0, 0, 0, 0, 234, 234, 0, 243, 0, 316, 322, 0, 461, 0, 0, 0, 436, 437, 0, 237, 438, 237, 0, 0, 243, 243, 439, 440, 441, 0, 442, 443, 444, 445, 446, 447, 436, 437, 0, 234, 438, 234, 78, 0, 0, 0, 439, 440, 441, 237, 442, 443, 444, 445, 446, 447, 0, 0, 79, 243, 237, 243, 0, 0, 0, 0, 0, 237, 0, 234, 0, 537, 80, 81, 0, 82, 435, 0, 0, 237, 234, 83, 84, 85, 86, 87, 237, 234, 0, 243, 401, 143, 0, 237, 89, 90, 91, 0, 0, 234, 243, 92, 0, 0, 93, 0, 234, 243, 0, 0, 0, 0, 0, 234, 0, 422, 423, 0, 431, 243, 433, 0, 0, 0, 0, 435, 243, 0, 449, 450, 348, 0, 452, 243, 436, 437, 0, 0, 438, 0, 0, 0, 0, 0, 439, 440, 441, 435, 442, 443, 444, 445, 446, 447, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 0, 510, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 461, 0, 0, 0, 436, 437, 0, 0, 438, 462, 0, 0, 0, 0, 439, 440, 441, 455, 442, 443, 444, 445, 446, 447, 0, 0, 436, 437, 0, 0, 438, 0, 0, 0, 0, 435, 439, 440, 441, 0, 442, 443, 444, 445, 446, 447, 382, 0, 0, 0, 0, 0, 373, 374, 375, 376, 0, 304, 0, 377, 0, 0, 0, 0, 0, 0, 378, 379, 380, 0, 0, 0, 431, 0, 0, 0, 539, 540, 541, 542, 543, 544, 545, 546, 547, 548, 549, 550, 0, 461, 0, 0, 0, 436, 437, 0, 0, 438, 557, 0, 559, 0, 561, 439, 440, 441, 0, 442, 443, 444, 445, 446, 447, 291, 0, 0, 107, 164, 0, 108, 632, 0, 109, 0, 165, 633, 166, 111, 112, 0, 0, 167, 571, 113, 168, 0, 169, 170, 0, 0, 0, 114, 0, 0, 435, 0, 0, 115, 0, 171, 172, 33, 0, 0, 0, 0, 585, 0, 0, 173, 116, 117, 174, 118, 590, 175, 176, 177, 593, 0, 119, 178, 179, 0, 0, 180, 0, 598, 181, 182, 183, 5, 184, 185, 186, 187, 188, 189, 190, 0, 135, -202, 191, 525, 0, 0, 192, 0, 0, 0, 193, 194, 436, 437, 195, 196, 438, 0, 613, 0, 0, 0, 439, 440, 441, 0, 442, 443, 444, 445, 446, 447, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 197, 198, 0, 0, 431, 0, 0, 631, 0, 0, 0, 0, 637, 638, 639, 0, 0, 0, 163, 0, 0, 107, 164, 0, 108, 0, 0, 109, 0, 165, 0, 166, 111, 112, 0, 0, 167, 0, 113, 168, 657, 169, 170, 0, 0, 0, 114, 0, 0, 0, 0, 613, 115, 0, 171, 172, 33, 0, 0, 0, 0, 0, 0, 0, 173, 116, 117, 174, 118, 0, 175, 176, 177, 0, 0, 119, 178, 179, 0, 0, 180, 0, 0, 181, 182, 183, 5, 184, 185, 186, 187, 188, 189, 190, 0, 135, -172, 191, 0, 0, 0, 192, 0, 0, 0, 193, 194, 0, 291, 195, 196, 107, 164, 0, 108, 0, 0, 109, 0, 165, 0, 166, 111, 112, 0, 0, 167, 0, 113, 168, 0, 169, 170, 0, 0, 0, 114, 197, 198, 0, 0, 0, 115, 0, 171, 172, 33, 0, 0, 0, 0, 0, 0, 0, 173, 116, 117, 174, 118, 0, 175, 176, 177, 0, 0, 119, 178, 179, 0, 0, 180, 0, 0, 181, 182, 183, 5, 184, 185, 186, 187, 188, 189, 190, 0, 135, -171, 191, 0, 0, 0, 192, 0, 0, 0, 193, 194, 0, 291, 195, 196, 107, 164, 0, 108, 0, 0, 109, 0, 165, 0, 166, 111, 112, 0, 0, 167, 0, 113, 168, 0, 169, 170, 0, 0, 0, 114, 197, 198, 0, 0, 0, 115, 0, 171, 172, 33, 0, 0, 0, 0, 0, 0, 0, 173, 116, 117, 174, 118, 0, 645, 176, 177, 0, 0, 119, 646, 179, 0, 0, 180, 0, 0, 181, 182, 183, 5, 184, 185, 186, 187, 188, 189, 190, 0, 135, -172, 191, 0, 0, 0, 192, 0, 0, 0, 193, 194, 0, 291, 195, 196, 107, 164, 0, 108, 0, 0, 109, 0, 165, 0, 166, 111, 112, 0, 0, 167, 0, 113, 168, 0, 169, 170, 0, 0, 0, 114, 197, 198, 0, 0, 0, 115, 0, 171, 172, 33, 0, 0, 0, 0, 0, 0, 0, 173, 116, 117, 174, 118, 0, 175, 176, 177, 0, 0, 119, 178, 179, 0, 0, 180, 0, 0, 181, 182, 183, 5, 184, 185, 186, 187, 188, 189, 190, 0, 135, -172, 191, 0, 0, 0, 192, 0, 0, 0, 193, 194, 0, 291, 195, 196, 107, 164, 0, 108, 0, 0, 109, 0, 165, 0, 166, 111, 112, 0, 0, 167, 0, 113, 168, 0, 169, 170, 0, 0, 0, 114, 197, 198, 0, 0, 0, 115, 0, 171, 172, 33, 0, 0, 0, 0, 0, 0, 0, 173, 116, 117, 174, 118, 0, 175, 176, 177, 0, 0, 119, 178, 179, 0, 0, 180, 0, 0, 181, 182, 183, 5, 184, 185, 186, 187, 188, 189, 190, 0, 135, 0, 191, 0, 0, 0, 192, 0, 0, 0, 193, 194, 0, 291, 195, 196, 107, 164, 0, 108, 0, 0, 109, 0, 165, 0, 166, 111, 112, 0, 0, 0, 0, 113, 168, 0, 169, 170, 0, 0, 0, 114, 197, 198, 0, 0, 0, 115, 0, 171, 172, 33, 0, 435, 0, 0, 0, 0, 0, 173, 116, 117, 174, 118, 0, 175, 176, 177, 0, 0, 119, 178, 179, 0, 0, 180, 0, 0, 181, 182, 183, 5, 184, 185, 186, 187, 188, 189, 190, 0, 135, 107, 191, 301, 108, 0, 192, 109, 0, 0, 193, 194, 111, 112, 195, 196, 0, 0, 113, 0, 0, 436, 437, 0, 0, 0, 114, 0, 0, 0, 0, 439, 115, 0, 171, 172, 33, 444, 445, 446, 447, 0, 197, 198, 0, 116, 117, 0, 118, 0, 175, 0, 0, 0, 0, 119, 178, 0, 0, 0, 0, 0, 0, 0, 182, 183, 5, 184, 185, 186, 187, 188, 189, 190, 0, 568, 609, 191, 0, 0, 0, 107, 0, 301, 108, 193, 194, 109, 0, 195, 196, 0, 111, 112, 0, 0, 0, 0, 113, 0, 0, 0, 0, 0, 0, 0, 114, 0, 0, 0, 0, 0, 115, 0, 171, 172, 33, 197, 198, 0, 0, 0, 0, 0, 0, 116, 117, 0, 118, 0, 175, 0, 0, 0, 0, 119, 178, 0, 0, 0, 0, 0, 0, 0, 182, 183, 5, 184, 185, 186, 187, 188, 189, 190, 0, 568, 666, 191, 0, 0, 0, 107, 0, 301, 108, 193, 194, 109, 0, 195, 196, 0, 111, 112, 0, 0, 0, 0, 113, 0, 0, 0, 0, 0, 0, 0, 114, 0, 0, 0, 0, 0, 115, 0, 171, 172, 33, 197, 198, 0, 0, 0, 0, 0, 0, 116, 117, 0, 118, 0, 175, 0, 0, 0, 0, 119, 178, 0, 0, 0, 0, 0, 0, 0, 182, 183, 5, 184, 185, 186, 187, 188, 189, 190, 0, 0, 0, 191, 398, 0, 0, 107, 0, 301, 108, 193, 194, 109, 0, 195, 196, 0, 111, 112, 0, 0, 0, 0, 113, 0, 0, 0, 0, 0, 0, 0, 114, 0, 0, 0, 0, 0, 115, 0, 171, 172, 33, 197, 198, 0, 0, 0, 0, 0, 0, 116, 117, 0, 118, 0, 175, 0, 0, 0, 0, 119, 178, 0, 0, 0, 0, 0, 0, 0, 182, 183, 5, 184, 185, 186, 187, 188, 189, 190, 0, 568, 107, 191, 301, 108, 0, 0, 109, 0, 0, 193, 194, 111, 112, 195, 196, 0, 0, 113, 0, 0, 0, 0, 0, 0, 0, 114, 0, 0, 0, 0, 0, 115, 0, 171, 172, 33, 0, 0, 0, 0, 0, 197, 198, 0, 116, 117, 0, 118, 0, 175, 0, 0, 0, 0, 119, 178, 0, 0, 0, 0, 0, 0, 0, 182, 183, 5, 184, 185, 186, 187, 188, 189, 190, 0, 0, 107, 191, 0, 108, 0, 0, 109, 0, 0, 193, 194, 111, 112, 195, 196, 167, 0, 113, 0, 0, 0, 0, 0, 0, 0, 114, 0, 0, 0, 0, 0, 115, 0, 171, 172, 33, 0, 0, 0, 0, 0, 197, 198, 0, 116, 117, 0, 118, 0, 175, 0, 0, 0, 0, 119, 178, 0, 0, 0, 0, 0, 0, 0, 182, 183, 5, 184, 185, 186, 187, 188, 189, 190, 0, 0, 107, 191, 0, 108, 0, 0, 109, 0, 0, 193, 194, 111, 112, 195, 196, 0, 0, 113, 0, 0, 0, 0, 0, 0, 0, 114, 0, 0, 0, 0, 0, 115, 0, 171, 172, 33, 0, 0, 0, 0, 0, 197, 198, 0, 116, 117, 0, 118, 0, 175, 0, 0, 0, 0, 119, 178, 0, 0, 0, 0, 0, 0, 0, 182, 183, 5, 184, 185, 186, 187, 188, 189, 190, 0, 0, 107, 191, 0, 108, 0, 0, 109, 0, 0, 193, 194, 111, 112, 195, 196, 0, 0, 113, 0, 0, 0, 0, 0, 0, 0, 114, 0, 0, 0, 0, 0, 115, 0, 171, 172, 33, 0, 0, 0, 0, 0, 197, 198, 0, 116, 117, 0, 118, 0, 175, 0, 0, 0, 0, 119, 178, 0, 0, 0, 0, 0, 0, 0, 182, 183, 5, 184, 185, 186, 187, 188, 189, 190, 77, 0, 78, -86, 0, 0, -86, 0, 0, -86, 0, 193, 194, 0, -86, -86, 0, 0, 79, 0, -86, 0, 0, 0, 0, 0, 0, 0, -86, 0, 0, 0, 80, 81, -86, 82, 0, 0, 0, 0, 0, 83, 84, 85, 86, 87, 0, -86, -86, 0, -86, 88, 0, 0, 89, 90, 91, -86, 0, 0, 0, 92, 0, -86, 93, 0, 0, 77, -86, 78, -86, 0, 0, -86, 0, 0, -86, 0, -77, 0, 435, -86, -86, 0, 0, 79, 0, -86, 0, 0, 0, 0, 0, 0, 0, -86, 0, 0, 0, 80, 81, -86, 82, 0, 0, 0, 0, 0, 83, 84, 85, 86, 87, 435, -86, -86, 0, -86, 88, 0, 0, 89, 90, 91, -86, 0, 0, 0, 92, 526, -86, 93, 0, 0, 0, -86, 0, 0, 436, 437, 0, 0, 438, 435, 0, -76, 0, 0, 439, 440, 441, 0, 442, 443, 444, 445, 446, 447, 0, 0, 0, 0, 551, 0, 0, 435, 0, 0, 0, 0, 0, 436, 437, 0, 0, 438, 0, 0, 0, 0, 0, 439, 440, 441, 0, 442, 443, 444, 445, 446, 447, 435, 552, 0, 0, 0, 0, 0, 0, 0, 0, 436, 437, 0, 0, 438, 0, 0, 0, 0, 0, 439, 440, 441, 553, 442, 443, 444, 445, 446, 447, 435, 0, 436, 437, 0, 0, 438, 0, 0, 0, 0, 0, 439, 440, 441, 0, 442, 443, 444, 445, 446, 447, 435, 0, 0, 0, 0, 0, 436, 437, 0, 0, 438, 599, 0, 0, 0, 0, 439, 440, 441, 0, 442, 443, 444, 445, 446, 447, 435, 0, 0, 0, 0, 0, 0, 0, 0, 0, 436, 437, 0, 0, 438, 604, 0, 0, 0, 0, 439, 440, 441, 0, 442, 443, 444, 445, 446, 447, 435, 0, 436, 437, 0, 0, 438, 605, 0, 0, 0, 0, 439, 440, 441, 0, 442, 443, 444, 445, 446, 447, 0, 0, 435, 0, 0, 0, 436, 437, 0, 0, 438, 606, 0, 0, 0, 0, 439, 440, 441, 0, 442, 443, 444, 445, 446, 447, 435, 623, 0, 0, 0, 0, 0, 0, 0, 0, 436, 437, 0, 0, 438, 0, 0, 0, 0, 0, 439, 440, 441, 0, 442, 443, 444, 445, 446, 447, 627, 0, 0, 0, 436, 437, 0, 0, 438, 0, 0, 0, 0, 0, 439, 440, 441, 0, 442, 443, 444, 445, 446, 447, 0, 78, 0, 0, 436, 437, 0, 0, 0, 0, 0, 0, 0, 0, 439, 440, 441, 79, 442, 0, 444, 445, 446, 447, 0, 0, 0, 0, 0, 0, 0, 80, 81, 0, 82, 0, 0, 0, 0, 0, 83, 84, 85, 86, 87, 107, 0, 0, 108, 0, 143, 109, 0, 89, 90, 91, 111, 112, 0, 0, 92, 0, 113, 93, 0, 0, 0, 0, 0, 107, 114, 0, 108, 0, 0, 109, 115, -145, 0, 0, 111, 112, 0, 0, 0, 0, 113, 0, 0, 116, 117, 0, 118, 0, 114, 0, 0, 0, 0, 119, 115, 0, 0, 0, 0, 139, 0, 0, 0, 0, 5, 0, 0, 116, 117, 0, 118, 0, 0, 0, 0, 0, 0, 119, 46, 0, 0, 0, 0, 0, 47, 48, 49, 50, 5, 0, 51, 52, 53, 54, 55, 56, 57, 58, 0, 0, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76 }; static const short yycheck[] = { 43, 44, 204, 88, 266, 294, 200, 156, 141, 191, 40, 345, 166, 135, 266, 1, 266, 40, 266, 135, 279, 362, 266, 40, 432, 366, 283, 266, 40, 19, 16, 69, 424, 32, 424, 0, 1, 34, 3, 518, 78, 11, 130, 1, 166, 566, 11, 1, 45, 46, 166, 644, 573, 8, 19, 98, 41, 578, 13, 56, 39, 39, 27, 9, 39, 30, 31, 110, 98, 608, 69, 84, 665, 617, 20, 98, 615, 120, 163, 44, 76, 98, 204, 80, 80, 11, 98, 77, 204, 271, 69, 69, 135, 58, 69, 180, 78, 140, 141, 293, 147, 148, 149, 647, 30, 135, 28, 76, 587, 83, 84, 69, 135, 82, 78, 69, 94, 86, 84, 84, 84, 164, 165, 166, 273, 155, 28, 157, 79, 159, 173, 82, 155, 119, 157, 105, 159, 167, 155, 531, 157, 531, 159, 155, 167, 157, 405, 159, 687, 688, 167, 408, 673, 674, 82, 167, 87, 200, 86, 341, 190, 204, 69, 3, 86, 87, 82, 190, 84, 76, 140, 141, 294, 190, 204, 308, 82, 83, 294, 19, 86, 204, 104, 105, 86, 87, 0, 1, 596, 3, 344, 31, 76, 527, 96, 97, 98, 11, 331, 83, 102, 103, 104, 105, 44, 19, 291, 340, 135, 34, 343, 92, 93, 94, 95, 69, 30, 31, 99, 266, 45, 46, 344, 83, 84, 106, 107, 108, 344, 518, 44, 56, 28, 77, 84, 82, 266, 84, 82, 166, 84, 77, 81, 266, 58, 507, 82, 78, 84, 279, 293, 336, 295, 77, 87, 507, 279, 507, 82, 507, 84, 79, 279, 507, 294, 308, 87, 279, 507, 78, 84, 294, 78, 79, 135, 84, 87, 204, 84, 461, 621, 622, 92, 93, 94, 95, 120, 121, 331, 99, 86, 87, 82, 86, 135, 82, 86, 340, 587, 86, 343, 344, 82, 82, 84, 166, 102, 103, 104, 105, 398, 82, 298, 84, 77, 574, 82, 360, 512, 82, 86, 84, 20, 83, 22, 166, 373, 374, 375, 376, 377, 378, 379, 380, 18, 669, 670, 425, 308, 18, 77, 371, 85, 204, 86, 82, 528, 84, 371, 76, 92, 93, 94, 95, 371, 77, 87, 99, 84, 371, 82, 331, 84, 204, 106, 107, 108, 294, 26, 76, 340, 525, 78, 343, 76, 405, 406, 76, 80, 512, 513, 535, 405, 406, 76, 94, 95, 28, 405, 406, 99, 76, 77, 405, 406, 76, 518, 83, 552, 553, 76, 76, 518, 525, 76, 435, 83, 135, 79, 525, 84, 91, 435, 535, 83, 80, 83, 344, 435, 535, 76, 509, 76, 435, 76, 76, 66, 135, 77, 82, 552, 553, 80, 294, 84, 589, 552, 553, 166, 147, 148, 149, 84, 78, 532, 86, 87, 135, 84, 81, 81, 80, 82, 294, 497, 96, 81, 98, 166, 661, 507, 102, 103, 104, 105, 587, 82, 589, 76, 512, 513, 587, 20, 589, 628, 9, 204, 507, 166, 81, 85, 80, 525, 344, 507, 193, 194, 195, 196, 197, 198, 77, 535, 581, 82, 617, 204, 86, 82, 81, 654, 617, 79, 344, 76, 84, 628, 82, 77, 552, 553, 79, 628, 635, 19, 81, 204, 77, 77, 635, 77, 34, 607, 4, 77, 647, 7, 81, 61, 10, 11, 647, 654, 84, 15, 16, 81, 33, 654, 661, 21, 80, 512, 513, 574, 661, 589, 79, 29, 78, 77, 574, 34, 78, 35, 76, 76, 574, 266, 17, 77, 84, 574, 77, 79, 91, 294, 48, 49, 40, 51, 28, 76, 79, 617, 77, 77, 58, 76, 664, 91, 84, 79, 668, 627, 628, 294, 617, 69, 77, 77, 518, 635, 82, 617, 0, 0, 77, 525, 84, 84, 84, 298, 298, 647, 635, 294, 298, 535, 29, 154, 654, 635, 99, 280, 360, 344, 647, 661, 95, 406, 496, 465, 668, 647, 552, 553, 84, 298, 86, 87, 661, 408, 90, 507, 678, 344, 155, 661, 96, 97, 98, 643, 100, 101, 102, 103, 104, 105, 294, 492, 694, 635, 661, 627, 636, 344, 518, 165, 337, 587, 531, 589, 28, 525, 373, 374, 375, 376, 377, 378, 379, 380, 341, 535, 338, 454, 518, 460, 417, -1, 458, -1, -1, 525, -1, -1, -1, -1, -1, 617, 552, 553, -1, 535, -1, 28, 86, -1, -1, -1, 628, -1, 92, 93, 94, 95, -1, 635, -1, 99, 552, 553, -1, -1, -1, -1, 106, 107, 108, 647, 86, 87, -1, -1, 90, 587, 654, 589, -1, -1, 96, 97, 98, 661, 100, 101, 102, 103, 104, 105, -1, -1, -1, -1, 453, 587, -1, 589, -1, 82, -1, -1, -1, 86, 87, 617, 122, 90, 91, -1, -1, -1, -1, 96, 97, 98, 628, 100, 101, 102, 103, 104, 105, 635, -1, 617, -1, -1, -1, -1, -1, -1, -1, -1, -1, 647, 628, -1, -1, 518, -1, -1, 654, 635, -1, -1, 525, 28, 507, 661, -1, -1, -1, -1, -1, 647, 535, -1, -1, 518, -1, -1, 654, -1, -1, -1, 525, 28, -1, 661, -1, -1, -1, 552, 553, -1, 535, -1, -1, 518, -1, -1, 174, -1, -1, -1, 525, 179, 69, -1, -1, -1, -1, 552, 553, -1, 535, -1, 190, 191, -1, 82, -1, -1, -1, 86, 87, -1, 587, 90, 589, -1, -1, 552, 553, 96, 97, 98, -1, 100, 101, 102, 103, 104, 105, 86, 87, -1, 587, 90, 589, 3, -1, -1, -1, 96, 97, 98, 617, 100, 101, 102, 103, 104, 105, -1, -1, 19, 587, 628, 589, -1, -1, -1, -1, -1, 635, -1, 617, -1, 23, 33, 34, -1, 36, 28, -1, -1, 647, 628, 42, 43, 44, 45, 46, 654, 635, -1, 617, 271, 52, -1, 661, 55, 56, 57, -1, -1, 647, 628, 62, -1, -1, 65, -1, 654, 635, -1, -1, -1, -1, -1, 661, -1, 296, 297, -1, 299, 647, 301, -1, -1, -1, -1, 28, 654, -1, 309, 310, 85, -1, 313, 661, 86, 87, -1, -1, 90, -1, -1, -1, -1, -1, 96, 97, 98, 28, 100, 101, 102, 103, 104, 105, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, -1, 69, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 82, -1, -1, -1, 86, 87, -1, -1, 90, 91, -1, -1, -1, -1, 96, 97, 98, 77, 100, 101, 102, 103, 104, 105, -1, -1, 86, 87, -1, -1, 90, -1, -1, -1, -1, 28, 96, 97, 98, -1, 100, 101, 102, 103, 104, 105, 86, -1, -1, -1, -1, -1, 92, 93, 94, 95, -1, 417, -1, 99, -1, -1, -1, -1, -1, -1, 106, 107, 108, -1, -1, -1, 432, -1, -1, -1, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, -1, 82, -1, -1, -1, 86, 87, -1, -1, 90, 458, -1, 460, -1, 462, 96, 97, 98, -1, 100, 101, 102, 103, 104, 105, 1, -1, -1, 4, 5, -1, 7, 8, -1, 10, -1, 12, 13, 14, 15, 16, -1, -1, 19, 492, 21, 22, -1, 24, 25, -1, -1, -1, 29, -1, -1, 28, -1, -1, 35, -1, 37, 38, 39, -1, -1, -1, -1, 516, -1, -1, 47, 48, 49, 50, 51, 524, 53, 54, 55, 528, -1, 58, 59, 60, -1, -1, 63, -1, 537, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, -1, 78, 79, 80, 77, -1, -1, 84, -1, -1, -1, 88, 89, 86, 87, 92, 93, 90, -1, 568, -1, -1, -1, 96, 97, 98, -1, 100, 101, 102, 103, 104, 105, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 120, 121, -1, -1, 596, -1, -1, 599, -1, -1, -1, -1, 604, 605, 606, -1, -1, -1, 1, -1, -1, 4, 5, -1, 7, -1, -1, 10, -1, 12, -1, 14, 15, 16, -1, -1, 19, -1, 21, 22, 632, 24, 25, -1, -1, -1, 29, -1, -1, -1, -1, 643, 35, -1, 37, 38, 39, -1, -1, -1, -1, -1, -1, -1, 47, 48, 49, 50, 51, -1, 53, 54, 55, -1, -1, 58, 59, 60, -1, -1, 63, -1, -1, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, -1, 78, 79, 80, -1, -1, -1, 84, -1, -1, -1, 88, 89, -1, 1, 92, 93, 4, 5, -1, 7, -1, -1, 10, -1, 12, -1, 14, 15, 16, -1, -1, 19, -1, 21, 22, -1, 24, 25, -1, -1, -1, 29, 120, 121, -1, -1, -1, 35, -1, 37, 38, 39, -1, -1, -1, -1, -1, -1, -1, 47, 48, 49, 50, 51, -1, 53, 54, 55, -1, -1, 58, 59, 60, -1, -1, 63, -1, -1, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, -1, 78, 79, 80, -1, -1, -1, 84, -1, -1, -1, 88, 89, -1, 1, 92, 93, 4, 5, -1, 7, -1, -1, 10, -1, 12, -1, 14, 15, 16, -1, -1, 19, -1, 21, 22, -1, 24, 25, -1, -1, -1, 29, 120, 121, -1, -1, -1, 35, -1, 37, 38, 39, -1, -1, -1, -1, -1, -1, -1, 47, 48, 49, 50, 51, -1, 53, 54, 55, -1, -1, 58, 59, 60, -1, -1, 63, -1, -1, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, -1, 78, 79, 80, -1, -1, -1, 84, -1, -1, -1, 88, 89, -1, 1, 92, 93, 4, 5, -1, 7, -1, -1, 10, -1, 12, -1, 14, 15, 16, -1, -1, 19, -1, 21, 22, -1, 24, 25, -1, -1, -1, 29, 120, 121, -1, -1, -1, 35, -1, 37, 38, 39, -1, -1, -1, -1, -1, -1, -1, 47, 48, 49, 50, 51, -1, 53, 54, 55, -1, -1, 58, 59, 60, -1, -1, 63, -1, -1, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, -1, 78, 79, 80, -1, -1, -1, 84, -1, -1, -1, 88, 89, -1, 1, 92, 93, 4, 5, -1, 7, -1, -1, 10, -1, 12, -1, 14, 15, 16, -1, -1, 19, -1, 21, 22, -1, 24, 25, -1, -1, -1, 29, 120, 121, -1, -1, -1, 35, -1, 37, 38, 39, -1, -1, -1, -1, -1, -1, -1, 47, 48, 49, 50, 51, -1, 53, 54, 55, -1, -1, 58, 59, 60, -1, -1, 63, -1, -1, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, -1, 78, -1, 80, -1, -1, -1, 84, -1, -1, -1, 88, 89, -1, 1, 92, 93, 4, 5, -1, 7, -1, -1, 10, -1, 12, -1, 14, 15, 16, -1, -1, -1, -1, 21, 22, -1, 24, 25, -1, -1, -1, 29, 120, 121, -1, -1, -1, 35, -1, 37, 38, 39, -1, 28, -1, -1, -1, -1, -1, 47, 48, 49, 50, 51, -1, 53, 54, 55, -1, -1, 58, 59, 60, -1, -1, 63, -1, -1, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, -1, 78, 4, 80, 6, 7, -1, 84, 10, -1, -1, 88, 89, 15, 16, 92, 93, -1, -1, 21, -1, -1, 86, 87, -1, -1, -1, 29, -1, -1, -1, -1, 96, 35, -1, 37, 38, 39, 102, 103, 104, 105, -1, 120, 121, -1, 48, 49, -1, 51, -1, 53, -1, -1, -1, -1, 58, 59, -1, -1, -1, -1, -1, -1, -1, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, -1, 78, 79, 80, -1, -1, -1, 4, -1, 6, 7, 88, 89, 10, -1, 92, 93, -1, 15, 16, -1, -1, -1, -1, 21, -1, -1, -1, -1, -1, -1, -1, 29, -1, -1, -1, -1, -1, 35, -1, 37, 38, 39, 120, 121, -1, -1, -1, -1, -1, -1, 48, 49, -1, 51, -1, 53, -1, -1, -1, -1, 58, 59, -1, -1, -1, -1, -1, -1, -1, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, -1, 78, 79, 80, -1, -1, -1, 4, -1, 6, 7, 88, 89, 10, -1, 92, 93, -1, 15, 16, -1, -1, -1, -1, 21, -1, -1, -1, -1, -1, -1, -1, 29, -1, -1, -1, -1, -1, 35, -1, 37, 38, 39, 120, 121, -1, -1, -1, -1, -1, -1, 48, 49, -1, 51, -1, 53, -1, -1, -1, -1, 58, 59, -1, -1, -1, -1, -1, -1, -1, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, -1, -1, -1, 80, 81, -1, -1, 4, -1, 6, 7, 88, 89, 10, -1, 92, 93, -1, 15, 16, -1, -1, -1, -1, 21, -1, -1, -1, -1, -1, -1, -1, 29, -1, -1, -1, -1, -1, 35, -1, 37, 38, 39, 120, 121, -1, -1, -1, -1, -1, -1, 48, 49, -1, 51, -1, 53, -1, -1, -1, -1, 58, 59, -1, -1, -1, -1, -1, -1, -1, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, -1, 78, 4, 80, 6, 7, -1, -1, 10, -1, -1, 88, 89, 15, 16, 92, 93, -1, -1, 21, -1, -1, -1, -1, -1, -1, -1, 29, -1, -1, -1, -1, -1, 35, -1, 37, 38, 39, -1, -1, -1, -1, -1, 120, 121, -1, 48, 49, -1, 51, -1, 53, -1, -1, -1, -1, 58, 59, -1, -1, -1, -1, -1, -1, -1, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, -1, -1, 4, 80, -1, 7, -1, -1, 10, -1, -1, 88, 89, 15, 16, 92, 93, 19, -1, 21, -1, -1, -1, -1, -1, -1, -1, 29, -1, -1, -1, -1, -1, 35, -1, 37, 38, 39, -1, -1, -1, -1, -1, 120, 121, -1, 48, 49, -1, 51, -1, 53, -1, -1, -1, -1, 58, 59, -1, -1, -1, -1, -1, -1, -1, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, -1, -1, 4, 80, -1, 7, -1, -1, 10, -1, -1, 88, 89, 15, 16, 92, 93, -1, -1, 21, -1, -1, -1, -1, -1, -1, -1, 29, -1, -1, -1, -1, -1, 35, -1, 37, 38, 39, -1, -1, -1, -1, -1, 120, 121, -1, 48, 49, -1, 51, -1, 53, -1, -1, -1, -1, 58, 59, -1, -1, -1, -1, -1, -1, -1, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, -1, -1, 4, 80, -1, 7, -1, -1, 10, -1, -1, 88, 89, 15, 16, 92, 93, -1, -1, 21, -1, -1, -1, -1, -1, -1, -1, 29, -1, -1, -1, -1, -1, 35, -1, 37, 38, 39, -1, -1, -1, -1, -1, 120, 121, -1, 48, 49, -1, 51, -1, 53, -1, -1, -1, -1, 58, 59, -1, -1, -1, -1, -1, -1, -1, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 1, -1, 3, 4, -1, -1, 7, -1, -1, 10, -1, 88, 89, -1, 15, 16, -1, -1, 19, -1, 21, -1, -1, -1, -1, -1, -1, -1, 29, -1, -1, -1, 33, 34, 35, 36, -1, -1, -1, -1, -1, 42, 43, 44, 45, 46, -1, 48, 49, -1, 51, 52, -1, -1, 55, 56, 57, 58, -1, -1, -1, 62, -1, 64, 65, -1, -1, 1, 69, 3, 4, -1, -1, 7, -1, -1, 10, -1, 79, -1, 28, 15, 16, -1, -1, 19, -1, 21, -1, -1, -1, -1, -1, -1, -1, 29, -1, -1, -1, 33, 34, 35, 36, -1, -1, -1, -1, -1, 42, 43, 44, 45, 46, 28, 48, 49, -1, 51, 52, -1, -1, 55, 56, 57, 58, -1, -1, -1, 62, 77, 64, 65, -1, -1, -1, 69, -1, -1, 86, 87, -1, -1, 90, 28, -1, 79, -1, -1, 96, 97, 98, -1, 100, 101, 102, 103, 104, 105, -1, -1, -1, -1, 77, -1, -1, 28, -1, -1, -1, -1, -1, 86, 87, -1, -1, 90, -1, -1, -1, -1, -1, 96, 97, 98, -1, 100, 101, 102, 103, 104, 105, 28, 77, -1, -1, -1, -1, -1, -1, -1, -1, 86, 87, -1, -1, 90, -1, -1, -1, -1, -1, 96, 97, 98, 77, 100, 101, 102, 103, 104, 105, 28, -1, 86, 87, -1, -1, 90, -1, -1, -1, -1, -1, 96, 97, 98, -1, 100, 101, 102, 103, 104, 105, 28, -1, -1, -1, -1, -1, 86, 87, -1, -1, 90, 91, -1, -1, -1, -1, 96, 97, 98, -1, 100, 101, 102, 103, 104, 105, 28, -1, -1, -1, -1, -1, -1, -1, -1, -1, 86, 87, -1, -1, 90, 91, -1, -1, -1, -1, 96, 97, 98, -1, 100, 101, 102, 103, 104, 105, 28, -1, 86, 87, -1, -1, 90, 91, -1, -1, -1, -1, 96, 97, 98, -1, 100, 101, 102, 103, 104, 105, -1, -1, 28, -1, -1, -1, 86, 87, -1, -1, 90, 91, -1, -1, -1, -1, 96, 97, 98, -1, 100, 101, 102, 103, 104, 105, 28, 77, -1, -1, -1, -1, -1, -1, -1, -1, 86, 87, -1, -1, 90, -1, -1, -1, -1, -1, 96, 97, 98, -1, 100, 101, 102, 103, 104, 105, 82, -1, -1, -1, 86, 87, -1, -1, 90, -1, -1, -1, -1, -1, 96, 97, 98, -1, 100, 101, 102, 103, 104, 105, -1, 3, -1, -1, 86, 87, -1, -1, -1, -1, -1, -1, -1, -1, 96, 97, 98, 19, 100, -1, 102, 103, 104, 105, -1, -1, -1, -1, -1, -1, -1, 33, 34, -1, 36, -1, -1, -1, -1, -1, 42, 43, 44, 45, 46, 4, -1, -1, 7, -1, 52, 10, -1, 55, 56, 57, 15, 16, -1, -1, 62, -1, 21, 65, -1, -1, -1, -1, -1, 4, 29, -1, 7, -1, -1, 10, 35, 79, -1, -1, 15, 16, -1, -1, -1, -1, 21, -1, -1, 48, 49, -1, 51, -1, 29, -1, -1, -1, -1, 58, 35, -1, -1, -1, -1, 64, -1, -1, -1, -1, 69, -1, -1, 48, 49, -1, 51, -1, -1, -1, -1, -1, -1, 58, 80, -1, -1, -1, -1, -1, 86, 87, 88, 89, 69, -1, 92, 93, 94, 95, 96, 97, 98, 99, -1, -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119 }; /* -*-C-*- Note some compilers choke on comments on `#line' lines. */ #line 3 "/usr/share/bison/bison.simple" /* Skeleton output parser for bison, Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software Foundation, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* As a special exception, when this file is copied by Bison into a Bison output file, you may use that output file without restriction. This special exception was added by the Free Software Foundation in version 1.24 of Bison. */ /* This is the parser code that is written into each bison parser when the %semantic_parser declaration is not specified in the grammar. It was written by Richard Stallman by simplifying the hairy parser used when %semantic_parser is specified. */ /* All symbols defined below should begin with yy or YY, to avoid infringing on user name space. This should be done even for local variables, as they might otherwise be expanded by user macros. There are some unavoidable exceptions within include files to define necessary library symbols; they are noted "INFRINGES ON USER NAME SPACE" below. */ #if ! defined (yyoverflow) || defined (YYERROR_VERBOSE) /* The parser invokes alloca or malloc; define the necessary symbols. */ # if YYSTACK_USE_ALLOCA # define YYSTACK_ALLOC alloca # else # ifndef YYSTACK_USE_ALLOCA # if defined (alloca) || defined (_ALLOCA_H) # define YYSTACK_ALLOC alloca # else # ifdef __GNUC__ # define YYSTACK_ALLOC __builtin_alloca # endif # endif # endif # endif # ifdef YYSTACK_ALLOC /* Pacify GCC's `empty if-body' warning. */ # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) # else # if defined (__STDC__) || defined (__cplusplus) # include /* INFRINGES ON USER NAME SPACE */ # define YYSIZE_T size_t # endif # define YYSTACK_ALLOC malloc # define YYSTACK_FREE free # endif #endif /* ! defined (yyoverflow) || defined (YYERROR_VERBOSE) */ #if (! defined (yyoverflow) \ && (! defined (__cplusplus) \ || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) /* A type that is properly aligned for any stack member. */ union yyalloc { short yyss; YYSTYPE yyvs; # if YYLSP_NEEDED YYLTYPE yyls; # endif }; /* The size of the maximum gap between one aligned stack and the next. */ # define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1) /* The size of an array large to enough to hold all stacks, each with N elements. */ # if YYLSP_NEEDED # define YYSTACK_BYTES(N) \ ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \ + 2 * YYSTACK_GAP_MAX) # else # define YYSTACK_BYTES(N) \ ((N) * (sizeof (short) + sizeof (YYSTYPE)) \ + YYSTACK_GAP_MAX) # endif /* Copy COUNT objects from FROM to TO. The source and destination do not overlap. */ # ifndef YYCOPY # if 1 < __GNUC__ # define YYCOPY(To, From, Count) \ __builtin_memcpy (To, From, (Count) * sizeof (*(From))) # else # define YYCOPY(To, From, Count) \ do \ { \ register YYSIZE_T yyi; \ for (yyi = 0; yyi < (Count); yyi++) \ (To)[yyi] = (From)[yyi]; \ } \ while (0) # endif # endif /* Relocate STACK from its old location to the new one. The local variables YYSIZE and YYSTACKSIZE give the old and new number of elements in the stack, and YYPTR gives the new location of the stack. Advance YYPTR to a properly aligned location for the next stack. */ # define YYSTACK_RELOCATE(Stack) \ do \ { \ YYSIZE_T yynewbytes; \ YYCOPY (&yyptr->Stack, Stack, yysize); \ Stack = &yyptr->Stack; \ yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX; \ yyptr += yynewbytes / sizeof (*yyptr); \ } \ while (0) #endif #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) # define YYSIZE_T __SIZE_TYPE__ #endif #if ! defined (YYSIZE_T) && defined (size_t) # define YYSIZE_T size_t #endif #if ! defined (YYSIZE_T) # if defined (__STDC__) || defined (__cplusplus) # include /* INFRINGES ON USER NAME SPACE */ # define YYSIZE_T size_t # endif #endif #if ! defined (YYSIZE_T) # define YYSIZE_T unsigned int #endif #define yyerrok (yyerrstatus = 0) #define yyclearin (yychar = YYEMPTY) #define YYEMPTY -2 #define YYEOF 0 #define YYACCEPT goto yyacceptlab #define YYABORT goto yyabortlab #define YYERROR goto yyerrlab1 /* Like YYERROR except do call yyerror. This remains here temporarily to ease the transition to the new meaning of YYERROR, for GCC. Once GCC version 2 has supplanted version 1, this can go. */ #define YYFAIL goto yyerrlab #define YYRECOVERING() (!!yyerrstatus) #define YYBACKUP(Token, Value) \ do \ if (yychar == YYEMPTY && yylen == 1) \ { \ yychar = (Token); \ yylval = (Value); \ yychar1 = YYTRANSLATE (yychar); \ YYPOPSTACK; \ goto yybackup; \ } \ else \ { \ yyerror ("syntax error: cannot back up"); \ YYERROR; \ } \ while (0) #define YYTERROR 1 #define YYERRCODE 256 /* YYLLOC_DEFAULT -- Compute the default location (before the actions are run). When YYLLOC_DEFAULT is run, CURRENT is set the location of the first token. By default, to implement support for ranges, extend its range to the last symbol. */ #ifndef YYLLOC_DEFAULT # define YYLLOC_DEFAULT(Current, Rhs, N) \ Current.last_line = Rhs[N].last_line; \ Current.last_column = Rhs[N].last_column; #endif /* YYLEX -- calling `yylex' with the right arguments. */ #if YYPURE # if YYLSP_NEEDED # ifdef YYLEX_PARAM # define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM) # else # define YYLEX yylex (&yylval, &yylloc) # endif # else /* !YYLSP_NEEDED */ # ifdef YYLEX_PARAM # define YYLEX yylex (&yylval, YYLEX_PARAM) # else # define YYLEX yylex (&yylval) # endif # endif /* !YYLSP_NEEDED */ #else /* !YYPURE */ # define YYLEX yylex () #endif /* !YYPURE */ /* Enable debugging if requested. */ #if YYDEBUG # ifndef YYFPRINTF # include /* INFRINGES ON USER NAME SPACE */ # define YYFPRINTF fprintf # endif # define YYDPRINTF(Args) \ do { \ if (yydebug) \ YYFPRINTF Args; \ } while (0) /* Nonzero means print parse trace. It is left uninitialized so that multiple parsers can coexist. */ int yydebug; #else /* !YYDEBUG */ # define YYDPRINTF(Args) #endif /* !YYDEBUG */ /* YYINITDEPTH -- initial size of the parser's stacks. */ #ifndef YYINITDEPTH # define YYINITDEPTH 200 #endif /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only if the built-in stack extension method is used). Do not make this value too large; the results are undefined if SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH) evaluated with infinite-precision integer arithmetic. */ #if YYMAXDEPTH == 0 # undef YYMAXDEPTH #endif #ifndef YYMAXDEPTH # define YYMAXDEPTH 10000 #endif #ifdef YYERROR_VERBOSE # ifndef yystrlen # if defined (__GLIBC__) && defined (_STRING_H) # define yystrlen strlen # else /* Return the length of YYSTR. */ static YYSIZE_T # if defined (__STDC__) || defined (__cplusplus) yystrlen (const char *yystr) # else yystrlen (yystr) const char *yystr; # endif { register const char *yys = yystr; while (*yys++ != '\0') continue; return yys - yystr - 1; } # endif # endif # ifndef yystpcpy # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE) # define yystpcpy stpcpy # else /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in YYDEST. */ static char * # if defined (__STDC__) || defined (__cplusplus) yystpcpy (char *yydest, const char *yysrc) # else yystpcpy (yydest, yysrc) char *yydest; const char *yysrc; # endif { register char *yyd = yydest; register const char *yys = yysrc; while ((*yyd++ = *yys++) != '\0') continue; return yyd - 1; } # endif # endif #endif #line 315 "/usr/share/bison/bison.simple" /* The user can define YYPARSE_PARAM as the name of an argument to be passed into yyparse. The argument should have type void *. It should actually point to an object. Grammar actions can access the variable by casting it to the proper pointer type. */ #ifdef YYPARSE_PARAM # if defined (__STDC__) || defined (__cplusplus) # define YYPARSE_PARAM_ARG void *YYPARSE_PARAM # define YYPARSE_PARAM_DECL # else # define YYPARSE_PARAM_ARG YYPARSE_PARAM # define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; # endif #else /* !YYPARSE_PARAM */ # define YYPARSE_PARAM_ARG # define YYPARSE_PARAM_DECL #endif /* !YYPARSE_PARAM */ /* Prevent warning if -Wstrict-prototypes. */ #ifdef __GNUC__ # ifdef YYPARSE_PARAM int yyparse (void *); # else int yyparse (void); # endif #endif /* YY_DECL_VARIABLES -- depending whether we use a pure parser, variables are global, or local to YYPARSE. */ #define YY_DECL_NON_LSP_VARIABLES \ /* The lookahead symbol. */ \ int yychar; \ \ /* The semantic value of the lookahead symbol. */ \ YYSTYPE yylval; \ \ /* Number of parse errors so far. */ \ int yynerrs; #if YYLSP_NEEDED # define YY_DECL_VARIABLES \ YY_DECL_NON_LSP_VARIABLES \ \ /* Location data for the lookahead symbol. */ \ YYLTYPE yylloc; #else # define YY_DECL_VARIABLES \ YY_DECL_NON_LSP_VARIABLES #endif /* If nonreentrant, generate the variables here. */ #if !YYPURE YY_DECL_VARIABLES #endif /* !YYPURE */ int yyparse (YYPARSE_PARAM_ARG) YYPARSE_PARAM_DECL { /* If reentrant, generate the variables here. */ #if YYPURE YY_DECL_VARIABLES #endif /* !YYPURE */ register int yystate; register int yyn; int yyresult; /* Number of tokens to shift before error messages enabled. */ int yyerrstatus; /* Lookahead token as an internal (translated) token number. */ int yychar1 = 0; /* Three stacks and their tools: `yyss': related to states, `yyvs': related to semantic values, `yyls': related to locations. Refer to the stacks thru separate pointers, to allow yyoverflow to reallocate them elsewhere. */ /* The state stack. */ short yyssa[YYINITDEPTH]; short *yyss = yyssa; register short *yyssp; /* The semantic value stack. */ YYSTYPE yyvsa[YYINITDEPTH]; YYSTYPE *yyvs = yyvsa; register YYSTYPE *yyvsp; #if YYLSP_NEEDED /* The location stack. */ YYLTYPE yylsa[YYINITDEPTH]; YYLTYPE *yyls = yylsa; YYLTYPE *yylsp; #endif #if YYLSP_NEEDED # define YYPOPSTACK (yyvsp--, yyssp--, yylsp--) #else # define YYPOPSTACK (yyvsp--, yyssp--) #endif YYSIZE_T yystacksize = YYINITDEPTH; /* The variables used to return semantic value and location from the action routines. */ YYSTYPE yyval; #if YYLSP_NEEDED YYLTYPE yyloc; #endif /* When reducing, the number of symbols on the RHS of the reduced rule. */ int yylen; YYDPRINTF ((stderr, "Starting parse\n")); yystate = 0; yyerrstatus = 0; yynerrs = 0; yychar = YYEMPTY; /* Cause a token to be read. */ /* Initialize stack pointers. Waste one element of value and location stack so that they stay on the same level as the state stack. The wasted elements are never initialized. */ yyssp = yyss; yyvsp = yyvs; #if YYLSP_NEEDED yylsp = yyls; #endif goto yysetstate; /*------------------------------------------------------------. | yynewstate -- Push a new state, which is found in yystate. | `------------------------------------------------------------*/ yynewstate: /* In all cases, when you get here, the value and location stacks have just been pushed. so pushing a state here evens the stacks. */ yyssp++; yysetstate: *yyssp = yystate; if (yyssp >= yyss + yystacksize - 1) { /* Get the current used size of the three stacks, in elements. */ YYSIZE_T yysize = yyssp - yyss + 1; #ifdef yyoverflow { /* Give user a chance to reallocate the stack. Use copies of these so that the &'s don't force the real ones into memory. */ YYSTYPE *yyvs1 = yyvs; short *yyss1 = yyss; /* Each stack pointer address is followed by the size of the data in use in that stack, in bytes. */ # if YYLSP_NEEDED YYLTYPE *yyls1 = yyls; /* This used to be a conditional around just the two extra args, but that might be undefined if yyoverflow is a macro. */ yyoverflow ("parser stack overflow", &yyss1, yysize * sizeof (*yyssp), &yyvs1, yysize * sizeof (*yyvsp), &yyls1, yysize * sizeof (*yylsp), &yystacksize); yyls = yyls1; # else yyoverflow ("parser stack overflow", &yyss1, yysize * sizeof (*yyssp), &yyvs1, yysize * sizeof (*yyvsp), &yystacksize); # endif yyss = yyss1; yyvs = yyvs1; } #else /* no yyoverflow */ # ifndef YYSTACK_RELOCATE goto yyoverflowlab; # else /* Extend the stack our own way. */ if (yystacksize >= YYMAXDEPTH) goto yyoverflowlab; yystacksize *= 2; if (yystacksize > YYMAXDEPTH) yystacksize = YYMAXDEPTH; { short *yyss1 = yyss; union yyalloc *yyptr = (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); if (! yyptr) goto yyoverflowlab; YYSTACK_RELOCATE (yyss); YYSTACK_RELOCATE (yyvs); # if YYLSP_NEEDED YYSTACK_RELOCATE (yyls); # endif # undef YYSTACK_RELOCATE if (yyss1 != yyssa) YYSTACK_FREE (yyss1); } # endif #endif /* no yyoverflow */ yyssp = yyss + yysize - 1; yyvsp = yyvs + yysize - 1; #if YYLSP_NEEDED yylsp = yyls + yysize - 1; #endif YYDPRINTF ((stderr, "Stack size increased to %lu\n", (unsigned long int) yystacksize)); if (yyssp >= yyss + yystacksize - 1) YYABORT; } YYDPRINTF ((stderr, "Entering state %d\n", yystate)); goto yybackup; /*-----------. | yybackup. | `-----------*/ yybackup: /* Do appropriate processing given the current state. */ /* Read a lookahead token if we need one and don't already have one. */ /* yyresume: */ /* First try to decide what to do without reference to lookahead token. */ yyn = yypact[yystate]; if (yyn == YYFLAG) goto yydefault; /* Not known => get a lookahead token if don't already have one. */ /* yychar is either YYEMPTY or YYEOF or a valid token in external form. */ if (yychar == YYEMPTY) { YYDPRINTF ((stderr, "Reading a token: ")); yychar = YYLEX; } /* Convert token to internal form (in yychar1) for indexing tables with */ if (yychar <= 0) /* This means end of input. */ { yychar1 = 0; yychar = YYEOF; /* Don't call YYLEX any more */ YYDPRINTF ((stderr, "Now at end of input.\n")); } else { yychar1 = YYTRANSLATE (yychar); #if YYDEBUG /* We have to keep this `#if YYDEBUG', since we use variables which are defined only if `YYDEBUG' is set. */ if (yydebug) { YYFPRINTF (stderr, "Next token is %d (%s", yychar, yytname[yychar1]); /* Give the individual parser a way to print the precise meaning of a token, for further debugging info. */ # ifdef YYPRINT YYPRINT (stderr, yychar, yylval); # endif YYFPRINTF (stderr, ")\n"); } #endif } yyn += yychar1; if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) goto yydefault; yyn = yytable[yyn]; /* yyn is what to do for this token type in this state. Negative => reduce, -yyn is rule number. Positive => shift, yyn is new state. New state is final state => don't bother to shift, just return success. 0, or most negative number => error. */ if (yyn < 0) { if (yyn == YYFLAG) goto yyerrlab; yyn = -yyn; goto yyreduce; } else if (yyn == 0) goto yyerrlab; if (yyn == YYFINAL) YYACCEPT; /* Shift the lookahead token. */ YYDPRINTF ((stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1])); /* Discard the token being shifted unless it is eof. */ if (yychar != YYEOF) yychar = YYEMPTY; *++yyvsp = yylval; #if YYLSP_NEEDED *++yylsp = yylloc; #endif /* Count tokens shifted since error; after three, turn off error status. */ if (yyerrstatus) yyerrstatus--; yystate = yyn; goto yynewstate; /*-----------------------------------------------------------. | yydefault -- do the default action for the current state. | `-----------------------------------------------------------*/ yydefault: yyn = yydefact[yystate]; if (yyn == 0) goto yyerrlab; goto yyreduce; /*-----------------------------. | yyreduce -- Do a reduction. | `-----------------------------*/ yyreduce: /* yyn is the number of a rule to reduce with. */ yylen = yyr2[yyn]; /* If YYLEN is nonzero, implement the default value of the action: `$$ = $1'. Otherwise, the following line sets YYVAL to the semantic value of the lookahead token. This behavior is undocumented and Bison users should not rely upon it. Assigning to YYVAL unconditionally makes the parser a bit smaller, and it avoids a GCC warning that YYVAL may be used uninitialized. */ yyval = yyvsp[1-yylen]; #if YYLSP_NEEDED /* Similarly for the default location. Let the user run additional commands if for instance locations are ranges. */ yyloc = yylsp[1-yylen]; YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen); #endif #if YYDEBUG /* We have to keep this `#if YYDEBUG', since we use variables which are defined only if `YYDEBUG' is set. */ if (yydebug) { int yyi; YYFPRINTF (stderr, "Reducing via rule %d (line %d), ", yyn, yyrline[yyn]); /* Print the symbols being reduced, and their result. */ for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++) YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]); YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]); } #endif switch (yyn) { case 1: #line 309 "parser.yy" { compileAST (yyvsp[0].CompileUnit); } break; case 2: #line 316 "parser.yy" { yyval.Tree = new PrimitiveLitNode (intLiteral(*yyvsp[0].Terminal.val), yyvsp[0].Terminal.posn); } break; case 3: #line 318 "parser.yy" { yyval.Tree = new PrimitiveLitNode (longLiteral(*yyvsp[0].Terminal.val), yyvsp[0].Terminal.posn); } break; case 4: #line 320 "parser.yy" { yyval.Tree = new PrimitiveLitNode (floatLiteral(*yyvsp[0].Terminal.val), yyvsp[0].Terminal.posn); } break; case 5: #line 322 "parser.yy" { yyval.Tree = new PrimitiveLitNode (doubleLiteral(*yyvsp[0].Terminal.val), yyvsp[0].Terminal.posn); } break; case 6: #line 324 "parser.yy" { yyval.Tree = new PrimitiveLitNode (Literal(true), yyvsp[0].SimpTerminal.posn); } break; case 7: #line 326 "parser.yy" { yyval.Tree = new PrimitiveLitNode (Literal(false), yyvsp[0].SimpTerminal.posn); } break; case 8: #line 328 "parser.yy" { yyval.Tree = new PrimitiveLitNode (Literal(yyvsp[0].CharTerminal.val), yyvsp[0].CharTerminal.posn); } break; case 9: #line 330 "parser.yy" { yyval.Tree = new StringLitNode (*yyvsp[0].StrTerminal.val, yyvsp[0].StrTerminal.posn); } break; case 10: #line 337 "parser.yy" { yyval.Type = yyvsp[0].Tree->asType(); } break; case 13: #line 346 "parser.yy" { yyval.Type = yyvsp[-1].Type; yyvsp[-1].Type->modifiers(yyvsp[0].Modifiers); } break; case 14: #line 348 "parser.yy" { yyvsp[-2].Type->modifiers(yyvsp[-1].Modifiers); yyval.Type = arraySpecifiers2Type(yyvsp[0].TreeList, yyvsp[-2].Type); } break; case 15: #line 353 "parser.yy" { yyval.Type = yyvsp[-1].Type; yyval.Type->modifiers(yyvsp[0].Modifiers); } break; case 20: #line 365 "parser.yy" { yyval.Type = new TypeNameNode (yyvsp[0].Tree); } break; case 24: #line 375 "parser.yy" { yyval.TreeList = cons(yyvsp[0].Tree); } break; case 25: #line 376 "parser.yy" { yyval.TreeList = cons(yyvsp[-1].Tree, yyvsp[0].TreeList); } break; case 26: #line 380 "parser.yy" { yyval.Tree = new EmptyArrayNode(yyvsp[0].Modifiers, yyvsp[-2].SimpTerminal.posn); } break; case 27: #line 382 "parser.yy" { yyval.Tree = new ExpressionArrayNode(yyvsp[-2].Tree, yyvsp[0].Modifiers); } break; case 28: #line 384 "parser.yy" { if (*yyvsp[-2].Terminal.val != "d") { Error(yyvsp[-2].Terminal.posn) << "Unexpected identifier '" << *yyvsp[-2].Terminal.val << "'" << endl; yyval.Tree = new ExpressionArrayNode(yyvsp[-3].Tree, yyvsp[0].Modifiers); } else yyval.Tree = new TitaniumArrayNode(yyvsp[-3].Tree, yyvsp[0].Modifiers); } break; case 29: #line 396 "parser.yy" { yyval.Modifiers = (Common::Modifiers)0; } break; case 30: #line 398 "parser.yy" { yyval.Modifiers = (Common::Modifiers) (yyvsp[-1].Modifiers | yyvsp[0].Modifiers); if ((yyvsp[-1].Modifiers & yyvsp[0].Modifiers) != 0) Error (lexerPosition()) << "repeated modifier" << endl; } break; case 31: #line 406 "parser.yy" { yyval.Modifiers = TreeNode::Single; } break; case 32: #line 407 "parser.yy" { yyval.Modifiers = TreeNode::Local; } break; case 33: #line 408 "parser.yy" { yyval.Modifiers = TreeNode::NonsharedQ; } break; case 34: #line 409 "parser.yy" { yyval.Modifiers = TreeNode::PolysharedQ; } break; case 35: #line 414 "parser.yy" { yyval.Type = new BoolTypeNode (yyvsp[0].SimpTerminal.posn); } break; case 36: #line 416 "parser.yy" { yyval.Type = new CharTypeNode (yyvsp[0].SimpTerminal.posn); } break; case 37: #line 418 "parser.yy" { yyval.Type = new ByteTypeNode (yyvsp[0].SimpTerminal.posn); } break; case 38: #line 420 "parser.yy" { yyval.Type = new ShortTypeNode (yyvsp[0].SimpTerminal.posn); } break; case 39: #line 422 "parser.yy" { yyval.Type = new IntTypeNode (yyvsp[0].SimpTerminal.posn); } break; case 40: #line 424 "parser.yy" { yyval.Type = new FloatTypeNode (yyvsp[0].SimpTerminal.posn); } break; case 41: #line 426 "parser.yy" { yyval.Type = new LongTypeNode (yyvsp[0].SimpTerminal.posn); } break; case 42: #line 428 "parser.yy" { yyval.Type = new DoubleTypeNode (yyvsp[0].SimpTerminal.posn); } break; case 43: #line 435 "parser.yy" { yyval.Type = new PointTypeNode(yyvsp[-1].Tree); } break; case 44: #line 437 "parser.yy" { yyval.Type = new RectDomainTypeNode(yyvsp[-1].Tree); } break; case 45: #line 439 "parser.yy" { yyval.Type = new DomainTypeNode(yyvsp[-1].Tree); } break; case 46: #line 449 "parser.yy" { yyval.CompileUnit = new CompileUnitNode (NULL, yyvsp[-2].Tree, yyvsp[-1].TreeList, new TreeListNode(yyvsp[0].TreeList), NULL); } break; case 47: #line 454 "parser.yy" { yyval.Tree = yyvsp[-1].Tree; } break; case 48: #line 456 "parser.yy" { yyval.Tree = TreeNode::omitted; } break; case 49: #line 461 "parser.yy" { yyval.TreeList = NULL; } break; case 50: #line 463 "parser.yy" { yyval.TreeList = extend (yyvsp[-1].TreeList, cons(yyvsp[0].Tree)); } break; case 51: #line 469 "parser.yy" { yyval.TreeList = NULL; } break; case 52: #line 471 "parser.yy" { if (yyvsp[-1].Tree->absent()) yyval.TreeList = yyvsp[0].TreeList; else yyval.TreeList = cons (static_cast(yyvsp[-1].Tree), yyvsp[0].TreeList); } break; case 53: #line 478 "parser.yy" { yyval.TreeList = yyvsp[0].TreeList; } break; case 54: #line 483 "parser.yy" { yyval.Tree = yyvsp[0].TypeDecl; } break; case 55: #line 485 "parser.yy" { yyval.Tree = yyvsp[0].Tree; } break; case 56: #line 490 "parser.yy" { yyval.TypeDecl = yyvsp[0].TypeDecl; } break; case 57: #line 492 "parser.yy" { yyval.TypeDecl = yyvsp[0].TypeDecl; } break; case 60: #line 505 "parser.yy" { yyval.Tree = new ImportNode (yyvsp[-1].Tree); } break; case 61: #line 514 "parser.yy" { yyval.Tree = new ImportOnDemandNode (yyvsp[-3].Tree); } break; case 62: #line 526 "parser.yy" { yyval.TypeDecl = new ClassDeclNode (yyvsp[-5].Modifiers, yyvsp[-3].Tree, yyvsp[-2].Tree, yyvsp[-1].TypeList, yyvsp[0].TreeList, yyvsp[-4].SimpTerminal.posn); } break; case 64: #line 535 "parser.yy" { yyval.Modifiers = (Common::Modifiers) 0; } break; case 66: #line 541 "parser.yy" { yyval.Modifiers = (Common::Modifiers) (yyvsp[-1].Modifiers | yyvsp[0].Modifiers); if ((yyvsp[-1].Modifiers & yyvsp[0].Modifiers) != 0) Error (lexerPosition()) << "repeated modifier" << endl; } break; case 67: #line 550 "parser.yy" { yyval.Modifiers = TreeNode::Abstract; } break; case 68: #line 552 "parser.yy" { yyval.Modifiers = TreeNode::Final; } break; case 69: #line 554 "parser.yy" { yyval.Modifiers = TreeNode::Public; } break; case 70: #line 556 "parser.yy" { yyval.Modifiers = TreeNode::Immutable; } break; case 71: #line 564 "parser.yy" { yyval.Tree = yyvsp[0].Type; } break; case 72: #line 566 "parser.yy" { yyval.Tree = TreeNode::omitted; } break; case 73: #line 574 "parser.yy" { yyval.TypeList = yyvsp[0].TypeList; } break; case 74: #line 576 "parser.yy" { yyval.TypeList = NULL; } break; case 75: #line 585 "parser.yy" { yyval.TreeList = cons (TreeNode::omitted, yyvsp[-1].TreeList); } break; case 77: #line 591 "parser.yy" { yyval.TreeList = NULL; } break; case 79: #line 597 "parser.yy" { yyval.TreeList = extend (yyvsp[-1].TreeList, yyvsp[0].TreeList); } break; case 81: #line 606 "parser.yy" { yyval.TreeList = cons (yyvsp[0].Tree); } break; case 82: #line 608 "parser.yy" { yyval.TreeList = cons (yyvsp[0].Tree); } break; case 83: #line 610 "parser.yy" { yyval.TreeList = cons (yyvsp[0].Tree); } break; case 84: #line 618 "parser.yy" { checkFieldModifiers (yyvsp[-3].Modifiers, yyvsp[-2].Type->position()); yyval.TreeList = NULL; foreach (decl, llist, *yyvsp[-1].DeclaratorList) { yyval.TreeList = cons (static_cast(new FieldDeclNode(makeArrayType(yyvsp[-2].Type, (*decl).dims), (*decl).name, yyvsp[-3].Modifiers, (*decl).initExpr)), yyval.TreeList); } free_all (yyvsp[-1].DeclaratorList); } break; case 86: #line 642 "parser.yy" { yyval.Modifiers = (Common::Modifiers) 0; } break; case 88: #line 648 "parser.yy" { yyval.Modifiers = (Common::Modifiers) (yyvsp[-1].Modifiers | yyvsp[0].Modifiers); if ((yyvsp[-1].Modifiers & yyvsp[0].Modifiers) != 0) Error (lexerPosition()) << "repeated modifier" << endl; } break; case 89: #line 657 "parser.yy" { yyval.Modifiers = TreeNode::Public; } break; case 90: #line 659 "parser.yy" { yyval.Modifiers = TreeNode::Protected; } break; case 91: #line 661 "parser.yy" { yyval.Modifiers = TreeNode::Private; } break; case 92: #line 664 "parser.yy" { yyval.Modifiers = TreeNode::Static; } break; case 93: #line 666 "parser.yy" { yyval.Modifiers = TreeNode::Final; } break; case 94: #line 668 "parser.yy" { yyval.Modifiers = TreeNode::Sglobal; } break; case 95: #line 670 "parser.yy" { yyval.Modifiers = TreeNode::Sglobal; } break; case 96: #line 673 "parser.yy" { yyval.Modifiers = TreeNode::Abstract; } break; case 97: #line 675 "parser.yy" { yyval.Modifiers = TreeNode::Native; } break; case 98: #line 677 "parser.yy" { yyval.Modifiers = TreeNode::Synchronized; } break; case 99: #line 680 "parser.yy" { yyval.Modifiers = TreeNode::Transient; } break; case 100: #line 682 "parser.yy" { yyval.Modifiers = TreeNode::Volatile; } break; case 101: #line 684 "parser.yy" { yyval.Modifiers = TreeNode::Local; } break; case 102: #line 686 "parser.yy" { yyval.Modifiers = TreeNode::NonsharedQ; } break; case 103: #line 688 "parser.yy" { yyval.Modifiers = TreeNode::PolysharedQ; } break; case 104: #line 690 "parser.yy" { yyval.Modifiers = TreeNode::Inline; } break; case 106: #line 700 "parser.yy" { yyval.DeclaratorList = yyvsp[0].DeclaratorList; yyvsp[0].DeclaratorList->tail() = yyvsp[-2].DeclaratorList; } break; case 107: #line 705 "parser.yy" { yyval.DeclaratorList = cons(DeclaratorTuple(yyvsp[0].Int, yyvsp[-1].Tree, TreeNode::omitted)); } break; case 108: #line 707 "parser.yy" { yyval.DeclaratorList = cons(DeclaratorTuple(yyvsp[-2].Int, yyvsp[-3].Tree, yyvsp[0].Tree)); } break; case 111: #line 723 "parser.yy" { checkMethodModifiers(yyvsp[-9].Modifiers, yyvsp[-7].Tree->position()); TreeNode *body = addSynchronized(yyvsp[-9].Modifiers, yyvsp[0].Tree); yyval.Tree = new MethodDeclNode(yyvsp[-9].Modifiers, yyvsp[-5].TreeList, makeArrayType(yyvsp[-8].Type, yyvsp[-3].Int), yyvsp[-7].Tree, yyvsp[-2].TypeList, yyvsp[-1].TreeList, body); } break; case 112: #line 729 "parser.yy" { checkMethodModifiers(yyvsp[-9].Modifiers, yyvsp[-7].Tree->position()); TreeNode *body = addSynchronized(yyvsp[-9].Modifiers, yyvsp[0].Tree); yyval.Tree = new MethodDeclNode(yyvsp[-9].Modifiers, yyvsp[-5].TreeList, makeArrayType(yyvsp[-8].Type, yyvsp[-3].Int), yyvsp[-7].Tree, yyvsp[-2].TypeList, yyvsp[-1].TreeList, body); if (yyvsp[-3].Int) Error(yyvsp[-7].Tree->position()) << "cannot return array of void" << endl; } break; case 115: #line 743 "parser.yy" { yyval.Type = new VoidTypeNode (yyvsp[0].SimpTerminal.posn); } break; case 116: #line 747 "parser.yy" { yyval.TreeList = NULL; } break; case 117: #line 748 "parser.yy" { yyval.TreeList = cons(yyvsp[-1].Tree, yyvsp[0].TreeList); } break; case 118: #line 753 "parser.yy" { yyval.Tree = new OverlapNode(yyvsp[-3].Tree, yyvsp[-1].Tree, yyvsp[-5].SimpTerminal.posn); } break; case 120: #line 764 "parser.yy" { yyval.TreeList = NULL; } break; case 121: #line 769 "parser.yy" { yyval.TreeList = cons (yyvsp[0].Tree); } break; case 122: #line 771 "parser.yy" { yyval.TreeList = cons (yyvsp[-2].Tree, yyvsp[0].TreeList); } break; case 123: #line 776 "parser.yy" { yyval.Tree = new ParameterNode (yyvsp[-3].Bool, makeArrayType (yyvsp[-2].Type, yyvsp[0].Int), yyvsp[-1].Tree); } break; case 124: #line 780 "parser.yy" { yyval.Bool = true; } break; case 125: #line 781 "parser.yy" { yyval.Bool = false; } break; case 127: #line 790 "parser.yy" { yyval.TypeList = NULL; } break; case 128: #line 795 "parser.yy" { yyval.TypeList = yyvsp[0].TypeList; } break; case 129: #line 800 "parser.yy" { yyval.TypeList = cons (yyvsp[0].Type); } break; case 130: #line 802 "parser.yy" { yyval.TypeList = cons (yyvsp[-2].Type, yyvsp[0].TypeList); } break; case 132: #line 811 "parser.yy" { yyval.Tree = TreeNode::omitted; } break; case 133: #line 820 "parser.yy" { checkConstructorModifiers (yyvsp[-9].Modifiers, yyvsp[-8].Tree->position()); yyval.Tree = new ConstructorDeclNode (yyvsp[-9].Modifiers, yyvsp[-6].TreeList, yyvsp[-8].Tree, yyvsp[-4].TypeList, yyvsp[-2].Tree, new BlockNode (yyvsp[-1].TreeList, yyvsp[0].SimpTerminal.posn)); } break; case 134: #line 826 "parser.yy" { checkConstructorModifiers (yyvsp[-8].Modifiers, yyvsp[-7].Tree->position ()); yyval.Tree = new ConstructorDeclNode (yyvsp[-8].Modifiers, yyvsp[-5].TreeList, yyvsp[-7].Tree, yyvsp[-3].TypeList, new SuperConstructorCallNode (NULL, NULL, yyvsp[-7].Tree->position()), new BlockNode (yyvsp[-1].TreeList, yyvsp[0].SimpTerminal.posn)); } break; case 137: #line 845 "parser.yy" { yyval.Tree = new ThisConstructorCallNode (yyvsp[-2].TreeList, NULL, false, yyvsp[-4].SimpTerminal.posn); } break; case 138: #line 850 "parser.yy" { yyval.Tree = new SuperConstructorCallNode (yyvsp[-2].TreeList, NULL, yyvsp[-4].SimpTerminal.posn); } break; case 139: #line 858 "parser.yy" { yyval.Tree = new StaticInitNode (yyvsp[0].Tree); } break; case 140: #line 867 "parser.yy" { checkInterfaceModifiers(yyvsp[-4].Modifiers, yyvsp[-3].SimpTerminal.posn); yyval.TypeDecl = new InterfaceDeclNode (yyvsp[-4].Modifiers, yyvsp[-2].Tree, yyvsp[-1].TypeList, yyvsp[0].TreeList); } break; case 142: #line 877 "parser.yy" { yyval.TypeList = NULL; } break; case 143: #line 882 "parser.yy" { yyval.TypeList = yyvsp[0].TypeList; } break; case 144: #line 889 "parser.yy" { yyval.TreeList = yyvsp[-1].TreeList; } break; case 145: #line 894 "parser.yy" { yyval.TreeList = NULL; } break; case 146: #line 896 "parser.yy" { yyval.TreeList = extend (yyvsp[-1].TreeList, yyvsp[0].TreeList); } break; case 148: #line 902 "parser.yy" { yyval.TreeList = cons (yyvsp[0].Tree); } break; case 149: #line 907 "parser.yy" { checkConstantFieldModifiers (yyvsp[-3].Modifiers, yyvsp[-2].Type->position()); yyval.TreeList = NULL; foreach (decl, llist, *yyvsp[-1].DeclaratorList) { yyval.TreeList = cons (static_cast(new FieldDeclNode (makeArrayType (yyvsp[-2].Type, (*decl).dims), (*decl).name, yyvsp[-3].Modifiers, (*decl).initExpr)), yyval.TreeList); } free_all (yyvsp[-1].DeclaratorList); } break; case 150: #line 924 "parser.yy" { checkMethodSignatureModifiers (yyvsp[-8].Modifiers, yyvsp[-7].Type->position()); yyval.Tree = new MethodSignatureNode (yyvsp[-8].Modifiers, yyvsp[-4].TreeList, makeArrayType (yyvsp[-7].Type, yyvsp[-2].Int), yyvsp[-6].Tree, yyvsp[-1].TypeList); } break; case 151: #line 930 "parser.yy" { checkMethodSignatureModifiers (yyvsp[-8].Modifiers, yyvsp[-7].Type->position()); yyval.Tree = new MethodSignatureNode (yyvsp[-8].Modifiers, yyvsp[-4].TreeList, makeArrayType (yyvsp[-7].Type, yyvsp[-2].Int), yyvsp[-6].Tree, yyvsp[-1].TypeList); } break; case 152: #line 941 "parser.yy" { yyval.Tree = new TemplateDeclNode( yyvsp[0].TypeDecl, yyvsp[-2].TreeList, 0 ); } break; case 153: #line 946 "parser.yy" { yyval.TreeList = cons( yyvsp[0].Tree ); } break; case 154: #line 948 "parser.yy" { yyval.TreeList = cons( yyvsp[-2].Tree, yyvsp[0].TreeList ); } break; case 155: #line 953 "parser.yy" { yyval.Tree = new TemplateTypeParamNode( yyvsp[0].Tree ); } break; case 156: #line 955 "parser.yy" { yyval.Tree = new TemplateConstParamNode( yyvsp[-1].Type, yyvsp[0].Tree ); } break; case 157: #line 960 "parser.yy" { yyval.Type = new TemplateInstanceTypeNode( yyvsp[-3].Type, yyvsp[-1].TreeList, 0 ); } break; case 158: #line 965 "parser.yy" { yyval.TreeList = cons( yyvsp[0].Tree ); } break; case 159: #line 967 "parser.yy" { yyval.TreeList = cons( yyvsp[-2].Tree, yyvsp[0].TreeList ); } break; case 160: #line 972 "parser.yy" { yyval.Tree = yyvsp[0].Type; } break; case 161: #line 974 "parser.yy" { yyval.Tree = yyvsp[0].Tree; } break; case 162: #line 976 "parser.yy" { yyval.Tree = yyvsp[0].Tree; } break; case 163: #line 985 "parser.yy" { yyval.Tree = new ArrayInitNode (dreverse (yyvsp[-1].TreeList), yyvsp[-2].SimpTerminal.posn); } break; case 164: #line 987 "parser.yy" { yyval.Tree = new ArrayInitNode (dreverse (yyvsp[-2].TreeList), yyvsp[-3].SimpTerminal.posn); } break; case 165: #line 989 "parser.yy" { yyval.Tree = new ArrayInitNode (NULL, yyvsp[-1].SimpTerminal.posn); } break; case 166: #line 996 "parser.yy" { yyval.TreeList = cons (yyvsp[0].Tree); } break; case 167: #line 998 "parser.yy" { yyval.TreeList = cons (yyvsp[0].Tree, yyvsp[-2].TreeList); } break; case 170: #line 1013 "parser.yy" { yyval.Tree = new BlockNode (yyvsp[-1].TreeList, yyvsp[0].SimpTerminal.posn); } break; case 172: #line 1019 "parser.yy" { yyval.TreeList = NULL; } break; case 173: #line 1024 "parser.yy" { yyval.TreeList = yyvsp[0].TreeList; } break; case 174: #line 1026 "parser.yy" { yyval.TreeList = extend (yyvsp[-1].TreeList, yyvsp[0].TreeList); } break; case 175: #line 1031 "parser.yy" { yyval.TreeList = yyvsp[0].TreeList; } break; case 176: #line 1033 "parser.yy" { yyval.TreeList = cons (yyvsp[0].Tree); } break; case 177: #line 1042 "parser.yy" { yyval.TreeList = makeVarDeclNodes(true, yyvsp[-2].Type, yyvsp[-1].DeclaratorList); } break; case 178: #line 1044 "parser.yy" { yyval.TreeList = makeVarDeclNodes(false, yyvsp[-2].Type, yyvsp[-1].DeclaratorList); } break; case 188: #line 1065 "parser.yy" { yyval.Tree = new EmptyStmtNode (yyvsp[0].SimpTerminal.posn); } break; case 189: #line 1073 "parser.yy" { yyval.Tree = new LabeledStmtNode (yyvsp[-2].Tree, yyvsp[0].Tree); } break; case 190: #line 1081 "parser.yy" { yyval.Tree = new ExpressionStmtNode( yyvsp[-1].Tree ); } break; case 191: #line 1086 "parser.yy" { yyval.Tree = yyvsp[0].Tree; } break; case 192: #line 1088 "parser.yy" { yyval.Tree = yyvsp[0].Tree; } break; case 193: #line 1090 "parser.yy" { yyval.Tree = yyvsp[0].Tree; } break; case 194: #line 1092 "parser.yy" { yyval.Tree = yyvsp[0].Tree; } break; case 195: #line 1094 "parser.yy" { yyval.Tree = yyvsp[0].Tree; } break; case 196: #line 1096 "parser.yy" { yyval.Tree = yyvsp[0].Tree; } break; case 197: #line 1098 "parser.yy" { yyval.Tree = yyvsp[0].Tree; } break; case 198: #line 1106 "parser.yy" { yyval.Tree = new IfStmtNode (yyvsp[-2].Tree, yyvsp[0].Tree, TreeNode::omitted); } break; case 199: #line 1108 "parser.yy" { yyval.Tree = new IfStmtNode (yyvsp[-4].Tree, yyvsp[-2].Tree, yyvsp[0].Tree); } break; case 200: #line 1110 "parser.yy" { yyval.Tree = new SwitchNode (yyvsp[-2].Tree, yyvsp[0].TreeList, yyvsp[-4].SimpTerminal.posn); } break; case 201: #line 1115 "parser.yy" { yyval.TreeList = yyvsp[-1].TreeList; } break; case 202: #line 1119 "parser.yy" { yyval.TreeList = NULL; } break; case 203: #line 1121 "parser.yy" { yyval.TreeList = cons (static_cast(new SwitchBranchNode (yyvsp[-2].TreeList, yyvsp[-1].TreeList)), yyvsp[0].TreeList); } break; case 204: #line 1126 "parser.yy" { yyval.TreeList = cons (yyvsp[0].Tree); } break; case 205: #line 1128 "parser.yy" { yyval.TreeList = cons (yyvsp[-1].Tree, yyvsp[0].TreeList); } break; case 206: #line 1133 "parser.yy" { yyval.Tree = new CaseNode (yyvsp[-1].Tree, yyvsp[-2].SimpTerminal.posn); } break; case 207: #line 1135 "parser.yy" { yyval.Tree = new CaseNode (TreeNode::omitted, yyvsp[-1].SimpTerminal.posn); } break; case 208: #line 1143 "parser.yy" { yyval.Tree = new WhileNode (yyvsp[-2].Tree, yyvsp[0].Tree); } break; case 209: #line 1145 "parser.yy" { yyval.Tree = new DoNode (yyvsp[-5].Tree, yyvsp[-2].Tree); } break; case 210: #line 1147 "parser.yy" { yyval.Tree = new ForNode (yyvsp[-5].TreeList, yyvsp[-4].Tree, yyvsp[-2].TreeList, yyvsp[0].Tree); } break; case 212: #line 1153 "parser.yy" { yyval.TreeList = yyvsp[-1].TreeList; } break; case 213: #line 1155 "parser.yy" { yyval.TreeList = yyvsp[0].TreeList; } break; case 215: #line 1161 "parser.yy" { yyval.TreeList = NULL; } break; case 217: #line 1167 "parser.yy" { yyval.TreeList = NULL; } break; case 218: #line 1172 "parser.yy" { yyval.TreeList = cons (static_cast(new ExpressionStmtNode(yyvsp[0].Tree))); } break; case 219: #line 1174 "parser.yy" { yyval.TreeList = cons (static_cast(new ExpressionStmtNode(yyvsp[-2].Tree)), yyvsp[0].TreeList); } break; case 220: #line 1181 "parser.yy" { yyval.Tree = new ForEachStmtNode (yyvsp[-3].TreeList, yyvsp[0].Tree, yyvsp[-1].Bool, yyvsp[-5].SimpTerminal.posn); } break; case 221: #line 1185 "parser.yy" { yyval.Bool = true; } break; case 222: #line 1186 "parser.yy" { yyval.Bool = false; } break; case 223: #line 1191 "parser.yy" { yyval.TreeList = cons(static_cast(new ForEachPairNode(yyvsp[-2].Tree, yyvsp[0].Tree))); } break; case 224: #line 1193 "parser.yy" { yyval.TreeList = cons(static_cast(new ForEachPairNode(yyvsp[-4].Tree, yyvsp[-2].Tree)), yyvsp[0].TreeList); } break; case 225: #line 1197 "parser.yy" { } break; case 226: #line 1199 "parser.yy" { if (*yyvsp[0].Terminal.val != "in") Error(lexerPosition()) << "bad keyword in foreach - expected 'in'" << endl; } break; case 227: #line 1208 "parser.yy" { yyval.Tree = new BreakNode (yyvsp[-1].Tree, NULL, NULL, yyvsp[-2].SimpTerminal.posn); } break; case 228: #line 1210 "parser.yy" { yyval.Tree = new ContinueNode (yyvsp[-1].Tree, NULL, NULL, yyvsp[-2].SimpTerminal.posn); } break; case 229: #line 1212 "parser.yy" { yyval.Tree = new ReturnNode (yyvsp[-1].Tree, NULL, yyvsp[-2].SimpTerminal.posn); } break; case 230: #line 1214 "parser.yy" { yyval.Tree = new ThrowNode (yyvsp[-1].Tree, yyvsp[-2].SimpTerminal.posn); } break; case 232: #line 1221 "parser.yy" { yyval.Tree = TreeNode::omitted; } break; case 233: #line 1229 "parser.yy" { yyval.Tree = new SynchronizedNode (yyvsp[-2].Tree, yyvsp[0].Tree); } break; case 234: #line 1232 "parser.yy" { yyval.Tree = new TryStmtNode (yyvsp[-1].Try, NULL, yyvsp[0].Tree); } break; case 235: #line 1234 "parser.yy" { yyval.Tree = new TryStmtNode (yyvsp[-1].Try, yyvsp[0].CatchList, TreeNode::omitted); } break; case 236: #line 1236 "parser.yy" { yyval.Tree = new TryStmtNode (yyvsp[-2].Try, yyvsp[-1].CatchList, yyvsp[0].Tree); } break; case 237: #line 1241 "parser.yy" { yyval.Try = new TryNode (yyvsp[0].Tree); } break; case 238: #line 1246 "parser.yy" { yyval.CatchList = cons (yyvsp[0].Catch); } break; case 239: #line 1248 "parser.yy" { yyval.CatchList = cons (yyvsp[-1].Catch, yyvsp[0].CatchList); } break; case 240: #line 1253 "parser.yy" { yyval.Catch = new CatchNode (yyvsp[-2].Tree, yyvsp[0].Tree, yyvsp[-4].SimpTerminal.posn); } break; case 241: #line 1258 "parser.yy" { yyval.Tree = new FinallyNode( yyvsp[0].Tree ); } break; case 242: #line 1265 "parser.yy" { yyval.Tree = new PartitionStmtNode(TreeNode::omitted, yyvsp[-1].TreeList, yyvsp[-3].SimpTerminal.posn); } break; case 243: #line 1267 "parser.yy" { yyval.Tree = new PartitionStmtNode(yyvsp[-3].Tree, yyvsp[-1].TreeList, yyvsp[-4].SimpTerminal.posn); } break; case 244: #line 1271 "parser.yy" { yyval.TreeList = NULL; } break; case 245: #line 1273 "parser.yy" { yyval.TreeList = cons(static_cast(new PartitionClauseNode(yyvsp[-3].Tree, yyvsp[-1].Tree)), yyvsp[0].TreeList); } break; case 246: #line 1285 "parser.yy" { yyval.Tree = yyvsp[0].Tree->asExpr(); } break; case 251: #line 1297 "parser.yy" { yyval.Tree = new NullPntrNode (yyvsp[0].SimpTerminal.posn); } break; case 252: #line 1299 "parser.yy" { yyval.Tree = new ThisNode (NULL, Common::None, yyvsp[0].SimpTerminal.posn); } break; case 253: #line 1301 "parser.yy" { yyval.Tree = yyvsp[-1].Tree; } break; case 254: #line 1303 "parser.yy" { yyval.Tree = yyvsp[-1].Tree->asExpr(); } break; case 256: #line 1306 "parser.yy" { yyval.Tree = yyvsp[0].Tree; } break; case 258: #line 1315 "parser.yy" { yyval.Tree = new ArrayNameNode(yyvsp[-1].Tree, yyvsp[0].Modifiers, NULL); } break; case 260: #line 1320 "parser.yy" { yyval.Tree = new ArrayNameNode(yyvsp[-2].Tree, yyvsp[-1].Modifiers, yyvsp[0].TreeList); } break; case 263: #line 1330 "parser.yy" { yyval.Tree = new NameNode (TreeNode::omitted, yyvsp[0].Terminal.val, NULL, yyvsp[0].Terminal.posn); } break; case 264: #line 1336 "parser.yy" { yyval.Tree = new NameNode (yyvsp[-2].Tree, yyvsp[0].Terminal.val, NULL, yyvsp[0].Terminal.posn); } break; case 265: #line 1338 "parser.yy" { yyval.Tree = new NameNode (yyvsp[-2].Tree, yyvsp[0].Tree->ident(), NULL, yyvsp[0].Tree->position()); } break; case 266: #line 1342 "parser.yy" { yyval.Tree = newOperator("!", yyvsp[0].SimpTerminal.posn); } break; case 267: #line 1343 "parser.yy" { yyval.Tree = newOperator("~", yyvsp[0].SimpTerminal.posn); } break; case 268: #line 1344 "parser.yy" { yyval.Tree = newOperator("<", yyvsp[0].SimpTerminal.posn); } break; case 269: #line 1345 "parser.yy" { yyval.Tree = newOperator(">", yyvsp[0].SimpTerminal.posn); } break; case 270: #line 1346 "parser.yy" { yyval.Tree = newOperator("<=", yyvsp[0].SimpTerminal.posn); } break; case 271: #line 1347 "parser.yy" { yyval.Tree = newOperator(">=", yyvsp[0].SimpTerminal.posn); } break; case 272: #line 1348 "parser.yy" { yyval.Tree = newOperator("==", yyvsp[0].SimpTerminal.posn); } break; case 273: #line 1349 "parser.yy" { yyval.Tree = newOperator("!=", yyvsp[0].SimpTerminal.posn); } break; case 274: #line 1350 "parser.yy" { yyval.Tree = newOperator("+", yyvsp[0].SimpTerminal.posn); } break; case 275: #line 1351 "parser.yy" { yyval.Tree = newOperator("-", yyvsp[0].SimpTerminal.posn); } break; case 276: #line 1352 "parser.yy" { yyval.Tree = newOperator("*", yyvsp[0].SimpTerminal.posn); } break; case 277: #line 1353 "parser.yy" { yyval.Tree = newOperator("/", yyvsp[0].SimpTerminal.posn); } break; case 278: #line 1354 "parser.yy" { yyval.Tree = newOperator("&", yyvsp[0].SimpTerminal.posn); } break; case 279: #line 1355 "parser.yy" { yyval.Tree = newOperator("|", yyvsp[0].SimpTerminal.posn); } break; case 280: #line 1356 "parser.yy" { yyval.Tree = newOperator("^", yyvsp[0].SimpTerminal.posn); } break; case 281: #line 1357 "parser.yy" { yyval.Tree = newOperator("%", yyvsp[0].SimpTerminal.posn); } break; case 282: #line 1358 "parser.yy" { yyval.Tree = newOperator("<<", yyvsp[0].SimpTerminal.posn); } break; case 283: #line 1359 "parser.yy" { yyval.Tree = newOperator(">>", yyvsp[0].SimpTerminal.posn); } break; case 284: #line 1360 "parser.yy" { yyval.Tree = newOperator(">>>", yyvsp[0].SimpTerminal.posn); } break; case 285: #line 1361 "parser.yy" { yyval.Tree = newOperator("+=", yyvsp[0].SimpTerminal.posn); } break; case 286: #line 1362 "parser.yy" { yyval.Tree = newOperator("-=", yyvsp[0].SimpTerminal.posn); } break; case 287: #line 1363 "parser.yy" { yyval.Tree = newOperator("*=", yyvsp[0].SimpTerminal.posn); } break; case 288: #line 1364 "parser.yy" { yyval.Tree = newOperator("/=", yyvsp[0].SimpTerminal.posn); } break; case 289: #line 1365 "parser.yy" { yyval.Tree = newOperator("%=", yyvsp[0].SimpTerminal.posn); } break; case 290: #line 1366 "parser.yy" { yyval.Tree = newOperator("<<=", yyvsp[0].SimpTerminal.posn); } break; case 291: #line 1367 "parser.yy" { yyval.Tree = newOperator(">>=", yyvsp[0].SimpTerminal.posn); } break; case 292: #line 1368 "parser.yy" { yyval.Tree = newOperator(">>>=", yyvsp[0].SimpTerminal.posn); } break; case 293: #line 1369 "parser.yy" { yyval.Tree = newOperator("&=", yyvsp[0].SimpTerminal.posn); } break; case 294: #line 1370 "parser.yy" { yyval.Tree = newOperator("^=", yyvsp[0].SimpTerminal.posn); } break; case 295: #line 1371 "parser.yy" { yyval.Tree = newOperator("|=", yyvsp[0].SimpTerminal.posn); } break; case 296: #line 1372 "parser.yy" { yyval.Tree = newOperator("[]", yyvsp[-1].SimpTerminal.posn); } break; case 297: #line 1373 "parser.yy" { yyval.Tree = newOperator("[]=", yyvsp[-2].SimpTerminal.posn); } break; case 298: #line 1380 "parser.yy" { yyval.Tree = new ArrayAccessNode (yyvsp[-3].Tree, yyvsp[-1].Tree); } break; case 299: #line 1384 "parser.yy" { yyval.Tree = new PointNode(yyvsp[0].TreeList); } break; case 300: #line 1393 "parser.yy" { yyval.Tree = new ObjectFieldAccessNode (yyvsp[-2].Tree, yyvsp[0].Tree); } break; case 301: #line 1395 "parser.yy" { yyval.Tree = new SuperFieldAccessNode (NULL, Common::None, yyvsp[0].Tree); } break; case 302: #line 1397 "parser.yy" { yyval.Tree = new TypeFieldAccessNode (yyvsp[-2].Type, yyvsp[0].Tree); } break; case 303: #line 1399 "parser.yy" { yyval.Tree = new ObjectFieldAccessNode (yyvsp[-2].Tree->asExpr(), yyvsp[0].Tree); } break; case 304: #line 1401 "parser.yy" { yyval.Tree = new ThisFieldAccessNode (NULL, Common::None, yyvsp[0].Tree); } break; case 305: #line 1409 "parser.yy" { yyval.Tree = new MethodCallNode (yyvsp[-3].Tree, yyvsp[-1].TreeList); } break; case 306: #line 1411 "parser.yy" { yyval.Tree = new MethodCallNode (yyvsp[-3].Tree->asExpr(), yyvsp[-1].TreeList); } break; case 308: #line 1417 "parser.yy" { yyval.TreeList = NULL; } break; case 309: #line 1422 "parser.yy" { yyval.TreeList = cons (yyvsp[0].Tree); } break; case 310: #line 1424 "parser.yy" { yyval.TreeList = cons (yyvsp[-2].Tree, yyvsp[0].TreeList); } break; case 311: #line 1432 "parser.yy" { yyval.Tree = new AllocateNode (yyvsp[-4].Tree, yyvsp[-3].Type, yyvsp[-1].TreeList, NULL); } break; case 312: #line 1434 "parser.yy" { yyval.Tree = new AllocateArrayNode (yyvsp[-2].Tree, yyvsp[-1].Type, yyvsp[0].TreeList); } break; case 313: #line 1439 "parser.yy" { yyval.Tree = yyvsp[-1].Tree; } break; case 314: #line 1441 "parser.yy" { yyval.Tree = TreeNode::omitted; } break; case 315: #line 1446 "parser.yy" { yyval.TreeList = cons (yyvsp[0].Tree); } break; case 316: #line 1448 "parser.yy" { yyval.TreeList = cons (yyvsp[-1].Tree, yyvsp[0].TreeList); } break; case 317: #line 1453 "parser.yy" { yyval.Tree = yyvsp[0].Tree; } break; case 318: #line 1455 "parser.yy" { yyval.Tree = new AllocateArrayDimensionNode(yyvsp[-1].Tree, yyvsp[0].Modifiers); } break; case 320: #line 1461 "parser.yy" { yyval.Int = 0; } break; case 321: #line 1466 "parser.yy" { yyval.Int = 1; } break; case 322: #line 1468 "parser.yy" { yyval.Int = 1; } break; case 323: #line 1470 "parser.yy" { yyval.Int = yyvsp[-2].Int + 1; } break; case 324: #line 1472 "parser.yy" { yyval.Int = yyvsp[-3].Int + 1; } break; case 331: #line 1495 "parser.yy" { yyval.Tree = new PostIncrNode (yyvsp[-1].Tree); } break; case 332: #line 1500 "parser.yy" { yyval.Tree = new PostDecrNode (yyvsp[-1].Tree); } break; case 339: #line 1520 "parser.yy" { yyval.Tree = new UnaryPlusNode (yyvsp[0].Tree, yyvsp[-1].SimpTerminal.posn); } break; case 340: #line 1522 "parser.yy" { yyval.Tree = new UnaryMinusNode (yyvsp[0].Tree, yyvsp[-1].SimpTerminal.posn); } break; case 343: #line 1529 "parser.yy" { yyval.Tree = new PreIncrNode (yyvsp[0].Tree); } break; case 344: #line 1534 "parser.yy" { yyval.Tree = new PreDecrNode (yyvsp[0].Tree); } break; case 349: #line 1549 "parser.yy" { yyval.Tree = new ComplementNode (yyvsp[0].Tree); } break; case 350: #line 1551 "parser.yy" { yyval.Tree = new NotNode (yyvsp[0].Tree); } break; case 352: #line 1557 "parser.yy" { yyval.Tree = new CastNode (yyvsp[0].Tree, yyvsp[-2].Type); } break; case 353: #line 1559 "parser.yy" { yyval.Tree = new CastNode (yyvsp[0].Tree, yyvsp[-2].Tree->asType()); } break; case 354: #line 1569 "parser.yy" { yyval.Tree = new PointNode(yyvsp[-1].TreeList); } break; case 355: #line 1573 "parser.yy" { yyval.Tree = new DomainNode(yyvsp[-1].TreeList); } break; case 356: #line 1574 "parser.yy" { yyval.Tree = new DomainNode(yyvsp[-1].TreeList); } break; case 357: #line 1578 "parser.yy" { yyval.TreeList = cons(yyvsp[0].Tree); } break; case 358: #line 1579 "parser.yy" { yyval.TreeList = cons(yyvsp[-2].Tree, yyvsp[0].TreeList); } break; case 359: #line 1584 "parser.yy" { llist* children = cons(yyvsp[-2].Tree, cons(yyvsp[0].Tree)); yyval.Tree = new TreeListNode(children); } break; case 360: #line 1589 "parser.yy" { yyval.TreeList = cons(yyvsp[0].Tree); } break; case 361: #line 1590 "parser.yy" { yyval.TreeList = cons(yyvsp[-2].Tree, yyvsp[0].TreeList); } break; case 362: #line 1595 "parser.yy" { llist* children = cons(yyvsp[-4].Tree, cons(yyvsp[-2].Tree, cons(yyvsp[0].Tree))); yyval.Tree = new TreeListNode(children); } break; case 364: #line 1604 "parser.yy" { yyval.Tree = TreeNode::omitted; } break; case 367: #line 1611 "parser.yy" { yyval.Tree = new LTNode (yyvsp[-2].Tree, yyvsp[0].Tree); } break; case 368: #line 1613 "parser.yy" { yyval.Tree = new GTNode (yyvsp[-2].Tree, yyvsp[0].Tree); } break; case 369: #line 1615 "parser.yy" { yyval.Tree = new LENode (yyvsp[-2].Tree, yyvsp[0].Tree); } break; case 370: #line 1617 "parser.yy" { yyval.Tree = new GENode (yyvsp[-2].Tree, yyvsp[0].Tree); } break; case 371: #line 1619 "parser.yy" { yyval.Tree = new InstanceOfNode (yyvsp[-2].Tree, yyvsp[0].Type); } break; case 372: #line 1621 "parser.yy" { yyval.Tree = new EQNode (yyvsp[-2].Tree, yyvsp[0].Tree); } break; case 373: #line 1623 "parser.yy" { yyval.Tree = new NENode (yyvsp[-2].Tree, yyvsp[0].Tree); } break; case 374: #line 1625 "parser.yy" { yyval.Tree = new BitAndNode (yyvsp[-2].Tree, yyvsp[0].Tree); } break; case 375: #line 1627 "parser.yy" { yyval.Tree = new BitOrNode (yyvsp[-2].Tree, yyvsp[0].Tree); } break; case 376: #line 1629 "parser.yy" { yyval.Tree = new BitXorNode (yyvsp[-2].Tree, yyvsp[0].Tree); } break; case 377: #line 1631 "parser.yy" { yyval.Tree = new CandNode (yyvsp[-2].Tree, yyvsp[0].Tree); } break; case 378: #line 1633 "parser.yy" { yyval.Tree = new CorNode (yyvsp[-2].Tree, yyvsp[0].Tree); } break; case 379: #line 1635 "parser.yy" { yyval.Tree = new IfExprNode (yyvsp[-4].Tree, yyvsp[-2].Tree, yyvsp[0].Tree); } break; case 385: #line 1651 "parser.yy" { yyval.Tree = new MultNode (yyvsp[-2].Tree, yyvsp[0].Tree); } break; case 386: #line 1653 "parser.yy" { yyval.Tree = new DivNode (yyvsp[-2].Tree, yyvsp[0].Tree); } break; case 387: #line 1655 "parser.yy" { yyval.Tree = new RemNode (yyvsp[-2].Tree, yyvsp[0].Tree); } break; case 388: #line 1657 "parser.yy" { yyval.Tree = new PlusNode (yyvsp[-2].Tree, yyvsp[0].Tree); } break; case 389: #line 1659 "parser.yy" { yyval.Tree = new MinusNode (yyvsp[-2].Tree, yyvsp[0].Tree); } break; case 390: #line 1661 "parser.yy" { yyval.Tree = new LeftShiftLogNode (yyvsp[-2].Tree, yyvsp[0].Tree); } break; case 391: #line 1663 "parser.yy" { yyval.Tree = new RightShiftLogNode (yyvsp[-2].Tree, yyvsp[0].Tree); } break; case 392: #line 1665 "parser.yy" { yyval.Tree = new RightShiftArithNode (yyvsp[-2].Tree, yyvsp[0].Tree); } break; case 393: #line 1673 "parser.yy" { yyval.Tree = new AssignNode (yyvsp[-2].Tree, yyvsp[0].Tree); } break; case 394: #line 1675 "parser.yy" { yyval.Tree = new MultAssignNode (yyvsp[-2].Tree, yyvsp[0].Tree); } break; case 395: #line 1677 "parser.yy" { yyval.Tree = new DivAssignNode (yyvsp[-2].Tree, yyvsp[0].Tree); } break; case 396: #line 1679 "parser.yy" { yyval.Tree = new RemAssignNode (yyvsp[-2].Tree, yyvsp[0].Tree); } break; case 397: #line 1681 "parser.yy" { yyval.Tree = new PlusAssignNode (yyvsp[-2].Tree, yyvsp[0].Tree); } break; case 398: #line 1683 "parser.yy" { yyval.Tree = new MinusAssignNode (yyvsp[-2].Tree, yyvsp[0].Tree); } break; case 399: #line 1685 "parser.yy" { yyval.Tree = new LeftShiftLogAssignNode (yyvsp[-2].Tree, yyvsp[0].Tree); } break; case 400: #line 1687 "parser.yy" { yyval.Tree = new RightShiftLogAssignNode (yyvsp[-2].Tree, yyvsp[0].Tree); } break; case 401: #line 1689 "parser.yy" { yyval.Tree = new RightShiftArithAssignNode (yyvsp[-2].Tree, yyvsp[0].Tree); } break; case 402: #line 1691 "parser.yy" { yyval.Tree = new BitAndAssignNode (yyvsp[-2].Tree, yyvsp[0].Tree); } break; case 403: #line 1693 "parser.yy" { yyval.Tree = new BitXorAssignNode (yyvsp[-2].Tree, yyvsp[0].Tree); } break; case 404: #line 1695 "parser.yy" { yyval.Tree = new BitOrAssignNode (yyvsp[-2].Tree, yyvsp[0].Tree); } break; case 406: #line 1707 "parser.yy" { yyval.Tree = new BroadcastNode (yyvsp[-2].Tree, yyvsp[0].Tree); } break; case 407: #line 1716 "parser.yy" { yyval.Tree = TreeNode::omitted; } break; case 408: #line 1721 "parser.yy" { yyval.Tree = TreeNode::omitted; } break; case 409: #line 1726 "parser.yy" { yyval.Tree = TreeNode::omitted; } break; case 410: #line 1731 "parser.yy" { yyval.Tree = new EmptyStmtNode; } break; case 411: #line 1733 "parser.yy" { yyval.Tree = yyvsp[0].Tree; } break; case 412: #line 1738 "parser.yy" { yyval.TreeList = NULL; } break; case 413: #line 1743 "parser.yy" { yyval.Tree = TreeNode::omitted; } break; } #line 705 "/usr/share/bison/bison.simple" yyvsp -= yylen; yyssp -= yylen; #if YYLSP_NEEDED yylsp -= yylen; #endif #if YYDEBUG if (yydebug) { short *yyssp1 = yyss - 1; YYFPRINTF (stderr, "state stack now"); while (yyssp1 != yyssp) YYFPRINTF (stderr, " %d", *++yyssp1); YYFPRINTF (stderr, "\n"); } #endif *++yyvsp = yyval; #if YYLSP_NEEDED *++yylsp = yyloc; #endif /* Now `shift' the result of the reduction. Determine what state that goes to, based on the state we popped back to and the rule number reduced by. */ yyn = yyr1[yyn]; yystate = yypgoto[yyn - YYNTBASE] + *yyssp; if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) yystate = yytable[yystate]; else yystate = yydefgoto[yyn - YYNTBASE]; goto yynewstate; /*------------------------------------. | yyerrlab -- here on detecting error | `------------------------------------*/ yyerrlab: /* If not already recovering from an error, report this error. */ if (!yyerrstatus) { ++yynerrs; #ifdef YYERROR_VERBOSE yyn = yypact[yystate]; if (yyn > YYFLAG && yyn < YYLAST) { YYSIZE_T yysize = 0; char *yymsg; int yyx, yycount; yycount = 0; /* Start YYX at -YYN if negative to avoid negative indexes in YYCHECK. */ for (yyx = yyn < 0 ? -yyn : 0; yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++) if (yycheck[yyx + yyn] == yyx) yysize += yystrlen (yytname[yyx]) + 15, yycount++; yysize += yystrlen ("parse error, unexpected ") + 1; yysize += yystrlen (yytname[YYTRANSLATE (yychar)]); yymsg = (char *) YYSTACK_ALLOC (yysize); if (yymsg != 0) { char *yyp = yystpcpy (yymsg, "parse error, unexpected "); yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]); if (yycount < 5) { yycount = 0; for (yyx = yyn < 0 ? -yyn : 0; yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++) if (yycheck[yyx + yyn] == yyx) { const char *yyq = ! yycount ? ", expecting " : " or "; yyp = yystpcpy (yyp, yyq); yyp = yystpcpy (yyp, yytname[yyx]); yycount++; } } yyerror (yymsg); YYSTACK_FREE (yymsg); } else yyerror ("parse error; also virtual memory exhausted"); } else #endif /* defined (YYERROR_VERBOSE) */ yyerror ("parse error"); } goto yyerrlab1; /*--------------------------------------------------. | yyerrlab1 -- error raised explicitly by an action | `--------------------------------------------------*/ yyerrlab1: if (yyerrstatus == 3) { /* If just tried and failed to reuse lookahead token after an error, discard it. */ /* return failure if at end of input */ if (yychar == YYEOF) YYABORT; YYDPRINTF ((stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1])); yychar = YYEMPTY; } /* Else will try to reuse lookahead token after shifting the error token. */ yyerrstatus = 3; /* Each real token shifted decrements this */ goto yyerrhandle; /*-------------------------------------------------------------------. | yyerrdefault -- current state does not do anything special for the | | error token. | `-------------------------------------------------------------------*/ yyerrdefault: #if 0 /* This is wrong; only states that explicitly want error tokens should shift them. */ /* If its default is to accept any token, ok. Otherwise pop it. */ yyn = yydefact[yystate]; if (yyn) goto yydefault; #endif /*---------------------------------------------------------------. | yyerrpop -- pop the current state because it cannot handle the | | error token | `---------------------------------------------------------------*/ yyerrpop: if (yyssp == yyss) YYABORT; yyvsp--; yystate = *--yyssp; #if YYLSP_NEEDED yylsp--; #endif #if YYDEBUG if (yydebug) { short *yyssp1 = yyss - 1; YYFPRINTF (stderr, "Error: state stack now"); while (yyssp1 != yyssp) YYFPRINTF (stderr, " %d", *++yyssp1); YYFPRINTF (stderr, "\n"); } #endif /*--------------. | yyerrhandle. | `--------------*/ yyerrhandle: yyn = yypact[yystate]; if (yyn == YYFLAG) goto yyerrdefault; yyn += YYTERROR; if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) goto yyerrdefault; yyn = yytable[yyn]; if (yyn < 0) { if (yyn == YYFLAG) goto yyerrpop; yyn = -yyn; goto yyreduce; } else if (yyn == 0) goto yyerrpop; if (yyn == YYFINAL) YYACCEPT; YYDPRINTF ((stderr, "Shifting error token, ")); *++yyvsp = yylval; #if YYLSP_NEEDED *++yylsp = yylloc; #endif yystate = yyn; goto yynewstate; /*-------------------------------------. | yyacceptlab -- YYACCEPT comes here. | `-------------------------------------*/ yyacceptlab: yyresult = 0; goto yyreturn; /*-----------------------------------. | yyabortlab -- YYABORT comes here. | `-----------------------------------*/ yyabortlab: yyresult = 1; goto yyreturn; /*---------------------------------------------. | yyoverflowab -- parser overflow comes here. | `---------------------------------------------*/ yyoverflowlab: yyerror ("parser stack overflow"); yyresult = 2; /* Fall through. */ yyreturn: #ifndef yyoverflow if (yyss != yyssa) YYSTACK_FREE (yyss); #endif return yyresult; } #line 1747 "parser.yy" static void yyerror(const char* msg) { Error(yylval.SimpTerminal.posn) << msg << endl; } static TreeNode *newOperator(char *op, SourcePosn p) { return new NameNode(TreeNode::omitted, intern(op), NULL, p); } /* Check that FLAG is not a member of FLAGS. If it is, report an */ /* error at POSN, giving NAME as the name of the offending modifier. */ static void checkModifier(SourcePosn posn, Common::Modifiers flags, Common::Modifiers flag, const char* name) { if (((unsigned long) flags & (unsigned long) flag) != 0) Error (posn) << "illegal modifier: '" << name << "'" << endl; } /* Check that only the modifiers in ... are in FLAGS, reporting an */ /* error at POSN if not. */ static void checkModifiers(SourcePosn posn, Common::Modifiers flags, ...) { unsigned long flag; va_list ap; va_start (ap, flags); while (true) { flag = va_arg (ap, unsigned long); if (flag == 0) break; flags = (Common::Modifiers)((unsigned long)flags & ~flag); } va_end (ap); if ((unsigned long) flags != 0) Error(posn) << "illegal modifiers: " << stringifyModifiers(flags) << endl; } static void checkFieldModifiers(Common::Modifiers flags, SourcePosn posn) { checkModifiers(posn, flags, TreeNode::Public, TreeNode::Protected, TreeNode::Private, TreeNode::Static, TreeNode::Final, TreeNode::Transient, TreeNode::Volatile, (Common::Modifiers) 0); } static void checkConstantFieldModifiers(Common::Modifiers flags, SourcePosn posn) { checkModifiers(posn, flags, TreeNode::Public, TreeNode::Static, TreeNode::Final, (Common::Modifiers) 0); } static void checkMethodModifiers(Common::Modifiers flags, SourcePosn posn) { checkModifiers(posn, flags, TreeNode::Public, TreeNode::Protected, TreeNode::Private, TreeNode::Static, TreeNode::Final, TreeNode::Abstract, TreeNode::Native, TreeNode::Sglobal, TreeNode::Local, TreeNode::NonsharedQ, TreeNode::PolysharedQ, TreeNode::Synchronized, TreeNode::Inline, (Common::Modifiers) 0); } static void checkConstructorModifiers(Common::Modifiers flags, SourcePosn posn) { checkModifiers(posn, flags, TreeNode::Public, TreeNode::Protected, TreeNode::Private, TreeNode::NonsharedQ, TreeNode::PolysharedQ, TreeNode::Sglobal, TreeNode::Inline, (Common::Modifiers) 0); } static void checkMethodSignatureModifiers(Common::Modifiers flags, SourcePosn posn) { checkModifiers(posn, flags, TreeNode::Public, TreeNode::Abstract, TreeNode::Single, TreeNode::Local, TreeNode::NonsharedQ, TreeNode::PolysharedQ, (Common::Modifiers) 0); } static void checkInterfaceModifiers(Common::Modifiers flags, SourcePosn posn) { checkModifiers(posn, flags, TreeNode::Public, TreeNode::Abstract, (Common::Modifiers) 0); } static TreeNode *addSynchronized(Common::Modifiers modifiers, TreeNode *body) { if ((modifiers & TreeNode::Synchronized) != 0 && !body->absent()) { TreeNode *syncObject; if ((modifiers & TreeNode::Static) != 0) { syncObject = TreeNode::omitted; } else { syncObject = new ThisNode(NULL, Common::None, body->position()); } body = new SynchronizedNode(syncObject, body); } return body; }