github.com/rohankumardubey/syslog-redirector-golang@v0.0.0-20140320174030-4859f03d829a/src/cmd/gc/y.tab.c (about) 1 /* A Bison parser, made by GNU Bison 2.5. */ 2 3 /* Bison implementation for Yacc-like parsers in C 4 5 Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc. 6 7 This program is free software: you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation, either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 /* As a special exception, you may create a larger work that contains 21 part or all of the Bison parser skeleton and distribute that work 22 under terms of your choice, so long as that work isn't itself a 23 parser generator using the skeleton or a modified version thereof 24 as a parser skeleton. Alternatively, if you modify or redistribute 25 the parser skeleton itself, you may (at your option) remove this 26 special exception, which will cause the skeleton and the resulting 27 Bison output files to be licensed under the GNU General Public 28 License without this special exception. 29 30 This special exception was added by the Free Software Foundation in 31 version 2.2 of Bison. */ 32 33 /* C LALR(1) parser skeleton written by Richard Stallman, by 34 simplifying the original so-called "semantic" parser. */ 35 36 /* All symbols defined below should begin with yy or YY, to avoid 37 infringing on user name space. This should be done even for local 38 variables, as they might otherwise be expanded by user macros. 39 There are some unavoidable exceptions within include files to 40 define necessary library symbols; they are noted "INFRINGES ON 41 USER NAME SPACE" below. */ 42 43 /* Identify Bison output. */ 44 #define YYBISON 1 45 46 /* Bison version. */ 47 #define YYBISON_VERSION "2.5" 48 49 /* Skeleton name. */ 50 #define YYSKELETON_NAME "yacc.c" 51 52 /* Pure parsers. */ 53 #define YYPURE 0 54 55 /* Push parsers. */ 56 #define YYPUSH 0 57 58 /* Pull parsers. */ 59 #define YYPULL 1 60 61 /* Using locations. */ 62 #define YYLSP_NEEDED 0 63 64 65 66 /* Copy the first part of user declarations. */ 67 68 /* Line 268 of yacc.c */ 69 #line 20 "go.y" 70 71 #include <u.h> 72 #include <stdio.h> /* if we don't, bison will, and go.h re-#defines getc */ 73 #include <libc.h> 74 #include "go.h" 75 76 static void fixlbrace(int); 77 78 79 /* Line 268 of yacc.c */ 80 #line 81 "y.tab.c" 81 82 /* Enabling traces. */ 83 #ifndef YYDEBUG 84 # define YYDEBUG 0 85 #endif 86 87 /* Enabling verbose error messages. */ 88 #ifdef YYERROR_VERBOSE 89 # undef YYERROR_VERBOSE 90 # define YYERROR_VERBOSE 1 91 #else 92 # define YYERROR_VERBOSE 1 93 #endif 94 95 /* Enabling the token table. */ 96 #ifndef YYTOKEN_TABLE 97 # define YYTOKEN_TABLE 0 98 #endif 99 100 101 /* Tokens. */ 102 #ifndef YYTOKENTYPE 103 # define YYTOKENTYPE 104 /* Put the tokens into the symbol table, so that GDB and other debuggers 105 know about them. */ 106 enum yytokentype { 107 LLITERAL = 258, 108 LASOP = 259, 109 LCOLAS = 260, 110 LBREAK = 261, 111 LCASE = 262, 112 LCHAN = 263, 113 LCONST = 264, 114 LCONTINUE = 265, 115 LDDD = 266, 116 LDEFAULT = 267, 117 LDEFER = 268, 118 LELSE = 269, 119 LFALL = 270, 120 LFOR = 271, 121 LFUNC = 272, 122 LGO = 273, 123 LGOTO = 274, 124 LIF = 275, 125 LIMPORT = 276, 126 LINTERFACE = 277, 127 LMAP = 278, 128 LNAME = 279, 129 LPACKAGE = 280, 130 LRANGE = 281, 131 LRETURN = 282, 132 LSELECT = 283, 133 LSTRUCT = 284, 134 LSWITCH = 285, 135 LTYPE = 286, 136 LVAR = 287, 137 LANDAND = 288, 138 LANDNOT = 289, 139 LBODY = 290, 140 LCOMM = 291, 141 LDEC = 292, 142 LEQ = 293, 143 LGE = 294, 144 LGT = 295, 145 LIGNORE = 296, 146 LINC = 297, 147 LLE = 298, 148 LLSH = 299, 149 LLT = 300, 150 LNE = 301, 151 LOROR = 302, 152 LRSH = 303, 153 NotPackage = 304, 154 NotParen = 305, 155 PreferToRightParen = 306 156 }; 157 #endif 158 /* Tokens. */ 159 #define LLITERAL 258 160 #define LASOP 259 161 #define LCOLAS 260 162 #define LBREAK 261 163 #define LCASE 262 164 #define LCHAN 263 165 #define LCONST 264 166 #define LCONTINUE 265 167 #define LDDD 266 168 #define LDEFAULT 267 169 #define LDEFER 268 170 #define LELSE 269 171 #define LFALL 270 172 #define LFOR 271 173 #define LFUNC 272 174 #define LGO 273 175 #define LGOTO 274 176 #define LIF 275 177 #define LIMPORT 276 178 #define LINTERFACE 277 179 #define LMAP 278 180 #define LNAME 279 181 #define LPACKAGE 280 182 #define LRANGE 281 183 #define LRETURN 282 184 #define LSELECT 283 185 #define LSTRUCT 284 186 #define LSWITCH 285 187 #define LTYPE 286 188 #define LVAR 287 189 #define LANDAND 288 190 #define LANDNOT 289 191 #define LBODY 290 192 #define LCOMM 291 193 #define LDEC 292 194 #define LEQ 293 195 #define LGE 294 196 #define LGT 295 197 #define LIGNORE 296 198 #define LINC 297 199 #define LLE 298 200 #define LLSH 299 201 #define LLT 300 202 #define LNE 301 203 #define LOROR 302 204 #define LRSH 303 205 #define NotPackage 304 206 #define NotParen 305 207 #define PreferToRightParen 306 208 209 210 211 212 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 213 typedef union YYSTYPE 214 { 215 216 /* Line 293 of yacc.c */ 217 #line 28 "go.y" 218 219 Node* node; 220 NodeList* list; 221 Type* type; 222 Sym* sym; 223 struct Val val; 224 int i; 225 226 227 228 /* Line 293 of yacc.c */ 229 #line 230 "y.tab.c" 230 } YYSTYPE; 231 # define YYSTYPE_IS_TRIVIAL 1 232 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ 233 # define YYSTYPE_IS_DECLARED 1 234 #endif 235 236 237 /* Copy the second part of user declarations. */ 238 239 240 /* Line 343 of yacc.c */ 241 #line 242 "y.tab.c" 242 243 #ifdef short 244 # undef short 245 #endif 246 247 #ifdef YYTYPE_UINT8 248 typedef YYTYPE_UINT8 yytype_uint8; 249 #else 250 typedef unsigned char yytype_uint8; 251 #endif 252 253 #ifdef YYTYPE_INT8 254 typedef YYTYPE_INT8 yytype_int8; 255 #elif (defined __STDC__ || defined __C99__FUNC__ \ 256 || defined __cplusplus || defined _MSC_VER) 257 typedef signed char yytype_int8; 258 #else 259 typedef short int yytype_int8; 260 #endif 261 262 #ifdef YYTYPE_UINT16 263 typedef YYTYPE_UINT16 yytype_uint16; 264 #else 265 typedef unsigned short int yytype_uint16; 266 #endif 267 268 #ifdef YYTYPE_INT16 269 typedef YYTYPE_INT16 yytype_int16; 270 #else 271 typedef short int yytype_int16; 272 #endif 273 274 #ifndef YYSIZE_T 275 # ifdef __SIZE_TYPE__ 276 # define YYSIZE_T __SIZE_TYPE__ 277 # elif defined size_t 278 # define YYSIZE_T size_t 279 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ 280 || defined __cplusplus || defined _MSC_VER) 281 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 282 # define YYSIZE_T size_t 283 # else 284 # define YYSIZE_T unsigned int 285 # endif 286 #endif 287 288 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 289 290 #ifndef YY_ 291 # if defined YYENABLE_NLS && YYENABLE_NLS 292 # if ENABLE_NLS 293 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 294 # define YY_(msgid) dgettext ("bison-runtime", msgid) 295 # endif 296 # endif 297 # ifndef YY_ 298 # define YY_(msgid) msgid 299 # endif 300 #endif 301 302 /* Suppress unused-variable warnings by "using" E. */ 303 #if ! defined lint || defined __GNUC__ 304 # define YYUSE(e) ((void) (e)) 305 #else 306 # define YYUSE(e) /* empty */ 307 #endif 308 309 /* Identity function, used to suppress warnings about constant conditions. */ 310 #ifndef lint 311 # define YYID(n) (n) 312 #else 313 #if (defined __STDC__ || defined __C99__FUNC__ \ 314 || defined __cplusplus || defined _MSC_VER) 315 static int 316 YYID (int yyi) 317 #else 318 static int 319 YYID (yyi) 320 int yyi; 321 #endif 322 { 323 return yyi; 324 } 325 #endif 326 327 #if ! defined yyoverflow || YYERROR_VERBOSE 328 329 /* The parser invokes alloca or malloc; define the necessary symbols. */ 330 331 # ifdef YYSTACK_USE_ALLOCA 332 # if YYSTACK_USE_ALLOCA 333 # ifdef __GNUC__ 334 # define YYSTACK_ALLOC __builtin_alloca 335 # elif defined __BUILTIN_VA_ARG_INCR 336 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 337 # elif defined _AIX 338 # define YYSTACK_ALLOC __alloca 339 # elif defined _MSC_VER 340 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 341 # define alloca _alloca 342 # else 343 # define YYSTACK_ALLOC alloca 344 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 345 || defined __cplusplus || defined _MSC_VER) 346 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 347 # ifndef EXIT_SUCCESS 348 # define EXIT_SUCCESS 0 349 # endif 350 # endif 351 # endif 352 # endif 353 # endif 354 355 # ifdef YYSTACK_ALLOC 356 /* Pacify GCC's `empty if-body' warning. */ 357 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) 358 # ifndef YYSTACK_ALLOC_MAXIMUM 359 /* The OS might guarantee only one guard page at the bottom of the stack, 360 and a page size can be as small as 4096 bytes. So we cannot safely 361 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 362 to allow for a few compiler-allocated temporary stack slots. */ 363 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 364 # endif 365 # else 366 # define YYSTACK_ALLOC YYMALLOC 367 # define YYSTACK_FREE YYFREE 368 # ifndef YYSTACK_ALLOC_MAXIMUM 369 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 370 # endif 371 # if (defined __cplusplus && ! defined EXIT_SUCCESS \ 372 && ! ((defined YYMALLOC || defined malloc) \ 373 && (defined YYFREE || defined free))) 374 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 375 # ifndef EXIT_SUCCESS 376 # define EXIT_SUCCESS 0 377 # endif 378 # endif 379 # ifndef YYMALLOC 380 # define YYMALLOC malloc 381 # if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 382 || defined __cplusplus || defined _MSC_VER) 383 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 384 # endif 385 # endif 386 # ifndef YYFREE 387 # define YYFREE free 388 # if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 389 || defined __cplusplus || defined _MSC_VER) 390 void free (void *); /* INFRINGES ON USER NAME SPACE */ 391 # endif 392 # endif 393 # endif 394 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */ 395 396 397 #if (! defined yyoverflow \ 398 && (! defined __cplusplus \ 399 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 400 401 /* A type that is properly aligned for any stack member. */ 402 union yyalloc 403 { 404 yytype_int16 yyss_alloc; 405 YYSTYPE yyvs_alloc; 406 }; 407 408 /* The size of the maximum gap between one aligned stack and the next. */ 409 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 410 411 /* The size of an array large to enough to hold all stacks, each with 412 N elements. */ 413 # define YYSTACK_BYTES(N) \ 414 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ 415 + YYSTACK_GAP_MAXIMUM) 416 417 # define YYCOPY_NEEDED 1 418 419 /* Relocate STACK from its old location to the new one. The 420 local variables YYSIZE and YYSTACKSIZE give the old and new number of 421 elements in the stack, and YYPTR gives the new location of the 422 stack. Advance YYPTR to a properly aligned location for the next 423 stack. */ 424 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 425 do \ 426 { \ 427 YYSIZE_T yynewbytes; \ 428 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 429 Stack = &yyptr->Stack_alloc; \ 430 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 431 yyptr += yynewbytes / sizeof (*yyptr); \ 432 } \ 433 while (YYID (0)) 434 435 #endif 436 437 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED 438 /* Copy COUNT objects from FROM to TO. The source and destination do 439 not overlap. */ 440 # ifndef YYCOPY 441 # if defined __GNUC__ && 1 < __GNUC__ 442 # define YYCOPY(To, From, Count) \ 443 __builtin_memcpy (To, From, (Count) * sizeof (*(From))) 444 # else 445 # define YYCOPY(To, From, Count) \ 446 do \ 447 { \ 448 YYSIZE_T yyi; \ 449 for (yyi = 0; yyi < (Count); yyi++) \ 450 (To)[yyi] = (From)[yyi]; \ 451 } \ 452 while (YYID (0)) 453 # endif 454 # endif 455 #endif /* !YYCOPY_NEEDED */ 456 457 /* YYFINAL -- State number of the termination state. */ 458 #define YYFINAL 4 459 /* YYLAST -- Last index in YYTABLE. */ 460 #define YYLAST 2270 461 462 /* YYNTOKENS -- Number of terminals. */ 463 #define YYNTOKENS 76 464 /* YYNNTS -- Number of nonterminals. */ 465 #define YYNNTS 142 466 /* YYNRULES -- Number of rules. */ 467 #define YYNRULES 351 468 /* YYNRULES -- Number of states. */ 469 #define YYNSTATES 667 470 471 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 472 #define YYUNDEFTOK 2 473 #define YYMAXUTOK 306 474 475 #define YYTRANSLATE(YYX) \ 476 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 477 478 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ 479 static const yytype_uint8 yytranslate[] = 480 { 481 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 482 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 483 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 484 2, 2, 2, 69, 2, 2, 64, 55, 56, 2, 485 59, 60, 53, 49, 75, 50, 63, 54, 2, 2, 486 2, 2, 2, 2, 2, 2, 2, 2, 66, 62, 487 2, 65, 2, 73, 74, 2, 2, 2, 2, 2, 488 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 489 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 490 2, 71, 2, 72, 52, 2, 2, 2, 2, 2, 491 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 492 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 493 2, 2, 2, 67, 51, 68, 70, 2, 2, 2, 494 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 495 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 496 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 497 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 498 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 499 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 500 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 501 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 502 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 503 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 504 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 505 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 506 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 507 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 508 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 509 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 510 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 511 45, 46, 47, 48, 57, 58, 61 512 }; 513 514 #if YYDEBUG 515 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 516 YYRHS. */ 517 static const yytype_uint16 yyprhs[] = 518 { 519 0, 0, 3, 8, 9, 13, 14, 18, 19, 23, 520 26, 32, 36, 40, 43, 45, 49, 51, 54, 57, 521 62, 63, 65, 66, 71, 72, 74, 76, 78, 80, 522 83, 89, 93, 96, 102, 110, 114, 117, 123, 127, 523 129, 132, 137, 141, 146, 150, 152, 155, 157, 159, 524 162, 164, 168, 172, 176, 179, 182, 186, 192, 198, 525 201, 202, 207, 208, 212, 213, 216, 217, 222, 227, 526 232, 238, 240, 242, 245, 246, 250, 252, 256, 257, 527 258, 259, 268, 269, 275, 276, 279, 280, 283, 284, 528 285, 293, 294, 300, 302, 306, 310, 314, 318, 322, 529 326, 330, 334, 338, 342, 346, 350, 354, 358, 362, 530 366, 370, 374, 378, 382, 384, 387, 390, 393, 396, 531 399, 402, 405, 408, 412, 418, 425, 427, 429, 433, 532 439, 445, 450, 457, 466, 468, 474, 480, 486, 494, 533 496, 497, 501, 503, 508, 510, 515, 517, 521, 523, 534 525, 527, 529, 531, 533, 535, 536, 538, 540, 542, 535 544, 549, 554, 556, 558, 560, 563, 565, 567, 569, 536 571, 573, 577, 579, 581, 583, 586, 588, 590, 592, 537 594, 598, 600, 602, 604, 606, 608, 610, 612, 614, 538 616, 620, 625, 630, 633, 637, 643, 645, 647, 650, 539 654, 660, 664, 670, 674, 678, 684, 693, 699, 708, 540 714, 715, 719, 720, 722, 726, 728, 733, 736, 737, 541 741, 743, 747, 749, 753, 755, 759, 761, 765, 767, 542 771, 775, 778, 783, 787, 793, 799, 801, 805, 807, 543 810, 812, 816, 821, 823, 826, 829, 831, 833, 837, 544 838, 841, 842, 844, 846, 848, 850, 852, 854, 856, 545 858, 860, 861, 866, 868, 871, 874, 877, 880, 883, 546 886, 888, 892, 894, 898, 900, 904, 906, 910, 912, 547 916, 918, 920, 924, 928, 929, 932, 933, 935, 936, 548 938, 939, 941, 942, 944, 945, 947, 948, 950, 951, 549 953, 954, 956, 957, 959, 964, 969, 975, 982, 987, 550 992, 994, 996, 998, 1000, 1002, 1004, 1006, 1008, 1010, 551 1014, 1019, 1025, 1030, 1035, 1038, 1041, 1046, 1050, 1054, 552 1060, 1064, 1069, 1073, 1079, 1081, 1082, 1084, 1088, 1090, 553 1092, 1095, 1097, 1099, 1105, 1106, 1109, 1111, 1115, 1117, 554 1121, 1123 555 }; 556 557 /* YYRHS -- A `-1'-separated list of the rules' RHS. */ 558 static const yytype_int16 yyrhs[] = 559 { 560 77, 0, -1, 79, 78, 81, 166, -1, -1, 25, 561 141, 62, -1, -1, 80, 86, 88, -1, -1, 81, 562 82, 62, -1, 21, 83, -1, 21, 59, 84, 190, 563 60, -1, 21, 59, 60, -1, 85, 86, 88, -1, 564 85, 88, -1, 83, -1, 84, 62, 83, -1, 3, 565 -1, 141, 3, -1, 63, 3, -1, 25, 24, 87, 566 62, -1, -1, 24, -1, -1, 89, 214, 64, 64, 567 -1, -1, 91, -1, 158, -1, 181, -1, 1, -1, 568 32, 93, -1, 32, 59, 167, 190, 60, -1, 32, 569 59, 60, -1, 92, 94, -1, 92, 59, 94, 190, 570 60, -1, 92, 59, 94, 62, 168, 190, 60, -1, 571 92, 59, 60, -1, 31, 97, -1, 31, 59, 169, 572 190, 60, -1, 31, 59, 60, -1, 9, -1, 185, 573 146, -1, 185, 146, 65, 186, -1, 185, 65, 186, 574 -1, 185, 146, 65, 186, -1, 185, 65, 186, -1, 575 94, -1, 185, 146, -1, 185, -1, 141, -1, 96, 576 146, -1, 126, -1, 126, 4, 126, -1, 186, 65, 577 186, -1, 186, 5, 186, -1, 126, 42, -1, 126, 578 37, -1, 7, 187, 66, -1, 7, 187, 65, 126, 579 66, -1, 7, 187, 5, 126, 66, -1, 12, 66, 580 -1, -1, 67, 101, 183, 68, -1, -1, 99, 103, 581 183, -1, -1, 104, 102, -1, -1, 35, 106, 183, 582 68, -1, 186, 65, 26, 126, -1, 186, 5, 26, 583 126, -1, 194, 62, 194, 62, 194, -1, 194, -1, 584 107, -1, 108, 105, -1, -1, 16, 111, 109, -1, 585 194, -1, 194, 62, 194, -1, -1, -1, -1, 20, 586 114, 112, 115, 105, 116, 119, 120, -1, -1, 14, 587 20, 118, 112, 105, -1, -1, 119, 117, -1, -1, 588 14, 100, -1, -1, -1, 30, 122, 112, 123, 35, 589 104, 68, -1, -1, 28, 125, 35, 104, 68, -1, 590 127, -1, 126, 47, 126, -1, 126, 33, 126, -1, 591 126, 38, 126, -1, 126, 46, 126, -1, 126, 45, 592 126, -1, 126, 43, 126, -1, 126, 39, 126, -1, 593 126, 40, 126, -1, 126, 49, 126, -1, 126, 50, 594 126, -1, 126, 51, 126, -1, 126, 52, 126, -1, 595 126, 53, 126, -1, 126, 54, 126, -1, 126, 55, 596 126, -1, 126, 56, 126, -1, 126, 34, 126, -1, 597 126, 44, 126, -1, 126, 48, 126, -1, 126, 36, 598 126, -1, 134, -1, 53, 127, -1, 56, 127, -1, 599 49, 127, -1, 50, 127, -1, 69, 127, -1, 70, 600 127, -1, 52, 127, -1, 36, 127, -1, 134, 59, 601 60, -1, 134, 59, 187, 191, 60, -1, 134, 59, 602 187, 11, 191, 60, -1, 3, -1, 143, -1, 134, 603 63, 141, -1, 134, 63, 59, 135, 60, -1, 134, 604 63, 59, 31, 60, -1, 134, 71, 126, 72, -1, 605 134, 71, 192, 66, 192, 72, -1, 134, 71, 192, 606 66, 192, 66, 192, 72, -1, 128, -1, 149, 59, 607 126, 191, 60, -1, 150, 137, 130, 189, 68, -1, 608 129, 67, 130, 189, 68, -1, 59, 135, 60, 67, 609 130, 189, 68, -1, 165, -1, -1, 126, 66, 133, 610 -1, 126, -1, 67, 130, 189, 68, -1, 126, -1, 611 67, 130, 189, 68, -1, 129, -1, 59, 135, 60, 612 -1, 126, -1, 147, -1, 146, -1, 35, -1, 67, 613 -1, 141, -1, 141, -1, -1, 138, -1, 24, -1, 614 142, -1, 73, -1, 74, 3, 63, 24, -1, 74, 615 3, 63, 73, -1, 141, -1, 138, -1, 11, -1, 616 11, 146, -1, 155, -1, 161, -1, 153, -1, 154, 617 -1, 152, -1, 59, 146, 60, -1, 155, -1, 161, 618 -1, 153, -1, 53, 147, -1, 161, -1, 153, -1, 619 154, -1, 152, -1, 59, 146, 60, -1, 161, -1, 620 153, -1, 153, -1, 155, -1, 161, -1, 153, -1, 621 154, -1, 152, -1, 143, -1, 143, 63, 141, -1, 622 71, 192, 72, 146, -1, 71, 11, 72, 146, -1, 623 8, 148, -1, 8, 36, 146, -1, 23, 71, 146, 624 72, 146, -1, 156, -1, 157, -1, 53, 146, -1, 625 36, 8, 146, -1, 29, 137, 170, 190, 68, -1, 626 29, 137, 68, -1, 22, 137, 171, 190, 68, -1, 627 22, 137, 68, -1, 17, 159, 162, -1, 141, 59, 628 179, 60, 163, -1, 59, 179, 60, 141, 59, 179, 629 60, 163, -1, 200, 59, 195, 60, 210, -1, 59, 630 215, 60, 141, 59, 195, 60, 210, -1, 17, 59, 631 179, 60, 163, -1, -1, 67, 183, 68, -1, -1, 632 151, -1, 59, 179, 60, -1, 161, -1, 164, 137, 633 183, 68, -1, 164, 1, -1, -1, 166, 90, 62, 634 -1, 93, -1, 167, 62, 93, -1, 95, -1, 168, 635 62, 95, -1, 97, -1, 169, 62, 97, -1, 172, 636 -1, 170, 62, 172, -1, 175, -1, 171, 62, 175, 637 -1, 184, 146, 198, -1, 174, 198, -1, 59, 174, 638 60, 198, -1, 53, 174, 198, -1, 59, 53, 174, 639 60, 198, -1, 53, 59, 174, 60, 198, -1, 24, 640 -1, 24, 63, 141, -1, 173, -1, 138, 176, -1, 641 173, -1, 59, 173, 60, -1, 59, 179, 60, 163, 642 -1, 136, -1, 141, 136, -1, 141, 145, -1, 145, 643 -1, 177, -1, 178, 75, 177, -1, -1, 178, 191, 644 -1, -1, 100, -1, 91, -1, 181, -1, 1, -1, 645 98, -1, 110, -1, 121, -1, 124, -1, 113, -1, 646 -1, 144, 66, 182, 180, -1, 15, -1, 6, 140, 647 -1, 10, 140, -1, 18, 128, -1, 13, 128, -1, 648 19, 138, -1, 27, 193, -1, 180, -1, 183, 62, 649 180, -1, 138, -1, 184, 75, 138, -1, 139, -1, 650 185, 75, 139, -1, 126, -1, 186, 75, 126, -1, 651 135, -1, 187, 75, 135, -1, 131, -1, 132, -1, 652 188, 75, 131, -1, 188, 75, 132, -1, -1, 188, 653 191, -1, -1, 62, -1, -1, 75, -1, -1, 126, 654 -1, -1, 186, -1, -1, 98, -1, -1, 215, -1, 655 -1, 216, -1, -1, 217, -1, -1, 3, -1, 21, 656 24, 3, 62, -1, 32, 200, 202, 62, -1, 9, 657 200, 65, 213, 62, -1, 9, 200, 202, 65, 213, 658 62, -1, 31, 201, 202, 62, -1, 17, 160, 162, 659 62, -1, 142, -1, 200, -1, 204, -1, 205, -1, 660 206, -1, 204, -1, 206, -1, 142, -1, 24, -1, 661 71, 72, 202, -1, 71, 3, 72, 202, -1, 23, 662 71, 202, 72, 202, -1, 29, 67, 196, 68, -1, 663 22, 67, 197, 68, -1, 53, 202, -1, 8, 203, 664 -1, 8, 59, 205, 60, -1, 8, 36, 202, -1, 665 36, 8, 202, -1, 17, 59, 195, 60, 210, -1, 666 141, 202, 198, -1, 141, 11, 202, 198, -1, 141, 667 202, 198, -1, 141, 59, 195, 60, 210, -1, 202, 668 -1, -1, 211, -1, 59, 195, 60, -1, 202, -1, 669 3, -1, 50, 3, -1, 141, -1, 212, -1, 59, 670 212, 49, 212, 60, -1, -1, 214, 199, -1, 207, 671 -1, 215, 75, 207, -1, 208, -1, 216, 62, 208, 672 -1, 209, -1, 217, 62, 209, -1 673 }; 674 675 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ 676 static const yytype_uint16 yyrline[] = 677 { 678 0, 124, 124, 133, 139, 150, 150, 165, 166, 169, 679 170, 171, 174, 211, 222, 223, 226, 233, 240, 249, 680 263, 264, 271, 271, 284, 288, 289, 293, 298, 304, 681 308, 312, 316, 322, 328, 334, 339, 343, 347, 353, 682 359, 363, 367, 373, 377, 383, 384, 388, 394, 403, 683 409, 427, 432, 444, 460, 465, 472, 492, 510, 519, 684 538, 537, 552, 551, 582, 585, 592, 591, 602, 608, 685 617, 628, 634, 637, 645, 644, 655, 661, 673, 677, 686 682, 672, 703, 702, 715, 718, 724, 727, 739, 743, 687 738, 761, 760, 776, 777, 781, 785, 789, 793, 797, 688 801, 805, 809, 813, 817, 821, 825, 829, 833, 837, 689 841, 845, 849, 854, 860, 861, 865, 876, 880, 884, 690 888, 893, 897, 907, 911, 916, 924, 928, 929, 940, 691 944, 948, 952, 956, 964, 965, 971, 978, 984, 991, 692 994, 1001, 1007, 1024, 1031, 1032, 1039, 1040, 1059, 1060, 693 1063, 1066, 1070, 1081, 1090, 1096, 1099, 1102, 1109, 1110, 694 1116, 1129, 1144, 1152, 1164, 1169, 1175, 1176, 1177, 1178, 695 1179, 1180, 1186, 1187, 1188, 1189, 1195, 1196, 1197, 1198, 696 1199, 1205, 1206, 1209, 1212, 1213, 1214, 1215, 1216, 1219, 697 1220, 1233, 1237, 1242, 1247, 1252, 1256, 1257, 1260, 1266, 698 1273, 1279, 1286, 1292, 1303, 1317, 1346, 1386, 1411, 1429, 699 1438, 1441, 1449, 1453, 1457, 1464, 1470, 1475, 1487, 1490, 700 1500, 1501, 1507, 1508, 1514, 1518, 1524, 1525, 1531, 1535, 701 1541, 1564, 1569, 1575, 1581, 1588, 1597, 1606, 1621, 1627, 702 1632, 1636, 1643, 1656, 1657, 1663, 1669, 1672, 1676, 1682, 703 1685, 1694, 1697, 1698, 1702, 1703, 1709, 1710, 1711, 1712, 704 1713, 1715, 1714, 1729, 1734, 1738, 1742, 1746, 1750, 1755, 705 1774, 1780, 1788, 1792, 1798, 1802, 1808, 1812, 1818, 1822, 706 1831, 1835, 1839, 1843, 1849, 1852, 1860, 1861, 1863, 1864, 707 1867, 1870, 1873, 1876, 1879, 1882, 1885, 1888, 1891, 1894, 708 1897, 1900, 1903, 1906, 1912, 1916, 1920, 1924, 1928, 1932, 709 1952, 1959, 1970, 1971, 1972, 1975, 1976, 1979, 1983, 1993, 710 1997, 2001, 2005, 2009, 2013, 2017, 2023, 2029, 2037, 2045, 711 2051, 2058, 2074, 2096, 2100, 2106, 2109, 2112, 2116, 2126, 712 2130, 2145, 2153, 2154, 2166, 2167, 2170, 2174, 2180, 2184, 713 2190, 2194 714 }; 715 #endif 716 717 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE 718 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 719 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 720 const char *yytname[] = 721 { 722 "$end", "error", "$undefined", "LLITERAL", "LASOP", "LCOLAS", "LBREAK", 723 "LCASE", "LCHAN", "LCONST", "LCONTINUE", "LDDD", "LDEFAULT", "LDEFER", 724 "LELSE", "LFALL", "LFOR", "LFUNC", "LGO", "LGOTO", "LIF", "LIMPORT", 725 "LINTERFACE", "LMAP", "LNAME", "LPACKAGE", "LRANGE", "LRETURN", 726 "LSELECT", "LSTRUCT", "LSWITCH", "LTYPE", "LVAR", "LANDAND", "LANDNOT", 727 "LBODY", "LCOMM", "LDEC", "LEQ", "LGE", "LGT", "LIGNORE", "LINC", "LLE", 728 "LLSH", "LLT", "LNE", "LOROR", "LRSH", "'+'", "'-'", "'|'", "'^'", "'*'", 729 "'/'", "'%'", "'&'", "NotPackage", "NotParen", "'('", "')'", 730 "PreferToRightParen", "';'", "'.'", "'$'", "'='", "':'", "'{'", "'}'", 731 "'!'", "'~'", "'['", "']'", "'?'", "'@'", "','", "$accept", "file", 732 "package", "loadsys", "$@1", "imports", "import", "import_stmt", 733 "import_stmt_list", "import_here", "import_package", "import_safety", 734 "import_there", "$@2", "xdcl", "common_dcl", "lconst", "vardcl", 735 "constdcl", "constdcl1", "typedclname", "typedcl", "simple_stmt", "case", 736 "compound_stmt", "$@3", "caseblock", "$@4", "caseblock_list", 737 "loop_body", "$@5", "range_stmt", "for_header", "for_body", "for_stmt", 738 "$@6", "if_header", "if_stmt", "$@7", "$@8", "$@9", "elseif", "$@10", 739 "elseif_list", "else", "switch_stmt", "$@11", "$@12", "select_stmt", 740 "$@13", "expr", "uexpr", "pseudocall", "pexpr_no_paren", "start_complit", 741 "keyval", "bare_complitexpr", "complitexpr", "pexpr", "expr_or_type", 742 "name_or_type", "lbrace", "new_name", "dcl_name", "onew_name", "sym", 743 "hidden_importsym", "name", "labelname", "dotdotdot", "ntype", 744 "non_expr_type", "non_recvchantype", "convtype", "comptype", 745 "fnret_type", "dotname", "othertype", "ptrtype", "recvchantype", 746 "structtype", "interfacetype", "xfndcl", "fndcl", "hidden_fndcl", 747 "fntype", "fnbody", "fnres", "fnlitdcl", "fnliteral", "xdcl_list", 748 "vardcl_list", "constdcl_list", "typedcl_list", "structdcl_list", 749 "interfacedcl_list", "structdcl", "packname", "embed", "interfacedcl", 750 "indcl", "arg_type", "arg_type_list", "oarg_type_list_ocomma", "stmt", 751 "non_dcl_stmt", "$@14", "stmt_list", "new_name_list", "dcl_name_list", 752 "expr_list", "expr_or_type_list", "keyval_list", "braced_keyval_list", 753 "osemi", "ocomma", "oexpr", "oexpr_list", "osimple_stmt", 754 "ohidden_funarg_list", "ohidden_structdcl_list", 755 "ohidden_interfacedcl_list", "oliteral", "hidden_import", 756 "hidden_pkg_importsym", "hidden_pkgtype", "hidden_type", 757 "hidden_type_non_recv_chan", "hidden_type_misc", "hidden_type_recv_chan", 758 "hidden_type_func", "hidden_funarg", "hidden_structdcl", 759 "hidden_interfacedcl", "ohidden_funres", "hidden_funres", 760 "hidden_literal", "hidden_constant", "hidden_import_list", 761 "hidden_funarg_list", "hidden_structdcl_list", 762 "hidden_interfacedcl_list", 0 763 }; 764 #endif 765 766 # ifdef YYPRINT 767 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to 768 token YYLEX-NUM. */ 769 static const yytype_uint16 yytoknum[] = 770 { 771 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 772 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 773 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 774 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 775 295, 296, 297, 298, 299, 300, 301, 302, 303, 43, 776 45, 124, 94, 42, 47, 37, 38, 304, 305, 40, 777 41, 306, 59, 46, 36, 61, 58, 123, 125, 33, 778 126, 91, 93, 63, 64, 44 779 }; 780 # endif 781 782 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 783 static const yytype_uint8 yyr1[] = 784 { 785 0, 76, 77, 78, 78, 80, 79, 81, 81, 82, 786 82, 82, 83, 83, 84, 84, 85, 85, 85, 86, 787 87, 87, 89, 88, 90, 90, 90, 90, 90, 91, 788 91, 91, 91, 91, 91, 91, 91, 91, 91, 92, 789 93, 93, 93, 94, 94, 95, 95, 95, 96, 97, 790 98, 98, 98, 98, 98, 98, 99, 99, 99, 99, 791 101, 100, 103, 102, 104, 104, 106, 105, 107, 107, 792 108, 108, 108, 109, 111, 110, 112, 112, 114, 115, 793 116, 113, 118, 117, 119, 119, 120, 120, 122, 123, 794 121, 125, 124, 126, 126, 126, 126, 126, 126, 126, 795 126, 126, 126, 126, 126, 126, 126, 126, 126, 126, 796 126, 126, 126, 126, 127, 127, 127, 127, 127, 127, 797 127, 127, 127, 128, 128, 128, 129, 129, 129, 129, 798 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 799 130, 131, 132, 132, 133, 133, 134, 134, 135, 135, 800 136, 137, 137, 138, 139, 140, 140, 141, 141, 141, 801 142, 142, 143, 144, 145, 145, 146, 146, 146, 146, 802 146, 146, 147, 147, 147, 147, 148, 148, 148, 148, 803 148, 149, 149, 150, 151, 151, 151, 151, 151, 152, 804 152, 153, 153, 153, 153, 153, 153, 153, 154, 155, 805 156, 156, 157, 157, 158, 159, 159, 160, 160, 161, 806 162, 162, 163, 163, 163, 164, 165, 165, 166, 166, 807 167, 167, 168, 168, 169, 169, 170, 170, 171, 171, 808 172, 172, 172, 172, 172, 172, 173, 173, 174, 175, 809 175, 175, 176, 177, 177, 177, 177, 178, 178, 179, 810 179, 180, 180, 180, 180, 180, 181, 181, 181, 181, 811 181, 182, 181, 181, 181, 181, 181, 181, 181, 181, 812 183, 183, 184, 184, 185, 185, 186, 186, 187, 187, 813 188, 188, 188, 188, 189, 189, 190, 190, 191, 191, 814 192, 192, 193, 193, 194, 194, 195, 195, 196, 196, 815 197, 197, 198, 198, 199, 199, 199, 199, 199, 199, 816 200, 201, 202, 202, 202, 203, 203, 204, 204, 204, 817 204, 204, 204, 204, 204, 204, 204, 204, 205, 206, 818 207, 207, 208, 209, 209, 210, 210, 211, 211, 212, 819 212, 212, 213, 213, 214, 214, 215, 215, 216, 216, 820 217, 217 821 }; 822 823 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 824 static const yytype_uint8 yyr2[] = 825 { 826 0, 2, 4, 0, 3, 0, 3, 0, 3, 2, 827 5, 3, 3, 2, 1, 3, 1, 2, 2, 4, 828 0, 1, 0, 4, 0, 1, 1, 1, 1, 2, 829 5, 3, 2, 5, 7, 3, 2, 5, 3, 1, 830 2, 4, 3, 4, 3, 1, 2, 1, 1, 2, 831 1, 3, 3, 3, 2, 2, 3, 5, 5, 2, 832 0, 4, 0, 3, 0, 2, 0, 4, 4, 4, 833 5, 1, 1, 2, 0, 3, 1, 3, 0, 0, 834 0, 8, 0, 5, 0, 2, 0, 2, 0, 0, 835 7, 0, 5, 1, 3, 3, 3, 3, 3, 3, 836 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 837 3, 3, 3, 3, 1, 2, 2, 2, 2, 2, 838 2, 2, 2, 3, 5, 6, 1, 1, 3, 5, 839 5, 4, 6, 8, 1, 5, 5, 5, 7, 1, 840 0, 3, 1, 4, 1, 4, 1, 3, 1, 1, 841 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 842 4, 4, 1, 1, 1, 2, 1, 1, 1, 1, 843 1, 3, 1, 1, 1, 2, 1, 1, 1, 1, 844 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 845 3, 4, 4, 2, 3, 5, 1, 1, 2, 3, 846 5, 3, 5, 3, 3, 5, 8, 5, 8, 5, 847 0, 3, 0, 1, 3, 1, 4, 2, 0, 3, 848 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 849 3, 2, 4, 3, 5, 5, 1, 3, 1, 2, 850 1, 3, 4, 1, 2, 2, 1, 1, 3, 0, 851 2, 0, 1, 1, 1, 1, 1, 1, 1, 1, 852 1, 0, 4, 1, 2, 2, 2, 2, 2, 2, 853 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 854 1, 1, 3, 3, 0, 2, 0, 1, 0, 1, 855 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 856 0, 1, 0, 1, 4, 4, 5, 6, 4, 4, 857 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 858 4, 5, 4, 4, 2, 2, 4, 3, 3, 5, 859 3, 4, 3, 5, 1, 0, 1, 3, 1, 1, 860 2, 1, 1, 5, 0, 2, 1, 3, 1, 3, 861 1, 3 862 }; 863 864 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM. 865 Performed when YYTABLE doesn't specify something else to do. Zero 866 means the default is an error. */ 867 static const yytype_uint16 yydefact[] = 868 { 869 5, 0, 3, 0, 1, 0, 7, 0, 22, 157, 870 159, 0, 0, 158, 218, 20, 6, 344, 0, 4, 871 0, 0, 0, 21, 0, 0, 0, 16, 0, 0, 872 9, 22, 0, 8, 28, 126, 155, 0, 39, 155, 873 0, 263, 74, 0, 0, 0, 78, 0, 0, 292, 874 91, 0, 88, 0, 0, 0, 0, 0, 0, 0, 875 0, 0, 0, 0, 290, 0, 25, 0, 256, 257, 876 260, 258, 259, 50, 93, 134, 146, 114, 163, 162, 877 127, 0, 0, 0, 183, 196, 197, 26, 215, 0, 878 139, 27, 0, 19, 0, 0, 0, 0, 0, 0, 879 345, 160, 161, 11, 14, 286, 18, 22, 13, 17, 880 156, 264, 153, 0, 0, 0, 0, 162, 189, 193, 881 179, 177, 178, 176, 265, 134, 0, 294, 249, 0, 882 210, 134, 268, 294, 151, 152, 0, 0, 276, 293, 883 269, 0, 0, 294, 0, 0, 36, 48, 0, 29, 884 274, 154, 0, 122, 117, 118, 121, 115, 116, 0, 885 0, 148, 0, 149, 174, 172, 173, 119, 120, 0, 886 291, 0, 219, 0, 32, 0, 0, 0, 0, 0, 887 55, 0, 0, 0, 54, 0, 0, 0, 0, 0, 888 0, 0, 0, 0, 0, 0, 0, 0, 0, 140, 889 0, 0, 290, 261, 0, 140, 217, 0, 0, 0, 890 0, 310, 0, 0, 210, 0, 0, 311, 0, 0, 891 23, 287, 0, 12, 249, 0, 0, 194, 170, 168, 892 169, 166, 167, 198, 0, 0, 295, 72, 0, 75, 893 0, 71, 164, 243, 162, 246, 150, 247, 288, 0, 894 249, 0, 204, 79, 76, 157, 0, 203, 0, 286, 895 240, 228, 0, 64, 0, 0, 201, 272, 286, 226, 896 238, 302, 0, 89, 38, 224, 286, 49, 31, 220, 897 286, 0, 0, 40, 0, 175, 147, 0, 0, 35, 898 286, 0, 0, 51, 95, 110, 113, 96, 100, 101, 899 99, 111, 98, 97, 94, 112, 102, 103, 104, 105, 900 106, 107, 108, 109, 284, 123, 278, 288, 0, 128, 901 291, 0, 0, 288, 284, 255, 60, 253, 252, 270, 902 254, 0, 53, 52, 277, 0, 0, 0, 0, 318, 903 0, 0, 0, 0, 0, 317, 0, 312, 313, 314, 904 0, 346, 0, 0, 296, 0, 0, 0, 15, 10, 905 0, 0, 0, 180, 190, 66, 73, 0, 0, 294, 906 165, 244, 245, 289, 250, 212, 0, 0, 0, 294, 907 0, 236, 0, 249, 239, 287, 0, 0, 0, 0, 908 302, 0, 0, 287, 0, 303, 231, 0, 302, 0, 909 287, 0, 287, 0, 42, 275, 0, 0, 0, 199, 910 170, 168, 169, 167, 140, 192, 191, 287, 0, 44, 911 0, 140, 142, 280, 281, 288, 0, 288, 289, 0, 912 0, 0, 131, 290, 262, 289, 0, 0, 0, 0, 913 216, 0, 0, 325, 315, 316, 296, 300, 0, 298, 914 0, 324, 339, 0, 0, 341, 342, 0, 0, 0, 915 0, 0, 302, 0, 0, 309, 0, 297, 304, 308, 916 305, 212, 171, 0, 0, 0, 0, 248, 249, 162, 917 213, 188, 186, 187, 184, 185, 209, 212, 211, 80, 918 77, 237, 241, 0, 229, 202, 195, 0, 0, 92, 919 62, 65, 0, 233, 0, 302, 227, 200, 273, 230, 920 64, 225, 37, 221, 30, 41, 0, 284, 45, 222, 921 286, 47, 33, 43, 284, 0, 289, 285, 137, 0, 922 279, 124, 130, 129, 0, 135, 136, 0, 271, 327, 923 0, 0, 318, 0, 317, 0, 334, 350, 301, 0, 924 0, 0, 348, 299, 328, 340, 0, 306, 0, 319, 925 0, 302, 330, 0, 347, 335, 0, 69, 68, 294, 926 0, 249, 205, 84, 212, 0, 59, 0, 302, 302, 927 232, 0, 171, 0, 287, 0, 46, 0, 140, 144, 928 141, 282, 283, 125, 290, 132, 61, 326, 335, 296, 929 323, 0, 0, 302, 322, 0, 0, 320, 307, 331, 930 296, 296, 338, 207, 336, 67, 70, 214, 0, 86, 931 242, 0, 0, 56, 0, 63, 235, 234, 90, 138, 932 223, 34, 143, 284, 0, 329, 0, 351, 321, 332, 933 349, 0, 0, 0, 212, 0, 85, 81, 0, 0, 934 0, 133, 335, 343, 335, 337, 206, 82, 87, 58, 935 57, 145, 333, 208, 294, 0, 83 936 }; 937 938 /* YYDEFGOTO[NTERM-NUM]. */ 939 static const yytype_int16 yydefgoto[] = 940 { 941 -1, 1, 6, 2, 3, 14, 21, 30, 105, 31, 942 8, 24, 16, 17, 65, 327, 67, 149, 518, 519, 943 145, 146, 68, 500, 328, 438, 501, 577, 388, 366, 944 473, 237, 238, 239, 69, 127, 253, 70, 133, 378, 945 573, 646, 664, 619, 647, 71, 143, 399, 72, 141, 946 73, 74, 75, 76, 314, 423, 424, 590, 77, 316, 947 243, 136, 78, 150, 111, 117, 13, 80, 81, 245, 948 246, 163, 119, 82, 83, 480, 228, 84, 230, 231, 949 85, 86, 87, 130, 214, 88, 252, 486, 89, 90, 950 22, 280, 520, 276, 268, 259, 269, 270, 271, 261, 951 384, 247, 248, 249, 329, 330, 322, 331, 272, 152, 952 92, 317, 425, 426, 222, 374, 171, 140, 254, 466, 953 551, 545, 396, 100, 212, 218, 612, 443, 347, 348, 954 349, 351, 552, 547, 613, 614, 456, 457, 25, 467, 955 553, 548 956 }; 957 958 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 959 STATE-NUM. */ 960 #define YYPACT_NINF -474 961 static const yytype_int16 yypact[] = 962 { 963 -474, 48, 28, 35, -474, 258, -474, 37, -474, -474, 964 -474, 61, 12, -474, 85, 107, -474, -474, 70, -474, 965 156, 82, 1059, -474, 122, 328, 22, -474, 56, 199, 966 -474, 35, 211, -474, -474, -474, 258, 767, -474, 258, 967 459, -474, -474, 152, 459, 258, -474, 23, 145, 1650, 968 -474, 23, -474, 294, 359, 1650, 1650, 1650, 1650, 1650, 969 1650, 1693, 1650, 1650, 1289, 159, -474, 412, -474, -474, 970 -474, -474, -474, 939, -474, -474, 157, 302, -474, 168, 971 -474, 175, 184, 23, 204, -474, -474, -474, 219, 54, 972 -474, -474, 47, -474, 227, -12, 269, 227, 227, 239, 973 -474, -474, -474, -474, -474, 240, -474, -474, -474, -474, 974 -474, -474, -474, 250, 1813, 1813, 1813, -474, 259, -474, 975 -474, -474, -474, -474, -474, 64, 302, 1650, 1805, 262, 976 260, 174, -474, 1650, -474, -474, 221, 1813, 2166, 255, 977 -474, 290, 237, 1650, 304, 1813, -474, -474, 420, -474, 978 -474, -474, 580, -474, -474, -474, -474, -474, -474, 1736, 979 1693, 2166, 280, -474, 253, -474, 50, -474, -474, 275, 980 2166, 285, -474, 430, -474, 612, 1650, 1650, 1650, 1650, 981 -474, 1650, 1650, 1650, -474, 1650, 1650, 1650, 1650, 1650, 982 1650, 1650, 1650, 1650, 1650, 1650, 1650, 1650, 1650, -474, 983 1332, 428, 1650, -474, 1650, -474, -474, 1234, 1650, 1650, 984 1650, -474, 763, 258, 260, 293, 369, -474, 1992, 1992, 985 -474, 51, 326, -474, 1805, 392, 1813, -474, -474, -474, 986 -474, -474, -474, -474, 341, 258, -474, -474, 371, -474, 987 89, 342, 1813, -474, 1805, -474, -474, -474, 335, 360, 988 1805, 1234, -474, -474, 357, 99, 399, -474, 365, 380, 989 -474, -474, 377, -474, 173, 151, -474, -474, 381, -474, 990 -474, 456, 1779, -474, -474, -474, 401, -474, -474, -474, 991 404, 1650, 258, 366, 1838, -474, 405, 1813, 1813, -474, 992 407, 1650, 410, 2166, 650, -474, 2190, 877, 877, 877, 993 877, -474, 877, 877, 2214, -474, 461, 461, 461, 461, 994 -474, -474, -474, -474, 1387, -474, -474, 52, 1442, -474, 995 2064, 411, 1160, 2031, 1387, -474, -474, -474, -474, -474, 996 -474, 19, 255, 255, 2166, 1905, 447, 441, 439, -474, 997 444, 505, 1992, 225, 27, -474, 454, -474, -474, -474, 998 1931, -474, 125, 458, 258, 460, 465, 466, -474, -474, 999 463, 1813, 480, -474, -474, -474, -474, 1497, 1552, 1650, 1000 -474, -474, -474, 1805, -474, 1872, 484, 24, 371, 1650, 1001 258, 485, 487, 1805, -474, 472, 481, 1813, 81, 399, 1002 456, 399, 490, 289, 483, -474, -474, 258, 456, 519, 1003 258, 495, 258, 496, 255, -474, 1650, 1897, 1813, -474, 1004 321, 349, 350, 354, -474, -474, -474, 258, 497, 255, 1005 1650, -474, 2094, -474, -474, 488, 491, 489, 1693, 498, 1006 500, 502, -474, 1650, -474, -474, 506, 503, 1234, 1160, 1007 -474, 1992, 534, -474, -474, -474, 258, 1958, 1992, 258, 1008 1992, -474, -474, 565, 149, -474, -474, 510, 504, 1992, 1009 225, 1992, 456, 258, 258, -474, 514, 507, -474, -474, 1010 -474, 1872, -474, 1234, 1650, 1650, 515, -474, 1805, 520, 1011 -474, -474, -474, -474, -474, -474, -474, 1872, -474, -474, 1012 -474, -474, -474, 518, -474, -474, -474, 1693, 517, -474, 1013 -474, -474, 524, -474, 525, 456, -474, -474, -474, -474, 1014 -474, -474, -474, -474, -474, 255, 526, 1387, -474, -474, 1015 527, 612, -474, 255, 1387, 1595, 1387, -474, -474, 530, 1016 -474, -474, -474, -474, 116, -474, -474, 141, -474, -474, 1017 539, 540, 521, 542, 546, 538, -474, -474, 548, 543, 1018 1992, 549, -474, 552, -474, -474, 562, -474, 1992, -474, 1019 556, 456, -474, 560, -474, 1984, 238, 2166, 2166, 1650, 1020 561, 1805, -474, -474, 1872, 32, -474, 1160, 456, 456, 1021 -474, 186, 370, 554, 258, 563, 410, 557, -474, 2166, 1022 -474, -474, -474, -474, 1650, -474, -474, -474, 1984, 258, 1023 -474, 1958, 1992, 456, -474, 258, 149, -474, -474, -474, 1024 258, 258, -474, -474, -474, -474, -474, -474, 564, 613, 1025 -474, 1650, 1650, -474, 1693, 566, -474, -474, -474, -474, 1026 -474, -474, -474, 1387, 558, -474, 571, -474, -474, -474, 1027 -474, 577, 582, 583, 1872, 36, -474, -474, 2118, 2142, 1028 572, -474, 1984, -474, 1984, -474, -474, -474, -474, -474, 1029 -474, -474, -474, -474, 1650, 371, -474 1030 }; 1031 1032 /* YYPGOTO[NTERM-NUM]. */ 1033 static const yytype_int16 yypgoto[] = 1034 { 1035 -474, -474, -474, -474, -474, -474, -474, -15, -474, -474, 1036 616, -474, -3, -474, -474, 622, -474, -125, -27, 66, 1037 -474, -124, -112, -474, 11, -474, -474, -474, 147, -368, 1038 -474, -474, -474, -474, -474, -474, -140, -474, -474, -474, 1039 -474, -474, -474, -474, -474, -474, -474, -474, -474, -474, 1040 532, 10, 247, -474, -194, 132, 135, -474, 279, -59, 1041 418, 67, 5, 384, 624, 425, 317, 20, -474, 424, 1042 636, 509, -474, -474, -474, -474, -36, -37, -31, -49, 1043 -474, -474, -474, -474, -474, -32, 464, -473, -474, -474, 1044 -474, -474, -474, -474, -474, -474, 277, -119, -231, 287, 1045 -474, 300, -474, -205, -300, 652, -474, -242, -474, -63, 1046 106, 182, -474, -316, -241, -285, -195, -474, -111, -420, 1047 -474, -474, -245, -474, 402, -474, -176, -474, 345, 249, 1048 346, 218, 87, 96, -415, -474, -429, 252, -474, 522, 1049 -474, -474 1050 }; 1051 1052 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 1053 positive, shift that token. If negative, reduce the rule which 1054 number is the opposite. If YYTABLE_NINF, syntax error. */ 1055 #define YYTABLE_NINF -277 1056 static const yytype_int16 yytable[] = 1057 { 1058 121, 120, 162, 273, 175, 123, 122, 321, 437, 377, 1059 489, 324, 165, 104, 572, 236, 241, 260, 386, 360, 1060 275, 236, 434, 279, 164, 556, 541, 394, 108, 166, 1061 458, 236, 429, 390, 392, 401, 346, 621, 436, 403, 1062 174, 110, 356, 357, 110, 376, 101, 213, 4, 418, 1063 132, -215, 208, 5, 27, 206, 657, 118, 134, 27, 1064 7, 15, 11, 427, 18, 153, 154, 155, 156, 157, 1065 158, -267, 167, 168, 19, 9, -267, 229, 229, 229, 1066 9, 439, 232, 232, 232, -215, 439, 440, 497, 134, 1067 135, 229, 488, 498, 367, 102, 232, 622, 623, 459, 1068 229, 620, -236, 326, 223, 232, 20, 624, 229, -181, 1069 175, 165, 209, 232, 29, 229, 103, -215, 142, 29, 1070 232, 135, 210, 164, 10, 11, -267, 428, 166, 10, 1071 11, 23, -267, 26, 118, 118, 118, 382, 229, 538, 1072 527, 258, 529, 232, 33, 503, 290, 267, 118, 499, 1073 205, 165, 452, 509, 368, 139, 207, 118, 502, 27, 1074 504, -236, 380, 164, 210, 118, 451, -236, 166, 153, 1075 157, 656, 118, 9, 462, 381, 9, 641, 493, 636, 1076 9, -266, 594, 635, 93, 463, -266, 229, 595, 229, 1077 642, 643, 232, 497, 232, 118, 537, 381, 498, 453, 1078 464, 583, 106, 439, 391, 229, 358, 229, 587, 596, 1079 232, 128, 232, 229, 109, 28, 137, 562, 232, 29, 1080 517, 172, 10, 11, 199, 10, 11, 524, 452, 10, 1081 11, 566, 389, 240, -153, 229, -266, 662, 534, 663, 1082 232, 203, -266, 204, 118, 255, 118, 411, 410, 9, 1083 229, 229, 413, 412, 628, 232, 232, 236, 476, 431, 1084 580, 255, 118, -182, 118, 539, 260, 236, 490, 165, 1085 118, 546, 549, 570, 554, 453, 511, 513, -181, 585, 1086 256, 164, 9, 559, 454, 561, 166, 125, -183, 257, 1087 264, 131, 118, 216, 10, 11, 265, 666, 10, 11, 1088 439, 11, 221, 220, 118, 266, 615, 118, 118, 224, 1089 10, 11, -182, 255, 332, 333, 609, 650, 9, 126, 1090 -183, 250, 235, 126, 229, 263, 484, 251, 9, 232, 1091 210, 10, 11, 626, 627, 625, 229, 94, 482, 481, 1092 286, 232, 264, 485, 483, 95, 229, 287, 265, 96, 1093 229, 232, 354, 144, 521, 232, -179, 288, 639, 97, 1094 98, 200, 10, 11, 274, 201, 618, 10, 11, 530, 1095 229, 229, 355, 202, 603, 232, 232, 10, 11, 165, 1096 -179, 118, 607, 9, -177, -178, 359, 404, -179, -176, 1097 258, 164, 99, 118, 633, 118, 166, 419, 267, 634, 1098 361, 363, 508, 118, 369, -180, 365, 118, -177, -178, 1099 373, 211, 211, -176, 211, 211, -177, -178, 148, 379, 1100 375, -176, 484, 381, 383, 546, 638, 118, 118, -180, 1101 12, 406, 10, 11, 482, 481, 9, -180, 484, 485, 1102 483, 229, 385, 393, 9, 32, 232, 79, 165, 387, 1103 482, 481, 9, 32, 9, 485, 483, 236, 616, 395, 1104 164, 112, 35, 400, 112, 166, 402, 37, 129, 417, 1105 112, 173, 414, 332, 333, 420, 113, 433, 147, 151, 1106 278, 47, 48, 9, 229, 10, 11, 318, 51, 232, 1107 289, 118, 151, 10, 11, 178, 255, 215, 118, 217, 1108 219, 10, 11, 10, 11, 186, 446, 118, 447, 190, 1109 448, 449, 515, 450, 195, 196, 197, 198, 61, 460, 1110 465, 521, 468, 471, 665, 484, 523, 469, 470, 345, 1111 64, 256, 10, 11, 229, 345, 345, 482, 481, 232, 1112 472, 118, 485, 483, 487, 10, 11, 492, 380, 495, 1113 505, 507, 236, 244, 510, 512, 514, 522, 531, 528, 1114 532, 112, 533, 526, 435, 530, 535, 112, 555, 147, 1115 341, 536, 557, 151, 565, 165, 558, 569, 574, 571, 1116 -157, 138, 464, 576, 578, 579, 582, 164, 37, 584, 1117 593, 118, 166, 161, 118, 484, 170, 113, 151, 597, 1118 598, 599, 47, 48, 9, -158, 600, 482, 481, 51, 1119 601, 606, 485, 483, 605, 602, 225, 604, 608, 610, 1120 37, 617, 629, 631, 644, 632, 319, 645, 439, 113, 1121 651, 652, 79, 115, 47, 48, 9, 653, 350, 226, 1122 661, 51, 654, 655, 66, 281, 32, 107, 225, 244, 1123 630, 64, 345, 10, 11, 282, 658, 581, 591, 345, 1124 364, 592, 371, 124, 118, 115, 405, 345, 372, 285, 1125 506, 226, 494, 477, 91, 244, 79, 291, 353, 575, 1126 444, 445, 564, 64, 178, 10, 11, 282, 181, 182, 1127 183, 540, 640, 185, 186, 187, 188, 637, 190, 191, 1128 192, 193, 194, 195, 196, 197, 198, 151, 293, 294, 1129 295, 296, 560, 297, 298, 299, 0, 300, 301, 302, 1130 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 1131 313, 0, 161, 0, 320, 352, 323, 0, 0, 0, 1132 138, 138, 334, 0, 0, 0, 0, 79, 0, 0, 1133 227, 233, 234, 0, 0, 0, 0, 0, 345, 0, 1134 0, 0, 0, 0, 544, 345, 0, 345, 455, 0, 1135 0, 335, 0, 262, 0, 37, 345, 0, 345, 350, 1136 336, 277, 0, 0, 113, 337, 338, 339, 283, 47, 1137 48, 9, 340, 0, 0, 0, 51, 0, 244, 341, 1138 479, 0, 0, 114, 0, 491, 0, 0, 244, 0, 1139 112, 292, 0, 138, 0, 0, 342, 0, 112, 0, 1140 115, 0, 112, 138, 0, 147, 116, 151, 343, 0, 1141 0, 0, 0, 0, 344, 0, 0, 11, 64, 0, 1142 10, 11, 151, 0, 0, 0, 422, 0, 0, 0, 1143 161, 0, 0, 0, 0, 0, 422, 0, 0, 0, 1144 0, 0, 362, 79, 79, 0, 0, 345, 0, 0, 1145 0, 350, 543, 0, 550, 345, 0, 0, 370, 455, 1146 0, 0, 345, 0, 0, 455, 0, 0, 563, 350, 1147 0, 0, 0, 0, 0, 0, 0, 0, 79, 138, 1148 138, 0, 0, 244, 0, 0, 0, 0, 398, 0, 1149 0, 178, 0, 0, 0, 345, 0, 0, 544, 345, 1150 409, 186, 0, 415, 416, 190, 191, 192, 193, 194, 1151 195, 196, 197, 198, 0, 0, 0, 0, 138, 0, 1152 0, 0, 0, 176, -276, 0, 0, 0, 0, 0, 1153 0, 0, 138, 0, 0, 0, 0, 0, 0, 0, 1154 161, 0, 0, 0, 0, 170, 0, 0, 0, 345, 1155 0, 345, 177, 178, 0, 179, 180, 181, 182, 183, 1156 0, 184, 185, 186, 187, 188, 189, 190, 191, 192, 1157 193, 194, 195, 196, 197, 198, 244, 409, 0, 0, 1158 0, 0, 79, 0, -276, 0, 567, 568, 0, 151, 1159 0, 0, 0, 0, -276, 0, 0, 0, 0, 0, 1160 0, 0, 0, 496, 350, 0, 543, 0, 0, 161, 1161 550, 455, 0, 0, 0, 350, 350, 0, 0, 0, 1162 0, 0, 0, 227, 516, 0, 0, 0, 0, 422, 1163 0, 0, 0, 0, 0, 0, 422, 589, 422, -2, 1164 34, 0, 35, 0, 0, 36, 0, 37, 38, 39, 1165 0, 0, 40, 0, 41, 42, 43, 44, 45, 46, 1166 0, 47, 48, 9, 0, 0, 49, 50, 51, 52, 1167 53, 54, 0, 0, 0, 55, 0, 0, 0, 0, 1168 0, 0, 0, 0, 0, 0, 0, 0, 56, 57, 1169 0, 58, 59, 0, 0, 60, 0, 0, 61, 0, 1170 0, -24, 0, 0, 0, 0, 170, 0, 62, 63, 1171 64, 0, 10, 11, 0, 0, 0, 0, 0, 0, 1172 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1173 0, 0, 0, 648, 649, 0, 161, 586, 0, 0, 1174 0, 325, 0, 35, 0, 422, 36, -251, 37, 38, 1175 39, 0, -251, 40, 0, 41, 42, 113, 44, 45, 1176 46, 0, 47, 48, 9, 0, 0, 49, 50, 51, 1177 52, 53, 54, 0, 0, 0, 55, 0, 0, 0, 1178 0, 0, 0, 0, 0, 0, 0, 0, 0, 56, 1179 57, 0, 58, 59, 0, 0, 60, 0, 0, 61, 1180 0, 0, -251, 0, 0, 0, 0, 326, -251, 62, 1181 63, 64, 0, 10, 11, 325, 0, 35, 0, 0, 1182 36, 0, 37, 38, 39, 0, 0, 40, 0, 41, 1183 42, 113, 44, 45, 46, 0, 47, 48, 9, 0, 1184 0, 49, 50, 51, 52, 53, 54, 0, 0, 0, 1185 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1186 0, 0, 0, 56, 57, 0, 58, 59, 0, 0, 1187 60, 0, 35, 61, 0, 0, -251, 37, 0, 0, 1188 169, 326, -251, 62, 63, 64, 113, 10, 11, 0, 1189 0, 47, 48, 9, 0, 0, 0, 0, 51, 0, 1190 0, 0, 0, 0, 0, 55, 0, 0, 0, 0, 1191 0, 0, 0, 0, 0, 35, 0, 0, 56, 57, 1192 37, 58, 59, 0, 0, 60, 0, 0, 61, 113, 1193 0, 0, 0, 0, 47, 48, 9, 0, 62, 63, 1194 64, 51, 10, 11, 0, 0, 0, 0, 159, 0, 1195 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1196 0, 56, 57, 0, 58, 160, 0, 0, 60, 0, 1197 35, 61, 315, 0, 0, 37, 0, 0, 0, 0, 1198 0, 62, 63, 64, 113, 10, 11, 0, 0, 47, 1199 48, 9, 0, 0, 0, 0, 51, 0, 0, 0, 1200 0, 0, 0, 55, 0, 0, 0, 0, 0, 0, 1201 0, 0, 0, 0, 0, 0, 56, 57, 0, 58, 1202 59, 0, 0, 60, 0, 35, 61, 0, 0, 0, 1203 37, 0, 0, 0, 421, 0, 62, 63, 64, 113, 1204 10, 11, 0, 0, 47, 48, 9, 0, 0, 0, 1205 0, 51, 0, 430, 0, 0, 0, 0, 159, 0, 1206 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1207 0, 56, 57, 0, 58, 160, 0, 0, 60, 0, 1208 35, 61, 0, 0, 0, 37, 0, 0, 0, 0, 1209 0, 62, 63, 64, 113, 10, 11, 0, 0, 47, 1210 48, 9, 0, 474, 0, 0, 51, 0, 0, 0, 1211 0, 0, 0, 55, 0, 0, 0, 0, 0, 0, 1212 0, 0, 0, 0, 0, 0, 56, 57, 0, 58, 1213 59, 0, 0, 60, 0, 35, 61, 0, 0, 0, 1214 37, 0, 0, 0, 0, 0, 62, 63, 64, 113, 1215 10, 11, 0, 0, 47, 48, 9, 0, 475, 0, 1216 0, 51, 0, 0, 0, 0, 0, 0, 55, 0, 1217 0, 0, 0, 0, 0, 0, 0, 0, 35, 0, 1218 0, 56, 57, 37, 58, 59, 0, 0, 60, 0, 1219 0, 61, 113, 0, 0, 0, 0, 47, 48, 9, 1220 0, 62, 63, 64, 51, 10, 11, 0, 0, 0, 1221 0, 55, 0, 0, 0, 0, 0, 0, 0, 0, 1222 0, 0, 0, 0, 56, 57, 0, 58, 59, 0, 1223 0, 60, 0, 35, 61, 0, 0, 0, 37, 0, 1224 0, 0, 588, 0, 62, 63, 64, 113, 10, 11, 1225 0, 0, 47, 48, 9, 0, 0, 0, 0, 51, 1226 0, 0, 0, 0, 0, 0, 55, 0, 0, 0, 1227 0, 0, 0, 0, 0, 0, 35, 0, 0, 56, 1228 57, 37, 58, 59, 0, 0, 60, 0, 0, 61, 1229 113, 0, 0, 0, 0, 47, 48, 9, 0, 62, 1230 63, 64, 51, 10, 11, 0, 0, 0, 0, 159, 1231 0, 0, 0, 0, 0, 0, 0, 0, 0, 35, 1232 0, 0, 56, 57, 284, 58, 160, 0, 0, 60, 1233 0, 0, 61, 113, 0, 0, 0, 0, 47, 48, 1234 9, 0, 62, 63, 64, 51, 10, 11, 0, 0, 1235 0, 0, 55, 0, 0, 0, 0, 0, 0, 0, 1236 0, 0, 0, 0, 0, 56, 57, 37, 58, 59, 1237 0, 0, 60, 0, 0, 61, 113, 0, 0, 0, 1238 0, 47, 48, 9, 0, 62, 63, 64, 51, 10, 1239 11, 0, 0, 37, 0, 225, 242, 0, 0, 0, 1240 0, 37, 113, 0, 0, 0, 0, 47, 48, 9, 1241 113, 0, 115, 0, 51, 47, 48, 9, 226, 0, 1242 0, 225, 51, 0, 0, 0, 37, 0, 0, 225, 1243 64, 0, 10, 11, 397, 113, 0, 0, 115, 0, 1244 47, 48, 9, 0, 226, 0, 115, 51, 0, 0, 1245 0, 0, 226, 0, 407, 0, 64, 0, 10, 11, 1246 37, 0, 0, 0, 64, 0, 10, 11, 0, 113, 1247 0, 115, 0, 0, 47, 48, 9, 408, 0, 0, 1248 0, 51, 0, 0, 0, 284, 0, 0, 225, 64, 1249 0, 10, 11, 335, 113, 0, 0, 0, 0, 47, 1250 48, 9, 336, 0, 0, 115, 51, 337, 338, 339, 1251 0, 478, 0, 225, 340, 0, 0, 0, 0, 335, 1252 0, 441, 461, 64, 0, 10, 11, 0, 336, 0, 1253 115, 0, 0, 337, 338, 339, 226, 0, 342, 0, 1254 340, 0, 0, 0, 442, 0, 335, 341, 64, 0, 1255 10, 11, 0, 0, 0, 336, 344, 0, 0, 11, 1256 337, 338, 542, 0, 342, 0, 0, 340, 0, 0, 1257 0, 0, 335, 0, 341, 0, 0, 0, 0, 0, 1258 335, 336, 344, 0, 0, 11, 337, 338, 339, 336, 1259 0, 342, 0, 340, 337, 338, 339, 0, 0, 0, 1260 341, 340, 0, 0, 0, 0, 0, 0, 341, 344, 1261 0, 10, 11, 0, 0, 0, 0, 342, 0, 0, 1262 0, 0, 0, 611, 0, 342, 0, 0, 0, 0, 1263 0, 0, 0, 0, 0, 344, 0, 0, 11, 0, 1264 0, 0, 0, 344, 177, 178, 11, 179, 0, 181, 1265 182, 183, 0, 0, 185, 186, 187, 188, 189, 190, 1266 191, 192, 193, 194, 195, 196, 197, 198, 0, 0, 1267 0, 0, 0, 0, 0, 0, 0, 177, 178, 0, 1268 179, 0, 181, 182, 183, 0, 435, 185, 186, 187, 1269 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 1270 198, 0, 0, 0, 0, 0, 0, 177, 178, 0, 1271 179, 0, 181, 182, 183, 0, 432, 185, 186, 187, 1272 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 1273 198, 177, 178, 0, 179, 0, 181, 182, 183, 0, 1274 525, 185, 186, 187, 188, 189, 190, 191, 192, 193, 1275 194, 195, 196, 197, 198, 177, 178, 0, 179, 0, 1276 181, 182, 183, 0, 659, 185, 186, 187, 188, 189, 1277 190, 191, 192, 193, 194, 195, 196, 197, 198, 177, 1278 178, 0, 179, 0, 181, 182, 183, 0, 660, 185, 1279 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 1280 196, 197, 198, 177, 178, 0, 0, 0, 181, 182, 1281 183, 0, 0, 185, 186, 187, 188, 189, 190, 191, 1282 192, 193, 194, 195, 196, 197, 198, 177, 178, 0, 1283 0, 0, 181, 182, 183, 0, 0, 185, 186, 187, 1284 188, 0, 190, 191, 192, 193, 194, 195, 196, 197, 1285 198 1286 }; 1287 1288 #define yypact_value_is_default(yystate) \ 1289 ((yystate) == (-474)) 1290 1291 #define yytable_value_is_error(yytable_value) \ 1292 YYID (0) 1293 1294 static const yytype_int16 yycheck[] = 1295 { 1296 37, 37, 61, 143, 67, 37, 37, 202, 324, 251, 1297 378, 205, 61, 28, 487, 127, 127, 136, 259, 224, 1298 144, 133, 322, 148, 61, 454, 446, 268, 31, 61, 1299 3, 143, 317, 264, 265, 276, 212, 5, 323, 280, 1300 67, 36, 218, 219, 39, 250, 24, 59, 0, 290, 1301 45, 1, 5, 25, 3, 1, 20, 37, 35, 3, 1302 25, 24, 74, 11, 3, 55, 56, 57, 58, 59, 1303 60, 7, 62, 63, 62, 24, 12, 114, 115, 116, 1304 24, 62, 114, 115, 116, 35, 62, 68, 7, 35, 1305 67, 128, 68, 12, 5, 73, 128, 65, 66, 72, 1306 137, 574, 3, 67, 107, 137, 21, 75, 145, 59, 1307 173, 160, 65, 145, 63, 152, 60, 67, 51, 63, 1308 152, 67, 75, 160, 73, 74, 62, 75, 160, 73, 1309 74, 24, 68, 63, 114, 115, 116, 256, 175, 439, 1310 425, 136, 427, 175, 62, 390, 173, 142, 128, 68, 1311 83, 200, 3, 398, 65, 49, 89, 137, 389, 3, 1312 391, 62, 63, 200, 75, 145, 342, 68, 200, 159, 1313 160, 644, 152, 24, 350, 24, 24, 606, 383, 599, 1314 24, 7, 66, 598, 62, 60, 12, 224, 72, 226, 1315 610, 611, 224, 7, 226, 175, 438, 24, 12, 50, 1316 75, 517, 3, 62, 53, 242, 221, 244, 524, 68, 1317 242, 59, 244, 250, 3, 59, 71, 462, 250, 63, 1318 414, 62, 73, 74, 67, 73, 74, 421, 3, 73, 1319 74, 473, 59, 127, 66, 272, 62, 652, 433, 654, 1320 272, 66, 68, 59, 224, 24, 226, 284, 284, 24, 1321 287, 288, 284, 284, 68, 287, 288, 369, 369, 318, 1322 505, 24, 242, 59, 244, 441, 385, 379, 379, 318, 1323 250, 447, 448, 478, 450, 50, 400, 402, 59, 520, 1324 59, 318, 24, 459, 59, 461, 318, 40, 35, 68, 1325 53, 44, 272, 24, 73, 74, 59, 665, 73, 74, 1326 62, 74, 62, 64, 284, 68, 68, 287, 288, 59, 1327 73, 74, 59, 24, 208, 209, 561, 633, 24, 40, 1328 67, 59, 63, 44, 361, 35, 375, 67, 24, 361, 1329 75, 73, 74, 578, 579, 577, 373, 9, 375, 375, 1330 60, 373, 53, 375, 375, 17, 383, 72, 59, 21, 1331 387, 383, 59, 59, 417, 387, 35, 72, 603, 31, 1332 32, 59, 73, 74, 60, 63, 571, 73, 74, 428, 1333 407, 408, 3, 71, 550, 407, 408, 73, 74, 428, 1334 59, 361, 558, 24, 35, 35, 60, 281, 67, 35, 1335 385, 428, 64, 373, 588, 375, 428, 291, 393, 594, 1336 8, 60, 397, 383, 62, 35, 35, 387, 59, 59, 1337 75, 94, 95, 59, 97, 98, 67, 67, 59, 62, 1338 60, 67, 471, 24, 59, 601, 602, 407, 408, 59, 1339 5, 65, 73, 74, 471, 471, 24, 67, 487, 471, 1340 471, 478, 62, 62, 24, 20, 478, 22, 497, 72, 1341 487, 487, 24, 28, 24, 487, 487, 569, 569, 3, 1342 497, 36, 3, 62, 39, 497, 62, 8, 43, 62, 1343 45, 59, 67, 367, 368, 65, 17, 66, 53, 54, 1344 60, 22, 23, 24, 521, 73, 74, 59, 29, 521, 1345 60, 471, 67, 73, 74, 34, 24, 95, 478, 97, 1346 98, 73, 74, 73, 74, 44, 59, 487, 67, 48, 1347 71, 67, 406, 8, 53, 54, 55, 56, 59, 65, 1348 62, 584, 62, 60, 664, 574, 420, 62, 62, 212, 1349 71, 59, 73, 74, 571, 218, 219, 574, 574, 571, 1350 60, 521, 574, 574, 60, 73, 74, 60, 63, 68, 1351 60, 68, 664, 128, 35, 60, 60, 60, 60, 68, 1352 60, 136, 60, 75, 75, 624, 60, 142, 3, 144, 1353 36, 68, 62, 148, 60, 624, 72, 62, 60, 59, 1354 59, 49, 75, 66, 60, 60, 60, 624, 8, 62, 1355 60, 571, 624, 61, 574, 644, 64, 17, 173, 60, 1356 60, 59, 22, 23, 24, 59, 68, 644, 644, 29, 1357 62, 49, 644, 644, 62, 72, 36, 68, 62, 59, 1358 8, 60, 68, 60, 60, 68, 201, 14, 62, 17, 1359 72, 60, 207, 53, 22, 23, 24, 60, 213, 59, 1360 68, 29, 60, 60, 22, 65, 221, 31, 36, 224, 1361 584, 71, 335, 73, 74, 75, 645, 510, 526, 342, 1362 235, 526, 244, 39, 644, 53, 282, 350, 244, 160, 1363 393, 59, 385, 373, 22, 250, 251, 65, 214, 497, 1364 335, 335, 464, 71, 34, 73, 74, 75, 38, 39, 1365 40, 442, 605, 43, 44, 45, 46, 601, 48, 49, 1366 50, 51, 52, 53, 54, 55, 56, 282, 176, 177, 1367 178, 179, 460, 181, 182, 183, -1, 185, 186, 187, 1368 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 1369 198, -1, 200, -1, 202, 213, 204, -1, -1, -1, 1370 208, 209, 210, -1, -1, -1, -1, 322, -1, -1, 1371 114, 115, 116, -1, -1, -1, -1, -1, 441, -1, 1372 -1, -1, -1, -1, 447, 448, -1, 450, 343, -1, 1373 -1, 8, -1, 137, -1, 8, 459, -1, 461, 354, 1374 17, 145, -1, -1, 17, 22, 23, 24, 152, 22, 1375 23, 24, 29, -1, -1, -1, 29, -1, 373, 36, 1376 375, -1, -1, 36, -1, 380, -1, -1, 383, -1, 1377 385, 175, -1, 281, -1, -1, 53, -1, 393, -1, 1378 53, -1, 397, 291, -1, 400, 59, 402, 65, -1, 1379 -1, -1, -1, -1, 71, -1, -1, 74, 71, -1, 1380 73, 74, 417, -1, -1, -1, 314, -1, -1, -1, 1381 318, -1, -1, -1, -1, -1, 324, -1, -1, -1, 1382 -1, -1, 226, 438, 439, -1, -1, 550, -1, -1, 1383 -1, 446, 447, -1, 449, 558, -1, -1, 242, 454, 1384 -1, -1, 565, -1, -1, 460, -1, -1, 463, 464, 1385 -1, -1, -1, -1, -1, -1, -1, -1, 473, 367, 1386 368, -1, -1, 478, -1, -1, -1, -1, 272, -1, 1387 -1, 34, -1, -1, -1, 598, -1, -1, 601, 602, 1388 284, 44, -1, 287, 288, 48, 49, 50, 51, 52, 1389 53, 54, 55, 56, -1, -1, -1, -1, 406, -1, 1390 -1, -1, -1, 4, 5, -1, -1, -1, -1, -1, 1391 -1, -1, 420, -1, -1, -1, -1, -1, -1, -1, 1392 428, -1, -1, -1, -1, 433, -1, -1, -1, 652, 1393 -1, 654, 33, 34, -1, 36, 37, 38, 39, 40, 1394 -1, 42, 43, 44, 45, 46, 47, 48, 49, 50, 1395 51, 52, 53, 54, 55, 56, 571, 361, -1, -1, 1396 -1, -1, 577, -1, 65, -1, 474, 475, -1, 584, 1397 -1, -1, -1, -1, 75, -1, -1, -1, -1, -1, 1398 -1, -1, -1, 387, 599, -1, 601, -1, -1, 497, 1399 605, 606, -1, -1, -1, 610, 611, -1, -1, -1, 1400 -1, -1, -1, 407, 408, -1, -1, -1, -1, 517, 1401 -1, -1, -1, -1, -1, -1, 524, 525, 526, 0, 1402 1, -1, 3, -1, -1, 6, -1, 8, 9, 10, 1403 -1, -1, 13, -1, 15, 16, 17, 18, 19, 20, 1404 -1, 22, 23, 24, -1, -1, 27, 28, 29, 30, 1405 31, 32, -1, -1, -1, 36, -1, -1, -1, -1, 1406 -1, -1, -1, -1, -1, -1, -1, -1, 49, 50, 1407 -1, 52, 53, -1, -1, 56, -1, -1, 59, -1, 1408 -1, 62, -1, -1, -1, -1, 594, -1, 69, 70, 1409 71, -1, 73, 74, -1, -1, -1, -1, -1, -1, 1410 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1411 -1, -1, -1, 621, 622, -1, 624, 521, -1, -1, 1412 -1, 1, -1, 3, -1, 633, 6, 7, 8, 9, 1413 10, -1, 12, 13, -1, 15, 16, 17, 18, 19, 1414 20, -1, 22, 23, 24, -1, -1, 27, 28, 29, 1415 30, 31, 32, -1, -1, -1, 36, -1, -1, -1, 1416 -1, -1, -1, -1, -1, -1, -1, -1, -1, 49, 1417 50, -1, 52, 53, -1, -1, 56, -1, -1, 59, 1418 -1, -1, 62, -1, -1, -1, -1, 67, 68, 69, 1419 70, 71, -1, 73, 74, 1, -1, 3, -1, -1, 1420 6, -1, 8, 9, 10, -1, -1, 13, -1, 15, 1421 16, 17, 18, 19, 20, -1, 22, 23, 24, -1, 1422 -1, 27, 28, 29, 30, 31, 32, -1, -1, -1, 1423 36, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1424 -1, -1, -1, 49, 50, -1, 52, 53, -1, -1, 1425 56, -1, 3, 59, -1, -1, 62, 8, -1, -1, 1426 11, 67, 68, 69, 70, 71, 17, 73, 74, -1, 1427 -1, 22, 23, 24, -1, -1, -1, -1, 29, -1, 1428 -1, -1, -1, -1, -1, 36, -1, -1, -1, -1, 1429 -1, -1, -1, -1, -1, 3, -1, -1, 49, 50, 1430 8, 52, 53, -1, -1, 56, -1, -1, 59, 17, 1431 -1, -1, -1, -1, 22, 23, 24, -1, 69, 70, 1432 71, 29, 73, 74, -1, -1, -1, -1, 36, -1, 1433 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1434 -1, 49, 50, -1, 52, 53, -1, -1, 56, -1, 1435 3, 59, 60, -1, -1, 8, -1, -1, -1, -1, 1436 -1, 69, 70, 71, 17, 73, 74, -1, -1, 22, 1437 23, 24, -1, -1, -1, -1, 29, -1, -1, -1, 1438 -1, -1, -1, 36, -1, -1, -1, -1, -1, -1, 1439 -1, -1, -1, -1, -1, -1, 49, 50, -1, 52, 1440 53, -1, -1, 56, -1, 3, 59, -1, -1, -1, 1441 8, -1, -1, -1, 67, -1, 69, 70, 71, 17, 1442 73, 74, -1, -1, 22, 23, 24, -1, -1, -1, 1443 -1, 29, -1, 31, -1, -1, -1, -1, 36, -1, 1444 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1445 -1, 49, 50, -1, 52, 53, -1, -1, 56, -1, 1446 3, 59, -1, -1, -1, 8, -1, -1, -1, -1, 1447 -1, 69, 70, 71, 17, 73, 74, -1, -1, 22, 1448 23, 24, -1, 26, -1, -1, 29, -1, -1, -1, 1449 -1, -1, -1, 36, -1, -1, -1, -1, -1, -1, 1450 -1, -1, -1, -1, -1, -1, 49, 50, -1, 52, 1451 53, -1, -1, 56, -1, 3, 59, -1, -1, -1, 1452 8, -1, -1, -1, -1, -1, 69, 70, 71, 17, 1453 73, 74, -1, -1, 22, 23, 24, -1, 26, -1, 1454 -1, 29, -1, -1, -1, -1, -1, -1, 36, -1, 1455 -1, -1, -1, -1, -1, -1, -1, -1, 3, -1, 1456 -1, 49, 50, 8, 52, 53, -1, -1, 56, -1, 1457 -1, 59, 17, -1, -1, -1, -1, 22, 23, 24, 1458 -1, 69, 70, 71, 29, 73, 74, -1, -1, -1, 1459 -1, 36, -1, -1, -1, -1, -1, -1, -1, -1, 1460 -1, -1, -1, -1, 49, 50, -1, 52, 53, -1, 1461 -1, 56, -1, 3, 59, -1, -1, -1, 8, -1, 1462 -1, -1, 67, -1, 69, 70, 71, 17, 73, 74, 1463 -1, -1, 22, 23, 24, -1, -1, -1, -1, 29, 1464 -1, -1, -1, -1, -1, -1, 36, -1, -1, -1, 1465 -1, -1, -1, -1, -1, -1, 3, -1, -1, 49, 1466 50, 8, 52, 53, -1, -1, 56, -1, -1, 59, 1467 17, -1, -1, -1, -1, 22, 23, 24, -1, 69, 1468 70, 71, 29, 73, 74, -1, -1, -1, -1, 36, 1469 -1, -1, -1, -1, -1, -1, -1, -1, -1, 3, 1470 -1, -1, 49, 50, 8, 52, 53, -1, -1, 56, 1471 -1, -1, 59, 17, -1, -1, -1, -1, 22, 23, 1472 24, -1, 69, 70, 71, 29, 73, 74, -1, -1, 1473 -1, -1, 36, -1, -1, -1, -1, -1, -1, -1, 1474 -1, -1, -1, -1, -1, 49, 50, 8, 52, 53, 1475 -1, -1, 56, -1, -1, 59, 17, -1, -1, -1, 1476 -1, 22, 23, 24, -1, 69, 70, 71, 29, 73, 1477 74, -1, -1, 8, -1, 36, 11, -1, -1, -1, 1478 -1, 8, 17, -1, -1, -1, -1, 22, 23, 24, 1479 17, -1, 53, -1, 29, 22, 23, 24, 59, -1, 1480 -1, 36, 29, -1, -1, -1, 8, -1, -1, 36, 1481 71, -1, 73, 74, 75, 17, -1, -1, 53, -1, 1482 22, 23, 24, -1, 59, -1, 53, 29, -1, -1, 1483 -1, -1, 59, -1, 36, -1, 71, -1, 73, 74, 1484 8, -1, -1, -1, 71, -1, 73, 74, -1, 17, 1485 -1, 53, -1, -1, 22, 23, 24, 59, -1, -1, 1486 -1, 29, -1, -1, -1, 8, -1, -1, 36, 71, 1487 -1, 73, 74, 8, 17, -1, -1, -1, -1, 22, 1488 23, 24, 17, -1, -1, 53, 29, 22, 23, 24, 1489 -1, 59, -1, 36, 29, -1, -1, -1, -1, 8, 1490 -1, 36, 11, 71, -1, 73, 74, -1, 17, -1, 1491 53, -1, -1, 22, 23, 24, 59, -1, 53, -1, 1492 29, -1, -1, -1, 59, -1, 8, 36, 71, -1, 1493 73, 74, -1, -1, -1, 17, 71, -1, -1, 74, 1494 22, 23, 24, -1, 53, -1, -1, 29, -1, -1, 1495 -1, -1, 8, -1, 36, -1, -1, -1, -1, -1, 1496 8, 17, 71, -1, -1, 74, 22, 23, 24, 17, 1497 -1, 53, -1, 29, 22, 23, 24, -1, -1, -1, 1498 36, 29, -1, -1, -1, -1, -1, -1, 36, 71, 1499 -1, 73, 74, -1, -1, -1, -1, 53, -1, -1, 1500 -1, -1, -1, 59, -1, 53, -1, -1, -1, -1, 1501 -1, -1, -1, -1, -1, 71, -1, -1, 74, -1, 1502 -1, -1, -1, 71, 33, 34, 74, 36, -1, 38, 1503 39, 40, -1, -1, 43, 44, 45, 46, 47, 48, 1504 49, 50, 51, 52, 53, 54, 55, 56, -1, -1, 1505 -1, -1, -1, -1, -1, -1, -1, 33, 34, -1, 1506 36, -1, 38, 39, 40, -1, 75, 43, 44, 45, 1507 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 1508 56, -1, -1, -1, -1, -1, -1, 33, 34, -1, 1509 36, -1, 38, 39, 40, -1, 72, 43, 44, 45, 1510 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 1511 56, 33, 34, -1, 36, -1, 38, 39, 40, -1, 1512 66, 43, 44, 45, 46, 47, 48, 49, 50, 51, 1513 52, 53, 54, 55, 56, 33, 34, -1, 36, -1, 1514 38, 39, 40, -1, 66, 43, 44, 45, 46, 47, 1515 48, 49, 50, 51, 52, 53, 54, 55, 56, 33, 1516 34, -1, 36, -1, 38, 39, 40, -1, 66, 43, 1517 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 1518 54, 55, 56, 33, 34, -1, -1, -1, 38, 39, 1519 40, -1, -1, 43, 44, 45, 46, 47, 48, 49, 1520 50, 51, 52, 53, 54, 55, 56, 33, 34, -1, 1521 -1, -1, 38, 39, 40, -1, -1, 43, 44, 45, 1522 46, -1, 48, 49, 50, 51, 52, 53, 54, 55, 1523 56 1524 }; 1525 1526 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 1527 symbol of state STATE-NUM. */ 1528 static const yytype_uint8 yystos[] = 1529 { 1530 0, 77, 79, 80, 0, 25, 78, 25, 86, 24, 1531 73, 74, 141, 142, 81, 24, 88, 89, 3, 62, 1532 21, 82, 166, 24, 87, 214, 63, 3, 59, 63, 1533 83, 85, 141, 62, 1, 3, 6, 8, 9, 10, 1534 13, 15, 16, 17, 18, 19, 20, 22, 23, 27, 1535 28, 29, 30, 31, 32, 36, 49, 50, 52, 53, 1536 56, 59, 69, 70, 71, 90, 91, 92, 98, 110, 1537 113, 121, 124, 126, 127, 128, 129, 134, 138, 141, 1538 143, 144, 149, 150, 153, 156, 157, 158, 161, 164, 1539 165, 181, 186, 62, 9, 17, 21, 31, 32, 64, 1540 199, 24, 73, 60, 83, 84, 3, 86, 88, 3, 1541 138, 140, 141, 17, 36, 53, 59, 141, 143, 148, 1542 152, 153, 154, 161, 140, 128, 134, 111, 59, 141, 1543 159, 128, 138, 114, 35, 67, 137, 71, 126, 186, 1544 193, 125, 137, 122, 59, 96, 97, 141, 59, 93, 1545 139, 141, 185, 127, 127, 127, 127, 127, 127, 36, 1546 53, 126, 135, 147, 153, 155, 161, 127, 127, 11, 1547 126, 192, 62, 59, 94, 185, 4, 33, 34, 36, 1548 37, 38, 39, 40, 42, 43, 44, 45, 46, 47, 1549 48, 49, 50, 51, 52, 53, 54, 55, 56, 67, 1550 59, 63, 71, 66, 59, 137, 1, 137, 5, 65, 1551 75, 142, 200, 59, 160, 200, 24, 200, 201, 200, 1552 64, 62, 190, 88, 59, 36, 59, 146, 152, 153, 1553 154, 155, 161, 146, 146, 63, 98, 107, 108, 109, 1554 186, 194, 11, 136, 141, 145, 146, 177, 178, 179, 1555 59, 67, 162, 112, 194, 24, 59, 68, 138, 171, 1556 173, 175, 146, 35, 53, 59, 68, 138, 170, 172, 1557 173, 174, 184, 112, 60, 97, 169, 146, 60, 93, 1558 167, 65, 75, 146, 8, 147, 60, 72, 72, 60, 1559 94, 65, 146, 126, 126, 126, 126, 126, 126, 126, 1560 126, 126, 126, 126, 126, 126, 126, 126, 126, 126, 1561 126, 126, 126, 126, 130, 60, 135, 187, 59, 141, 1562 126, 192, 182, 126, 130, 1, 67, 91, 100, 180, 1563 181, 183, 186, 186, 126, 8, 17, 22, 23, 24, 1564 29, 36, 53, 65, 71, 142, 202, 204, 205, 206, 1565 141, 207, 215, 162, 59, 3, 202, 202, 83, 60, 1566 179, 8, 146, 60, 141, 35, 105, 5, 65, 62, 1567 146, 136, 145, 75, 191, 60, 179, 183, 115, 62, 1568 63, 24, 173, 59, 176, 62, 190, 72, 104, 59, 1569 174, 53, 174, 62, 190, 3, 198, 75, 146, 123, 1570 62, 190, 62, 190, 186, 139, 65, 36, 59, 146, 1571 152, 153, 154, 161, 67, 146, 146, 62, 190, 186, 1572 65, 67, 126, 131, 132, 188, 189, 11, 75, 191, 1573 31, 135, 72, 66, 180, 75, 191, 189, 101, 62, 1574 68, 36, 59, 203, 204, 206, 59, 67, 71, 67, 1575 8, 202, 3, 50, 59, 141, 212, 213, 3, 72, 1576 65, 11, 202, 60, 75, 62, 195, 215, 62, 62, 1577 62, 60, 60, 106, 26, 26, 194, 177, 59, 141, 1578 151, 152, 153, 154, 155, 161, 163, 60, 68, 105, 1579 194, 141, 60, 179, 175, 68, 146, 7, 12, 68, 1580 99, 102, 174, 198, 174, 60, 172, 68, 138, 198, 1581 35, 97, 60, 93, 60, 186, 146, 130, 94, 95, 1582 168, 185, 60, 186, 130, 66, 75, 191, 68, 191, 1583 135, 60, 60, 60, 192, 60, 68, 183, 180, 202, 1584 205, 195, 24, 141, 142, 197, 202, 209, 217, 202, 1585 141, 196, 208, 216, 202, 3, 212, 62, 72, 202, 1586 213, 202, 198, 141, 207, 60, 183, 126, 126, 62, 1587 179, 59, 163, 116, 60, 187, 66, 103, 60, 60, 1588 198, 104, 60, 189, 62, 190, 146, 189, 67, 126, 1589 133, 131, 132, 60, 66, 72, 68, 60, 60, 59, 1590 68, 62, 72, 202, 68, 62, 49, 202, 62, 198, 1591 59, 59, 202, 210, 211, 68, 194, 60, 179, 119, 1592 163, 5, 65, 66, 75, 183, 198, 198, 68, 68, 1593 95, 60, 68, 130, 192, 210, 195, 209, 202, 198, 1594 208, 212, 195, 195, 60, 14, 117, 120, 126, 126, 1595 189, 72, 60, 60, 60, 60, 163, 20, 100, 66, 1596 66, 68, 210, 210, 118, 112, 105 1597 }; 1598 1599 #define yyerrok (yyerrstatus = 0) 1600 #define yyclearin (yychar = YYEMPTY) 1601 #define YYEMPTY (-2) 1602 #define YYEOF 0 1603 1604 #define YYACCEPT goto yyacceptlab 1605 #define YYABORT goto yyabortlab 1606 #define YYERROR goto yyerrorlab 1607 1608 1609 /* Like YYERROR except do call yyerror. This remains here temporarily 1610 to ease the transition to the new meaning of YYERROR, for GCC. 1611 Once GCC version 2 has supplanted version 1, this can go. However, 1612 YYFAIL appears to be in use. Nevertheless, it is formally deprecated 1613 in Bison 2.4.2's NEWS entry, where a plan to phase it out is 1614 discussed. */ 1615 1616 #define YYFAIL goto yyerrlab 1617 #if defined YYFAIL 1618 /* This is here to suppress warnings from the GCC cpp's 1619 -Wunused-macros. Normally we don't worry about that warning, but 1620 some users do, and we want to make it easy for users to remove 1621 YYFAIL uses, which will produce warnings from Bison 2.5. */ 1622 #endif 1623 1624 #define YYRECOVERING() (!!yyerrstatus) 1625 1626 #define YYBACKUP(Token, Value) \ 1627 do \ 1628 if (yychar == YYEMPTY && yylen == 1) \ 1629 { \ 1630 yychar = (Token); \ 1631 yylval = (Value); \ 1632 YYPOPSTACK (1); \ 1633 goto yybackup; \ 1634 } \ 1635 else \ 1636 { \ 1637 yyerror (YY_("syntax error: cannot back up")); \ 1638 YYERROR; \ 1639 } \ 1640 while (YYID (0)) 1641 1642 1643 #define YYTERROR 1 1644 #define YYERRCODE 256 1645 1646 1647 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. 1648 If N is 0, then set CURRENT to the empty location which ends 1649 the previous symbol: RHS[0] (always defined). */ 1650 1651 #define YYRHSLOC(Rhs, K) ((Rhs)[K]) 1652 #ifndef YYLLOC_DEFAULT 1653 # define YYLLOC_DEFAULT(Current, Rhs, N) \ 1654 do \ 1655 if (YYID (N)) \ 1656 { \ 1657 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ 1658 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ 1659 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ 1660 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ 1661 } \ 1662 else \ 1663 { \ 1664 (Current).first_line = (Current).last_line = \ 1665 YYRHSLOC (Rhs, 0).last_line; \ 1666 (Current).first_column = (Current).last_column = \ 1667 YYRHSLOC (Rhs, 0).last_column; \ 1668 } \ 1669 while (YYID (0)) 1670 #endif 1671 1672 1673 /* This macro is provided for backward compatibility. */ 1674 1675 #ifndef YY_LOCATION_PRINT 1676 # define YY_LOCATION_PRINT(File, Loc) ((void) 0) 1677 #endif 1678 1679 1680 /* YYLEX -- calling `yylex' with the right arguments. */ 1681 1682 #ifdef YYLEX_PARAM 1683 # define YYLEX yylex (YYLEX_PARAM) 1684 #else 1685 # define YYLEX yylex () 1686 #endif 1687 1688 /* Enable debugging if requested. */ 1689 #if YYDEBUG 1690 1691 # ifndef YYFPRINTF 1692 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 1693 # define YYFPRINTF fprintf 1694 # endif 1695 1696 # define YYDPRINTF(Args) \ 1697 do { \ 1698 if (yydebug) \ 1699 YYFPRINTF Args; \ 1700 } while (YYID (0)) 1701 1702 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 1703 do { \ 1704 if (yydebug) \ 1705 { \ 1706 YYFPRINTF (stderr, "%s ", Title); \ 1707 yy_symbol_print (stderr, \ 1708 Type, Value); \ 1709 YYFPRINTF (stderr, "\n"); \ 1710 } \ 1711 } while (YYID (0)) 1712 1713 1714 /*--------------------------------. 1715 | Print this symbol on YYOUTPUT. | 1716 `--------------------------------*/ 1717 1718 /*ARGSUSED*/ 1719 #if (defined __STDC__ || defined __C99__FUNC__ \ 1720 || defined __cplusplus || defined _MSC_VER) 1721 static void 1722 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 1723 #else 1724 static void 1725 yy_symbol_value_print (yyoutput, yytype, yyvaluep) 1726 FILE *yyoutput; 1727 int yytype; 1728 YYSTYPE const * const yyvaluep; 1729 #endif 1730 { 1731 if (!yyvaluep) 1732 return; 1733 # ifdef YYPRINT 1734 if (yytype < YYNTOKENS) 1735 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 1736 # else 1737 YYUSE (yyoutput); 1738 # endif 1739 switch (yytype) 1740 { 1741 default: 1742 break; 1743 } 1744 } 1745 1746 1747 /*--------------------------------. 1748 | Print this symbol on YYOUTPUT. | 1749 `--------------------------------*/ 1750 1751 #if (defined __STDC__ || defined __C99__FUNC__ \ 1752 || defined __cplusplus || defined _MSC_VER) 1753 static void 1754 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 1755 #else 1756 static void 1757 yy_symbol_print (yyoutput, yytype, yyvaluep) 1758 FILE *yyoutput; 1759 int yytype; 1760 YYSTYPE const * const yyvaluep; 1761 #endif 1762 { 1763 if (yytype < YYNTOKENS) 1764 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); 1765 else 1766 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); 1767 1768 yy_symbol_value_print (yyoutput, yytype, yyvaluep); 1769 YYFPRINTF (yyoutput, ")"); 1770 } 1771 1772 /*------------------------------------------------------------------. 1773 | yy_stack_print -- Print the state stack from its BOTTOM up to its | 1774 | TOP (included). | 1775 `------------------------------------------------------------------*/ 1776 1777 #if (defined __STDC__ || defined __C99__FUNC__ \ 1778 || defined __cplusplus || defined _MSC_VER) 1779 static void 1780 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) 1781 #else 1782 static void 1783 yy_stack_print (yybottom, yytop) 1784 yytype_int16 *yybottom; 1785 yytype_int16 *yytop; 1786 #endif 1787 { 1788 YYFPRINTF (stderr, "Stack now"); 1789 for (; yybottom <= yytop; yybottom++) 1790 { 1791 int yybot = *yybottom; 1792 YYFPRINTF (stderr, " %d", yybot); 1793 } 1794 YYFPRINTF (stderr, "\n"); 1795 } 1796 1797 # define YY_STACK_PRINT(Bottom, Top) \ 1798 do { \ 1799 if (yydebug) \ 1800 yy_stack_print ((Bottom), (Top)); \ 1801 } while (YYID (0)) 1802 1803 1804 /*------------------------------------------------. 1805 | Report that the YYRULE is going to be reduced. | 1806 `------------------------------------------------*/ 1807 1808 #if (defined __STDC__ || defined __C99__FUNC__ \ 1809 || defined __cplusplus || defined _MSC_VER) 1810 static void 1811 yy_reduce_print (YYSTYPE *yyvsp, int yyrule) 1812 #else 1813 static void 1814 yy_reduce_print (yyvsp, yyrule) 1815 YYSTYPE *yyvsp; 1816 int yyrule; 1817 #endif 1818 { 1819 int yynrhs = yyr2[yyrule]; 1820 int yyi; 1821 unsigned long int yylno = yyrline[yyrule]; 1822 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", 1823 yyrule - 1, yylno); 1824 /* The symbols being reduced. */ 1825 for (yyi = 0; yyi < yynrhs; yyi++) 1826 { 1827 YYFPRINTF (stderr, " $%d = ", yyi + 1); 1828 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], 1829 &(yyvsp[(yyi + 1) - (yynrhs)]) 1830 ); 1831 YYFPRINTF (stderr, "\n"); 1832 } 1833 } 1834 1835 # define YY_REDUCE_PRINT(Rule) \ 1836 do { \ 1837 if (yydebug) \ 1838 yy_reduce_print (yyvsp, Rule); \ 1839 } while (YYID (0)) 1840 1841 /* Nonzero means print parse trace. It is left uninitialized so that 1842 multiple parsers can coexist. */ 1843 int yydebug; 1844 #else /* !YYDEBUG */ 1845 # define YYDPRINTF(Args) 1846 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) 1847 # define YY_STACK_PRINT(Bottom, Top) 1848 # define YY_REDUCE_PRINT(Rule) 1849 #endif /* !YYDEBUG */ 1850 1851 1852 /* YYINITDEPTH -- initial size of the parser's stacks. */ 1853 #ifndef YYINITDEPTH 1854 # define YYINITDEPTH 200 1855 #endif 1856 1857 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 1858 if the built-in stack extension method is used). 1859 1860 Do not make this value too large; the results are undefined if 1861 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 1862 evaluated with infinite-precision integer arithmetic. */ 1863 1864 #ifndef YYMAXDEPTH 1865 # define YYMAXDEPTH 10000 1866 #endif 1867 1868 1869 #if YYERROR_VERBOSE 1870 1871 # ifndef yystrlen 1872 # if defined __GLIBC__ && defined _STRING_H 1873 # define yystrlen strlen 1874 # else 1875 /* Return the length of YYSTR. */ 1876 #if (defined __STDC__ || defined __C99__FUNC__ \ 1877 || defined __cplusplus || defined _MSC_VER) 1878 static YYSIZE_T 1879 yystrlen (const char *yystr) 1880 #else 1881 static YYSIZE_T 1882 yystrlen (yystr) 1883 const char *yystr; 1884 #endif 1885 { 1886 YYSIZE_T yylen; 1887 for (yylen = 0; yystr[yylen]; yylen++) 1888 continue; 1889 return yylen; 1890 } 1891 # endif 1892 # endif 1893 1894 # ifndef yystpcpy 1895 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 1896 # define yystpcpy stpcpy 1897 # else 1898 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 1899 YYDEST. */ 1900 #if (defined __STDC__ || defined __C99__FUNC__ \ 1901 || defined __cplusplus || defined _MSC_VER) 1902 static char * 1903 yystpcpy (char *yydest, const char *yysrc) 1904 #else 1905 static char * 1906 yystpcpy (yydest, yysrc) 1907 char *yydest; 1908 const char *yysrc; 1909 #endif 1910 { 1911 char *yyd = yydest; 1912 const char *yys = yysrc; 1913 1914 while ((*yyd++ = *yys++) != '\0') 1915 continue; 1916 1917 return yyd - 1; 1918 } 1919 # endif 1920 # endif 1921 1922 # ifndef yytnamerr 1923 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary 1924 quotes and backslashes, so that it's suitable for yyerror. The 1925 heuristic is that double-quoting is unnecessary unless the string 1926 contains an apostrophe, a comma, or backslash (other than 1927 backslash-backslash). YYSTR is taken from yytname. If YYRES is 1928 null, do not copy; instead, return the length of what the result 1929 would have been. */ 1930 static YYSIZE_T 1931 yytnamerr (char *yyres, const char *yystr) 1932 { 1933 if (*yystr == '"') 1934 { 1935 YYSIZE_T yyn = 0; 1936 char const *yyp = yystr; 1937 1938 for (;;) 1939 switch (*++yyp) 1940 { 1941 case '\'': 1942 case ',': 1943 goto do_not_strip_quotes; 1944 1945 case '\\': 1946 if (*++yyp != '\\') 1947 goto do_not_strip_quotes; 1948 /* Fall through. */ 1949 default: 1950 if (yyres) 1951 yyres[yyn] = *yyp; 1952 yyn++; 1953 break; 1954 1955 case '"': 1956 if (yyres) 1957 yyres[yyn] = '\0'; 1958 return yyn; 1959 } 1960 do_not_strip_quotes: ; 1961 } 1962 1963 if (! yyres) 1964 return yystrlen (yystr); 1965 1966 return yystpcpy (yyres, yystr) - yyres; 1967 } 1968 # endif 1969 1970 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message 1971 about the unexpected token YYTOKEN for the state stack whose top is 1972 YYSSP. 1973 1974 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is 1975 not large enough to hold the message. In that case, also set 1976 *YYMSG_ALLOC to the required number of bytes. Return 2 if the 1977 required number of bytes is too large to store. */ 1978 static int 1979 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, 1980 yytype_int16 *yyssp, int yytoken) 1981 { 1982 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]); 1983 YYSIZE_T yysize = yysize0; 1984 YYSIZE_T yysize1; 1985 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 1986 /* Internationalized format string. */ 1987 const char *yyformat = 0; 1988 /* Arguments of yyformat. */ 1989 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 1990 /* Number of reported tokens (one for the "unexpected", one per 1991 "expected"). */ 1992 int yycount = 0; 1993 1994 /* There are many possibilities here to consider: 1995 - Assume YYFAIL is not used. It's too flawed to consider. See 1996 <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html> 1997 for details. YYERROR is fine as it does not invoke this 1998 function. 1999 - If this state is a consistent state with a default action, then 2000 the only way this function was invoked is if the default action 2001 is an error action. In that case, don't check for expected 2002 tokens because there are none. 2003 - The only way there can be no lookahead present (in yychar) is if 2004 this state is a consistent state with a default action. Thus, 2005 detecting the absence of a lookahead is sufficient to determine 2006 that there is no unexpected or expected token to report. In that 2007 case, just report a simple "syntax error". 2008 - Don't assume there isn't a lookahead just because this state is a 2009 consistent state with a default action. There might have been a 2010 previous inconsistent state, consistent state with a non-default 2011 action, or user semantic action that manipulated yychar. 2012 - Of course, the expected token list depends on states to have 2013 correct lookahead information, and it depends on the parser not 2014 to perform extra reductions after fetching a lookahead from the 2015 scanner and before detecting a syntax error. Thus, state merging 2016 (from LALR or IELR) and default reductions corrupt the expected 2017 token list. However, the list is correct for canonical LR with 2018 one exception: it will still contain any token that will not be 2019 accepted due to an error action in a later state. 2020 */ 2021 if (yytoken != YYEMPTY) 2022 { 2023 int yyn = yypact[*yyssp]; 2024 yyarg[yycount++] = yytname[yytoken]; 2025 if (!yypact_value_is_default (yyn)) 2026 { 2027 /* Start YYX at -YYN if negative to avoid negative indexes in 2028 YYCHECK. In other words, skip the first -YYN actions for 2029 this state because they are default actions. */ 2030 int yyxbegin = yyn < 0 ? -yyn : 0; 2031 /* Stay within bounds of both yycheck and yytname. */ 2032 int yychecklim = YYLAST - yyn + 1; 2033 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 2034 int yyx; 2035 2036 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 2037 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR 2038 && !yytable_value_is_error (yytable[yyx + yyn])) 2039 { 2040 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 2041 { 2042 yycount = 1; 2043 yysize = yysize0; 2044 break; 2045 } 2046 yyarg[yycount++] = yytname[yyx]; 2047 yysize1 = yysize + yytnamerr (0, yytname[yyx]); 2048 if (! (yysize <= yysize1 2049 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 2050 return 2; 2051 yysize = yysize1; 2052 } 2053 } 2054 } 2055 2056 switch (yycount) 2057 { 2058 # define YYCASE_(N, S) \ 2059 case N: \ 2060 yyformat = S; \ 2061 break 2062 YYCASE_(0, YY_("syntax error")); 2063 YYCASE_(1, YY_("syntax error, unexpected %s")); 2064 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); 2065 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); 2066 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); 2067 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); 2068 # undef YYCASE_ 2069 } 2070 2071 yysize1 = yysize + yystrlen (yyformat); 2072 if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 2073 return 2; 2074 yysize = yysize1; 2075 2076 if (*yymsg_alloc < yysize) 2077 { 2078 *yymsg_alloc = 2 * yysize; 2079 if (! (yysize <= *yymsg_alloc 2080 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) 2081 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; 2082 return 1; 2083 } 2084 2085 /* Avoid sprintf, as that infringes on the user's name space. 2086 Don't have undefined behavior even if the translation 2087 produced a string with the wrong number of "%s"s. */ 2088 { 2089 char *yyp = *yymsg; 2090 int yyi = 0; 2091 while ((*yyp = *yyformat) != '\0') 2092 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) 2093 { 2094 yyp += yytnamerr (yyp, yyarg[yyi++]); 2095 yyformat += 2; 2096 } 2097 else 2098 { 2099 yyp++; 2100 yyformat++; 2101 } 2102 } 2103 return 0; 2104 } 2105 #endif /* YYERROR_VERBOSE */ 2106 2107 /*-----------------------------------------------. 2108 | Release the memory associated to this symbol. | 2109 `-----------------------------------------------*/ 2110 2111 /*ARGSUSED*/ 2112 #if (defined __STDC__ || defined __C99__FUNC__ \ 2113 || defined __cplusplus || defined _MSC_VER) 2114 static void 2115 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) 2116 #else 2117 static void 2118 yydestruct (yymsg, yytype, yyvaluep) 2119 const char *yymsg; 2120 int yytype; 2121 YYSTYPE *yyvaluep; 2122 #endif 2123 { 2124 YYUSE (yyvaluep); 2125 2126 if (!yymsg) 2127 yymsg = "Deleting"; 2128 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 2129 2130 switch (yytype) 2131 { 2132 2133 default: 2134 break; 2135 } 2136 } 2137 2138 2139 /* Prevent warnings from -Wmissing-prototypes. */ 2140 #ifdef YYPARSE_PARAM 2141 #if defined __STDC__ || defined __cplusplus 2142 int yyparse (void *YYPARSE_PARAM); 2143 #else 2144 int yyparse (); 2145 #endif 2146 #else /* ! YYPARSE_PARAM */ 2147 #if defined __STDC__ || defined __cplusplus 2148 int yyparse (void); 2149 #else 2150 int yyparse (); 2151 #endif 2152 #endif /* ! YYPARSE_PARAM */ 2153 2154 2155 /* The lookahead symbol. */ 2156 int yychar, yystate; 2157 2158 /* The semantic value of the lookahead symbol. */ 2159 YYSTYPE yylval; 2160 2161 /* Number of syntax errors so far. */ 2162 int yynerrs; 2163 2164 2165 /*----------. 2166 | yyparse. | 2167 `----------*/ 2168 2169 #ifdef YYPARSE_PARAM 2170 #if (defined __STDC__ || defined __C99__FUNC__ \ 2171 || defined __cplusplus || defined _MSC_VER) 2172 int 2173 yyparse (void *YYPARSE_PARAM) 2174 #else 2175 int 2176 yyparse (YYPARSE_PARAM) 2177 void *YYPARSE_PARAM; 2178 #endif 2179 #else /* ! YYPARSE_PARAM */ 2180 #if (defined __STDC__ || defined __C99__FUNC__ \ 2181 || defined __cplusplus || defined _MSC_VER) 2182 int 2183 yyparse (void) 2184 #else 2185 int 2186 yyparse () 2187 2188 #endif 2189 #endif 2190 { 2191 /* Number of tokens to shift before error messages enabled. */ 2192 int yyerrstatus; 2193 2194 /* The stacks and their tools: 2195 `yyss': related to states. 2196 `yyvs': related to semantic values. 2197 2198 Refer to the stacks thru separate pointers, to allow yyoverflow 2199 to reallocate them elsewhere. */ 2200 2201 /* The state stack. */ 2202 yytype_int16 yyssa[YYINITDEPTH]; 2203 yytype_int16 *yyss; 2204 yytype_int16 *yyssp; 2205 2206 /* The semantic value stack. */ 2207 YYSTYPE yyvsa[YYINITDEPTH]; 2208 YYSTYPE *yyvs; 2209 YYSTYPE *yyvsp; 2210 2211 YYSIZE_T yystacksize; 2212 2213 int yyn; 2214 int yyresult; 2215 /* Lookahead token as an internal (translated) token number. */ 2216 int yytoken; 2217 /* The variables used to return semantic value and location from the 2218 action routines. */ 2219 YYSTYPE yyval; 2220 2221 #if YYERROR_VERBOSE 2222 /* Buffer for error messages, and its allocated size. */ 2223 char yymsgbuf[128]; 2224 char *yymsg = yymsgbuf; 2225 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 2226 #endif 2227 2228 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 2229 2230 /* The number of symbols on the RHS of the reduced rule. 2231 Keep to zero when no symbol should be popped. */ 2232 int yylen = 0; 2233 2234 yytoken = 0; 2235 yyss = yyssa; 2236 yyvs = yyvsa; 2237 yystacksize = YYINITDEPTH; 2238 2239 YYDPRINTF ((stderr, "Starting parse\n")); 2240 2241 yystate = 0; 2242 yyerrstatus = 0; 2243 yynerrs = 0; 2244 yychar = YYEMPTY; /* Cause a token to be read. */ 2245 2246 /* Initialize stack pointers. 2247 Waste one element of value and location stack 2248 so that they stay on the same level as the state stack. 2249 The wasted elements are never initialized. */ 2250 yyssp = yyss; 2251 yyvsp = yyvs; 2252 2253 goto yysetstate; 2254 2255 /*------------------------------------------------------------. 2256 | yynewstate -- Push a new state, which is found in yystate. | 2257 `------------------------------------------------------------*/ 2258 yynewstate: 2259 /* In all cases, when you get here, the value and location stacks 2260 have just been pushed. So pushing a state here evens the stacks. */ 2261 yyssp++; 2262 2263 yysetstate: 2264 *yyssp = yystate; 2265 2266 if (yyss + yystacksize - 1 <= yyssp) 2267 { 2268 /* Get the current used size of the three stacks, in elements. */ 2269 YYSIZE_T yysize = yyssp - yyss + 1; 2270 2271 #ifdef yyoverflow 2272 { 2273 /* Give user a chance to reallocate the stack. Use copies of 2274 these so that the &'s don't force the real ones into 2275 memory. */ 2276 YYSTYPE *yyvs1 = yyvs; 2277 yytype_int16 *yyss1 = yyss; 2278 2279 /* Each stack pointer address is followed by the size of the 2280 data in use in that stack, in bytes. This used to be a 2281 conditional around just the two extra args, but that might 2282 be undefined if yyoverflow is a macro. */ 2283 yyoverflow (YY_("memory exhausted"), 2284 &yyss1, yysize * sizeof (*yyssp), 2285 &yyvs1, yysize * sizeof (*yyvsp), 2286 &yystacksize); 2287 2288 yyss = yyss1; 2289 yyvs = yyvs1; 2290 } 2291 #else /* no yyoverflow */ 2292 # ifndef YYSTACK_RELOCATE 2293 goto yyexhaustedlab; 2294 # else 2295 /* Extend the stack our own way. */ 2296 if (YYMAXDEPTH <= yystacksize) 2297 goto yyexhaustedlab; 2298 yystacksize *= 2; 2299 if (YYMAXDEPTH < yystacksize) 2300 yystacksize = YYMAXDEPTH; 2301 2302 { 2303 yytype_int16 *yyss1 = yyss; 2304 union yyalloc *yyptr = 2305 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 2306 if (! yyptr) 2307 goto yyexhaustedlab; 2308 YYSTACK_RELOCATE (yyss_alloc, yyss); 2309 YYSTACK_RELOCATE (yyvs_alloc, yyvs); 2310 # undef YYSTACK_RELOCATE 2311 if (yyss1 != yyssa) 2312 YYSTACK_FREE (yyss1); 2313 } 2314 # endif 2315 #endif /* no yyoverflow */ 2316 2317 yyssp = yyss + yysize - 1; 2318 yyvsp = yyvs + yysize - 1; 2319 2320 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 2321 (unsigned long int) yystacksize)); 2322 2323 if (yyss + yystacksize - 1 <= yyssp) 2324 YYABORT; 2325 } 2326 2327 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 2328 2329 if (yystate == YYFINAL) 2330 YYACCEPT; 2331 2332 goto yybackup; 2333 2334 /*-----------. 2335 | yybackup. | 2336 `-----------*/ 2337 yybackup: 2338 2339 /* Do appropriate processing given the current state. Read a 2340 lookahead token if we need one and don't already have one. */ 2341 2342 /* First try to decide what to do without reference to lookahead token. */ 2343 yyn = yypact[yystate]; 2344 if (yypact_value_is_default (yyn)) 2345 goto yydefault; 2346 2347 /* Not known => get a lookahead token if don't already have one. */ 2348 2349 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 2350 if (yychar == YYEMPTY) 2351 { 2352 YYDPRINTF ((stderr, "Reading a token: ")); 2353 yychar = YYLEX; 2354 } 2355 2356 if (yychar <= YYEOF) 2357 { 2358 yychar = yytoken = YYEOF; 2359 YYDPRINTF ((stderr, "Now at end of input.\n")); 2360 } 2361 else 2362 { 2363 yytoken = YYTRANSLATE (yychar); 2364 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 2365 } 2366 2367 /* If the proper action on seeing token YYTOKEN is to reduce or to 2368 detect an error, take that action. */ 2369 yyn += yytoken; 2370 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 2371 goto yydefault; 2372 yyn = yytable[yyn]; 2373 if (yyn <= 0) 2374 { 2375 if (yytable_value_is_error (yyn)) 2376 goto yyerrlab; 2377 yyn = -yyn; 2378 goto yyreduce; 2379 } 2380 2381 /* Count tokens shifted since error; after three, turn off error 2382 status. */ 2383 if (yyerrstatus) 2384 yyerrstatus--; 2385 2386 /* Shift the lookahead token. */ 2387 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 2388 2389 /* Discard the shifted token. */ 2390 yychar = YYEMPTY; 2391 2392 yystate = yyn; 2393 *++yyvsp = yylval; 2394 2395 goto yynewstate; 2396 2397 2398 /*-----------------------------------------------------------. 2399 | yydefault -- do the default action for the current state. | 2400 `-----------------------------------------------------------*/ 2401 yydefault: 2402 yyn = yydefact[yystate]; 2403 if (yyn == 0) 2404 goto yyerrlab; 2405 goto yyreduce; 2406 2407 2408 /*-----------------------------. 2409 | yyreduce -- Do a reduction. | 2410 `-----------------------------*/ 2411 yyreduce: 2412 /* yyn is the number of a rule to reduce with. */ 2413 yylen = yyr2[yyn]; 2414 2415 /* If YYLEN is nonzero, implement the default value of the action: 2416 `$$ = $1'. 2417 2418 Otherwise, the following line sets YYVAL to garbage. 2419 This behavior is undocumented and Bison 2420 users should not rely upon it. Assigning to YYVAL 2421 unconditionally makes the parser a bit smaller, and it avoids a 2422 GCC warning that YYVAL may be used uninitialized. */ 2423 yyval = yyvsp[1-yylen]; 2424 2425 2426 YY_REDUCE_PRINT (yyn); 2427 switch (yyn) 2428 { 2429 case 2: 2430 2431 /* Line 1806 of yacc.c */ 2432 #line 128 "go.y" 2433 { 2434 xtop = concat(xtop, (yyvsp[(4) - (4)].list)); 2435 } 2436 break; 2437 2438 case 3: 2439 2440 /* Line 1806 of yacc.c */ 2441 #line 134 "go.y" 2442 { 2443 prevlineno = lineno; 2444 yyerror("package statement must be first"); 2445 errorexit(); 2446 } 2447 break; 2448 2449 case 4: 2450 2451 /* Line 1806 of yacc.c */ 2452 #line 140 "go.y" 2453 { 2454 mkpackage((yyvsp[(2) - (3)].sym)->name); 2455 } 2456 break; 2457 2458 case 5: 2459 2460 /* Line 1806 of yacc.c */ 2461 #line 150 "go.y" 2462 { 2463 importpkg = runtimepkg; 2464 2465 if(debug['A']) 2466 cannedimports("runtime.builtin", "package runtime\n\n$$\n\n"); 2467 else 2468 cannedimports("runtime.builtin", runtimeimport); 2469 curio.importsafe = 1; 2470 } 2471 break; 2472 2473 case 6: 2474 2475 /* Line 1806 of yacc.c */ 2476 #line 161 "go.y" 2477 { 2478 importpkg = nil; 2479 } 2480 break; 2481 2482 case 12: 2483 2484 /* Line 1806 of yacc.c */ 2485 #line 175 "go.y" 2486 { 2487 Pkg *ipkg; 2488 Sym *my; 2489 Node *pack; 2490 2491 ipkg = importpkg; 2492 my = importmyname; 2493 importpkg = nil; 2494 importmyname = S; 2495 2496 if(my == nil) 2497 my = lookup(ipkg->name); 2498 2499 pack = nod(OPACK, N, N); 2500 pack->sym = my; 2501 pack->pkg = ipkg; 2502 pack->lineno = (yyvsp[(1) - (3)].i); 2503 2504 if(my->name[0] == '.') { 2505 importdot(ipkg, pack); 2506 break; 2507 } 2508 if(strcmp(my->name, "init") == 0) { 2509 yyerror("cannot import package as init - init must be a func"); 2510 break; 2511 } 2512 if(my->name[0] == '_' && my->name[1] == '\0') 2513 break; 2514 if(my->def) { 2515 lineno = (yyvsp[(1) - (3)].i); 2516 redeclare(my, "as imported package name"); 2517 } 2518 my->def = pack; 2519 my->lastlineno = (yyvsp[(1) - (3)].i); 2520 my->block = 1; // at top level 2521 } 2522 break; 2523 2524 case 13: 2525 2526 /* Line 1806 of yacc.c */ 2527 #line 212 "go.y" 2528 { 2529 // When an invalid import path is passed to importfile, 2530 // it calls yyerror and then sets up a fake import with 2531 // no package statement. This allows us to test more 2532 // than one invalid import statement in a single file. 2533 if(nerrors == 0) 2534 fatal("phase error in import"); 2535 } 2536 break; 2537 2538 case 16: 2539 2540 /* Line 1806 of yacc.c */ 2541 #line 227 "go.y" 2542 { 2543 // import with original name 2544 (yyval.i) = parserline(); 2545 importmyname = S; 2546 importfile(&(yyvsp[(1) - (1)].val), (yyval.i)); 2547 } 2548 break; 2549 2550 case 17: 2551 2552 /* Line 1806 of yacc.c */ 2553 #line 234 "go.y" 2554 { 2555 // import with given name 2556 (yyval.i) = parserline(); 2557 importmyname = (yyvsp[(1) - (2)].sym); 2558 importfile(&(yyvsp[(2) - (2)].val), (yyval.i)); 2559 } 2560 break; 2561 2562 case 18: 2563 2564 /* Line 1806 of yacc.c */ 2565 #line 241 "go.y" 2566 { 2567 // import into my name space 2568 (yyval.i) = parserline(); 2569 importmyname = lookup("."); 2570 importfile(&(yyvsp[(2) - (2)].val), (yyval.i)); 2571 } 2572 break; 2573 2574 case 19: 2575 2576 /* Line 1806 of yacc.c */ 2577 #line 250 "go.y" 2578 { 2579 if(importpkg->name == nil) { 2580 importpkg->name = (yyvsp[(2) - (4)].sym)->name; 2581 pkglookup((yyvsp[(2) - (4)].sym)->name, nil)->npkg++; 2582 } else if(strcmp(importpkg->name, (yyvsp[(2) - (4)].sym)->name) != 0) 2583 yyerror("conflicting names %s and %s for package \"%Z\"", importpkg->name, (yyvsp[(2) - (4)].sym)->name, importpkg->path); 2584 importpkg->direct = 1; 2585 importpkg->safe = curio.importsafe; 2586 2587 if(safemode && !curio.importsafe) 2588 yyerror("cannot import unsafe package \"%Z\"", importpkg->path); 2589 } 2590 break; 2591 2592 case 21: 2593 2594 /* Line 1806 of yacc.c */ 2595 #line 265 "go.y" 2596 { 2597 if(strcmp((yyvsp[(1) - (1)].sym)->name, "safe") == 0) 2598 curio.importsafe = 1; 2599 } 2600 break; 2601 2602 case 22: 2603 2604 /* Line 1806 of yacc.c */ 2605 #line 271 "go.y" 2606 { 2607 defercheckwidth(); 2608 } 2609 break; 2610 2611 case 23: 2612 2613 /* Line 1806 of yacc.c */ 2614 #line 275 "go.y" 2615 { 2616 resumecheckwidth(); 2617 unimportfile(); 2618 } 2619 break; 2620 2621 case 24: 2622 2623 /* Line 1806 of yacc.c */ 2624 #line 284 "go.y" 2625 { 2626 yyerror("empty top-level declaration"); 2627 (yyval.list) = nil; 2628 } 2629 break; 2630 2631 case 26: 2632 2633 /* Line 1806 of yacc.c */ 2634 #line 290 "go.y" 2635 { 2636 (yyval.list) = list1((yyvsp[(1) - (1)].node)); 2637 } 2638 break; 2639 2640 case 27: 2641 2642 /* Line 1806 of yacc.c */ 2643 #line 294 "go.y" 2644 { 2645 yyerror("non-declaration statement outside function body"); 2646 (yyval.list) = nil; 2647 } 2648 break; 2649 2650 case 28: 2651 2652 /* Line 1806 of yacc.c */ 2653 #line 299 "go.y" 2654 { 2655 (yyval.list) = nil; 2656 } 2657 break; 2658 2659 case 29: 2660 2661 /* Line 1806 of yacc.c */ 2662 #line 305 "go.y" 2663 { 2664 (yyval.list) = (yyvsp[(2) - (2)].list); 2665 } 2666 break; 2667 2668 case 30: 2669 2670 /* Line 1806 of yacc.c */ 2671 #line 309 "go.y" 2672 { 2673 (yyval.list) = (yyvsp[(3) - (5)].list); 2674 } 2675 break; 2676 2677 case 31: 2678 2679 /* Line 1806 of yacc.c */ 2680 #line 313 "go.y" 2681 { 2682 (yyval.list) = nil; 2683 } 2684 break; 2685 2686 case 32: 2687 2688 /* Line 1806 of yacc.c */ 2689 #line 317 "go.y" 2690 { 2691 (yyval.list) = (yyvsp[(2) - (2)].list); 2692 iota = -100000; 2693 lastconst = nil; 2694 } 2695 break; 2696 2697 case 33: 2698 2699 /* Line 1806 of yacc.c */ 2700 #line 323 "go.y" 2701 { 2702 (yyval.list) = (yyvsp[(3) - (5)].list); 2703 iota = -100000; 2704 lastconst = nil; 2705 } 2706 break; 2707 2708 case 34: 2709 2710 /* Line 1806 of yacc.c */ 2711 #line 329 "go.y" 2712 { 2713 (yyval.list) = concat((yyvsp[(3) - (7)].list), (yyvsp[(5) - (7)].list)); 2714 iota = -100000; 2715 lastconst = nil; 2716 } 2717 break; 2718 2719 case 35: 2720 2721 /* Line 1806 of yacc.c */ 2722 #line 335 "go.y" 2723 { 2724 (yyval.list) = nil; 2725 iota = -100000; 2726 } 2727 break; 2728 2729 case 36: 2730 2731 /* Line 1806 of yacc.c */ 2732 #line 340 "go.y" 2733 { 2734 (yyval.list) = list1((yyvsp[(2) - (2)].node)); 2735 } 2736 break; 2737 2738 case 37: 2739 2740 /* Line 1806 of yacc.c */ 2741 #line 344 "go.y" 2742 { 2743 (yyval.list) = (yyvsp[(3) - (5)].list); 2744 } 2745 break; 2746 2747 case 38: 2748 2749 /* Line 1806 of yacc.c */ 2750 #line 348 "go.y" 2751 { 2752 (yyval.list) = nil; 2753 } 2754 break; 2755 2756 case 39: 2757 2758 /* Line 1806 of yacc.c */ 2759 #line 354 "go.y" 2760 { 2761 iota = 0; 2762 } 2763 break; 2764 2765 case 40: 2766 2767 /* Line 1806 of yacc.c */ 2768 #line 360 "go.y" 2769 { 2770 (yyval.list) = variter((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node), nil); 2771 } 2772 break; 2773 2774 case 41: 2775 2776 /* Line 1806 of yacc.c */ 2777 #line 364 "go.y" 2778 { 2779 (yyval.list) = variter((yyvsp[(1) - (4)].list), (yyvsp[(2) - (4)].node), (yyvsp[(4) - (4)].list)); 2780 } 2781 break; 2782 2783 case 42: 2784 2785 /* Line 1806 of yacc.c */ 2786 #line 368 "go.y" 2787 { 2788 (yyval.list) = variter((yyvsp[(1) - (3)].list), nil, (yyvsp[(3) - (3)].list)); 2789 } 2790 break; 2791 2792 case 43: 2793 2794 /* Line 1806 of yacc.c */ 2795 #line 374 "go.y" 2796 { 2797 (yyval.list) = constiter((yyvsp[(1) - (4)].list), (yyvsp[(2) - (4)].node), (yyvsp[(4) - (4)].list)); 2798 } 2799 break; 2800 2801 case 44: 2802 2803 /* Line 1806 of yacc.c */ 2804 #line 378 "go.y" 2805 { 2806 (yyval.list) = constiter((yyvsp[(1) - (3)].list), N, (yyvsp[(3) - (3)].list)); 2807 } 2808 break; 2809 2810 case 46: 2811 2812 /* Line 1806 of yacc.c */ 2813 #line 385 "go.y" 2814 { 2815 (yyval.list) = constiter((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node), nil); 2816 } 2817 break; 2818 2819 case 47: 2820 2821 /* Line 1806 of yacc.c */ 2822 #line 389 "go.y" 2823 { 2824 (yyval.list) = constiter((yyvsp[(1) - (1)].list), N, nil); 2825 } 2826 break; 2827 2828 case 48: 2829 2830 /* Line 1806 of yacc.c */ 2831 #line 395 "go.y" 2832 { 2833 // different from dclname because the name 2834 // becomes visible right here, not at the end 2835 // of the declaration. 2836 (yyval.node) = typedcl0((yyvsp[(1) - (1)].sym)); 2837 } 2838 break; 2839 2840 case 49: 2841 2842 /* Line 1806 of yacc.c */ 2843 #line 404 "go.y" 2844 { 2845 (yyval.node) = typedcl1((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node), 1); 2846 } 2847 break; 2848 2849 case 50: 2850 2851 /* Line 1806 of yacc.c */ 2852 #line 410 "go.y" 2853 { 2854 (yyval.node) = (yyvsp[(1) - (1)].node); 2855 2856 // These nodes do not carry line numbers. 2857 // Since a bare name used as an expression is an error, 2858 // introduce a wrapper node to give the correct line. 2859 switch((yyval.node)->op) { 2860 case ONAME: 2861 case ONONAME: 2862 case OTYPE: 2863 case OPACK: 2864 case OLITERAL: 2865 (yyval.node) = nod(OPAREN, (yyval.node), N); 2866 (yyval.node)->implicit = 1; 2867 break; 2868 } 2869 } 2870 break; 2871 2872 case 51: 2873 2874 /* Line 1806 of yacc.c */ 2875 #line 428 "go.y" 2876 { 2877 (yyval.node) = nod(OASOP, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 2878 (yyval.node)->etype = (yyvsp[(2) - (3)].i); // rathole to pass opcode 2879 } 2880 break; 2881 2882 case 52: 2883 2884 /* Line 1806 of yacc.c */ 2885 #line 433 "go.y" 2886 { 2887 if((yyvsp[(1) - (3)].list)->next == nil && (yyvsp[(3) - (3)].list)->next == nil) { 2888 // simple 2889 (yyval.node) = nod(OAS, (yyvsp[(1) - (3)].list)->n, (yyvsp[(3) - (3)].list)->n); 2890 break; 2891 } 2892 // multiple 2893 (yyval.node) = nod(OAS2, N, N); 2894 (yyval.node)->list = (yyvsp[(1) - (3)].list); 2895 (yyval.node)->rlist = (yyvsp[(3) - (3)].list); 2896 } 2897 break; 2898 2899 case 53: 2900 2901 /* Line 1806 of yacc.c */ 2902 #line 445 "go.y" 2903 { 2904 if((yyvsp[(3) - (3)].list)->n->op == OTYPESW) { 2905 (yyval.node) = nod(OTYPESW, N, (yyvsp[(3) - (3)].list)->n->right); 2906 if((yyvsp[(3) - (3)].list)->next != nil) 2907 yyerror("expr.(type) must be alone in list"); 2908 if((yyvsp[(1) - (3)].list)->next != nil) 2909 yyerror("argument count mismatch: %d = %d", count((yyvsp[(1) - (3)].list)), 1); 2910 else if(((yyvsp[(1) - (3)].list)->n->op != ONAME && (yyvsp[(1) - (3)].list)->n->op != OTYPE && (yyvsp[(1) - (3)].list)->n->op != ONONAME) || isblank((yyvsp[(1) - (3)].list)->n)) 2911 yyerror("invalid variable name %N in type switch", (yyvsp[(1) - (3)].list)->n); 2912 else 2913 (yyval.node)->left = dclname((yyvsp[(1) - (3)].list)->n->sym); // it's a colas, so must not re-use an oldname. 2914 break; 2915 } 2916 (yyval.node) = colas((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list), (yyvsp[(2) - (3)].i)); 2917 } 2918 break; 2919 2920 case 54: 2921 2922 /* Line 1806 of yacc.c */ 2923 #line 461 "go.y" 2924 { 2925 (yyval.node) = nod(OASOP, (yyvsp[(1) - (2)].node), nodintconst(1)); 2926 (yyval.node)->etype = OADD; 2927 } 2928 break; 2929 2930 case 55: 2931 2932 /* Line 1806 of yacc.c */ 2933 #line 466 "go.y" 2934 { 2935 (yyval.node) = nod(OASOP, (yyvsp[(1) - (2)].node), nodintconst(1)); 2936 (yyval.node)->etype = OSUB; 2937 } 2938 break; 2939 2940 case 56: 2941 2942 /* Line 1806 of yacc.c */ 2943 #line 473 "go.y" 2944 { 2945 Node *n, *nn; 2946 2947 // will be converted to OCASE 2948 // right will point to next case 2949 // done in casebody() 2950 markdcl(); 2951 (yyval.node) = nod(OXCASE, N, N); 2952 (yyval.node)->list = (yyvsp[(2) - (3)].list); 2953 if(typesw != N && typesw->right != N && (n=typesw->right->left) != N) { 2954 // type switch - declare variable 2955 nn = newname(n->sym); 2956 declare(nn, dclcontext); 2957 (yyval.node)->nname = nn; 2958 2959 // keep track of the instances for reporting unused 2960 nn->defn = typesw->right; 2961 } 2962 } 2963 break; 2964 2965 case 57: 2966 2967 /* Line 1806 of yacc.c */ 2968 #line 493 "go.y" 2969 { 2970 Node *n; 2971 2972 // will be converted to OCASE 2973 // right will point to next case 2974 // done in casebody() 2975 markdcl(); 2976 (yyval.node) = nod(OXCASE, N, N); 2977 if((yyvsp[(2) - (5)].list)->next == nil) 2978 n = nod(OAS, (yyvsp[(2) - (5)].list)->n, (yyvsp[(4) - (5)].node)); 2979 else { 2980 n = nod(OAS2, N, N); 2981 n->list = (yyvsp[(2) - (5)].list); 2982 n->rlist = list1((yyvsp[(4) - (5)].node)); 2983 } 2984 (yyval.node)->list = list1(n); 2985 } 2986 break; 2987 2988 case 58: 2989 2990 /* Line 1806 of yacc.c */ 2991 #line 511 "go.y" 2992 { 2993 // will be converted to OCASE 2994 // right will point to next case 2995 // done in casebody() 2996 markdcl(); 2997 (yyval.node) = nod(OXCASE, N, N); 2998 (yyval.node)->list = list1(colas((yyvsp[(2) - (5)].list), list1((yyvsp[(4) - (5)].node)), (yyvsp[(3) - (5)].i))); 2999 } 3000 break; 3001 3002 case 59: 3003 3004 /* Line 1806 of yacc.c */ 3005 #line 520 "go.y" 3006 { 3007 Node *n, *nn; 3008 3009 markdcl(); 3010 (yyval.node) = nod(OXCASE, N, N); 3011 if(typesw != N && typesw->right != N && (n=typesw->right->left) != N) { 3012 // type switch - declare variable 3013 nn = newname(n->sym); 3014 declare(nn, dclcontext); 3015 (yyval.node)->nname = nn; 3016 3017 // keep track of the instances for reporting unused 3018 nn->defn = typesw->right; 3019 } 3020 } 3021 break; 3022 3023 case 60: 3024 3025 /* Line 1806 of yacc.c */ 3026 #line 538 "go.y" 3027 { 3028 markdcl(); 3029 } 3030 break; 3031 3032 case 61: 3033 3034 /* Line 1806 of yacc.c */ 3035 #line 542 "go.y" 3036 { 3037 if((yyvsp[(3) - (4)].list) == nil) 3038 (yyval.node) = nod(OEMPTY, N, N); 3039 else 3040 (yyval.node) = liststmt((yyvsp[(3) - (4)].list)); 3041 popdcl(); 3042 } 3043 break; 3044 3045 case 62: 3046 3047 /* Line 1806 of yacc.c */ 3048 #line 552 "go.y" 3049 { 3050 // If the last token read by the lexer was consumed 3051 // as part of the case, clear it (parser has cleared yychar). 3052 // If the last token read by the lexer was the lookahead 3053 // leave it alone (parser has it cached in yychar). 3054 // This is so that the stmt_list action doesn't look at 3055 // the case tokens if the stmt_list is empty. 3056 yylast = yychar; 3057 } 3058 break; 3059 3060 case 63: 3061 3062 /* Line 1806 of yacc.c */ 3063 #line 562 "go.y" 3064 { 3065 int last; 3066 3067 // This is the only place in the language where a statement 3068 // list is not allowed to drop the final semicolon, because 3069 // it's the only place where a statement list is not followed 3070 // by a closing brace. Handle the error for pedantry. 3071 3072 // Find the final token of the statement list. 3073 // yylast is lookahead; yyprev is last of stmt_list 3074 last = yyprev; 3075 3076 if(last > 0 && last != ';' && yychar != '}') 3077 yyerror("missing statement after label"); 3078 (yyval.node) = (yyvsp[(1) - (3)].node); 3079 (yyval.node)->nbody = (yyvsp[(3) - (3)].list); 3080 popdcl(); 3081 } 3082 break; 3083 3084 case 64: 3085 3086 /* Line 1806 of yacc.c */ 3087 #line 582 "go.y" 3088 { 3089 (yyval.list) = nil; 3090 } 3091 break; 3092 3093 case 65: 3094 3095 /* Line 1806 of yacc.c */ 3096 #line 586 "go.y" 3097 { 3098 (yyval.list) = list((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); 3099 } 3100 break; 3101 3102 case 66: 3103 3104 /* Line 1806 of yacc.c */ 3105 #line 592 "go.y" 3106 { 3107 markdcl(); 3108 } 3109 break; 3110 3111 case 67: 3112 3113 /* Line 1806 of yacc.c */ 3114 #line 596 "go.y" 3115 { 3116 (yyval.list) = (yyvsp[(3) - (4)].list); 3117 popdcl(); 3118 } 3119 break; 3120 3121 case 68: 3122 3123 /* Line 1806 of yacc.c */ 3124 #line 603 "go.y" 3125 { 3126 (yyval.node) = nod(ORANGE, N, (yyvsp[(4) - (4)].node)); 3127 (yyval.node)->list = (yyvsp[(1) - (4)].list); 3128 (yyval.node)->etype = 0; // := flag 3129 } 3130 break; 3131 3132 case 69: 3133 3134 /* Line 1806 of yacc.c */ 3135 #line 609 "go.y" 3136 { 3137 (yyval.node) = nod(ORANGE, N, (yyvsp[(4) - (4)].node)); 3138 (yyval.node)->list = (yyvsp[(1) - (4)].list); 3139 (yyval.node)->colas = 1; 3140 colasdefn((yyvsp[(1) - (4)].list), (yyval.node)); 3141 } 3142 break; 3143 3144 case 70: 3145 3146 /* Line 1806 of yacc.c */ 3147 #line 618 "go.y" 3148 { 3149 // init ; test ; incr 3150 if((yyvsp[(5) - (5)].node) != N && (yyvsp[(5) - (5)].node)->colas != 0) 3151 yyerror("cannot declare in the for-increment"); 3152 (yyval.node) = nod(OFOR, N, N); 3153 if((yyvsp[(1) - (5)].node) != N) 3154 (yyval.node)->ninit = list1((yyvsp[(1) - (5)].node)); 3155 (yyval.node)->ntest = (yyvsp[(3) - (5)].node); 3156 (yyval.node)->nincr = (yyvsp[(5) - (5)].node); 3157 } 3158 break; 3159 3160 case 71: 3161 3162 /* Line 1806 of yacc.c */ 3163 #line 629 "go.y" 3164 { 3165 // normal test 3166 (yyval.node) = nod(OFOR, N, N); 3167 (yyval.node)->ntest = (yyvsp[(1) - (1)].node); 3168 } 3169 break; 3170 3171 case 73: 3172 3173 /* Line 1806 of yacc.c */ 3174 #line 638 "go.y" 3175 { 3176 (yyval.node) = (yyvsp[(1) - (2)].node); 3177 (yyval.node)->nbody = concat((yyval.node)->nbody, (yyvsp[(2) - (2)].list)); 3178 } 3179 break; 3180 3181 case 74: 3182 3183 /* Line 1806 of yacc.c */ 3184 #line 645 "go.y" 3185 { 3186 markdcl(); 3187 } 3188 break; 3189 3190 case 75: 3191 3192 /* Line 1806 of yacc.c */ 3193 #line 649 "go.y" 3194 { 3195 (yyval.node) = (yyvsp[(3) - (3)].node); 3196 popdcl(); 3197 } 3198 break; 3199 3200 case 76: 3201 3202 /* Line 1806 of yacc.c */ 3203 #line 656 "go.y" 3204 { 3205 // test 3206 (yyval.node) = nod(OIF, N, N); 3207 (yyval.node)->ntest = (yyvsp[(1) - (1)].node); 3208 } 3209 break; 3210 3211 case 77: 3212 3213 /* Line 1806 of yacc.c */ 3214 #line 662 "go.y" 3215 { 3216 // init ; test 3217 (yyval.node) = nod(OIF, N, N); 3218 if((yyvsp[(1) - (3)].node) != N) 3219 (yyval.node)->ninit = list1((yyvsp[(1) - (3)].node)); 3220 (yyval.node)->ntest = (yyvsp[(3) - (3)].node); 3221 } 3222 break; 3223 3224 case 78: 3225 3226 /* Line 1806 of yacc.c */ 3227 #line 673 "go.y" 3228 { 3229 markdcl(); 3230 } 3231 break; 3232 3233 case 79: 3234 3235 /* Line 1806 of yacc.c */ 3236 #line 677 "go.y" 3237 { 3238 if((yyvsp[(3) - (3)].node)->ntest == N) 3239 yyerror("missing condition in if statement"); 3240 } 3241 break; 3242 3243 case 80: 3244 3245 /* Line 1806 of yacc.c */ 3246 #line 682 "go.y" 3247 { 3248 (yyvsp[(3) - (5)].node)->nbody = (yyvsp[(5) - (5)].list); 3249 } 3250 break; 3251 3252 case 81: 3253 3254 /* Line 1806 of yacc.c */ 3255 #line 686 "go.y" 3256 { 3257 Node *n; 3258 NodeList *nn; 3259 3260 (yyval.node) = (yyvsp[(3) - (8)].node); 3261 n = (yyvsp[(3) - (8)].node); 3262 popdcl(); 3263 for(nn = concat((yyvsp[(7) - (8)].list), (yyvsp[(8) - (8)].list)); nn; nn = nn->next) { 3264 if(nn->n->op == OIF) 3265 popdcl(); 3266 n->nelse = list1(nn->n); 3267 n = nn->n; 3268 } 3269 } 3270 break; 3271 3272 case 82: 3273 3274 /* Line 1806 of yacc.c */ 3275 #line 703 "go.y" 3276 { 3277 markdcl(); 3278 } 3279 break; 3280 3281 case 83: 3282 3283 /* Line 1806 of yacc.c */ 3284 #line 707 "go.y" 3285 { 3286 if((yyvsp[(4) - (5)].node)->ntest == N) 3287 yyerror("missing condition in if statement"); 3288 (yyvsp[(4) - (5)].node)->nbody = (yyvsp[(5) - (5)].list); 3289 (yyval.list) = list1((yyvsp[(4) - (5)].node)); 3290 } 3291 break; 3292 3293 case 84: 3294 3295 /* Line 1806 of yacc.c */ 3296 #line 715 "go.y" 3297 { 3298 (yyval.list) = nil; 3299 } 3300 break; 3301 3302 case 85: 3303 3304 /* Line 1806 of yacc.c */ 3305 #line 719 "go.y" 3306 { 3307 (yyval.list) = concat((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].list)); 3308 } 3309 break; 3310 3311 case 86: 3312 3313 /* Line 1806 of yacc.c */ 3314 #line 724 "go.y" 3315 { 3316 (yyval.list) = nil; 3317 } 3318 break; 3319 3320 case 87: 3321 3322 /* Line 1806 of yacc.c */ 3323 #line 728 "go.y" 3324 { 3325 NodeList *node; 3326 3327 node = mal(sizeof *node); 3328 node->n = (yyvsp[(2) - (2)].node); 3329 node->end = node; 3330 (yyval.list) = node; 3331 } 3332 break; 3333 3334 case 88: 3335 3336 /* Line 1806 of yacc.c */ 3337 #line 739 "go.y" 3338 { 3339 markdcl(); 3340 } 3341 break; 3342 3343 case 89: 3344 3345 /* Line 1806 of yacc.c */ 3346 #line 743 "go.y" 3347 { 3348 Node *n; 3349 n = (yyvsp[(3) - (3)].node)->ntest; 3350 if(n != N && n->op != OTYPESW) 3351 n = N; 3352 typesw = nod(OXXX, typesw, n); 3353 } 3354 break; 3355 3356 case 90: 3357 3358 /* Line 1806 of yacc.c */ 3359 #line 751 "go.y" 3360 { 3361 (yyval.node) = (yyvsp[(3) - (7)].node); 3362 (yyval.node)->op = OSWITCH; 3363 (yyval.node)->list = (yyvsp[(6) - (7)].list); 3364 typesw = typesw->left; 3365 popdcl(); 3366 } 3367 break; 3368 3369 case 91: 3370 3371 /* Line 1806 of yacc.c */ 3372 #line 761 "go.y" 3373 { 3374 typesw = nod(OXXX, typesw, N); 3375 } 3376 break; 3377 3378 case 92: 3379 3380 /* Line 1806 of yacc.c */ 3381 #line 765 "go.y" 3382 { 3383 (yyval.node) = nod(OSELECT, N, N); 3384 (yyval.node)->lineno = typesw->lineno; 3385 (yyval.node)->list = (yyvsp[(4) - (5)].list); 3386 typesw = typesw->left; 3387 } 3388 break; 3389 3390 case 94: 3391 3392 /* Line 1806 of yacc.c */ 3393 #line 778 "go.y" 3394 { 3395 (yyval.node) = nod(OOROR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 3396 } 3397 break; 3398 3399 case 95: 3400 3401 /* Line 1806 of yacc.c */ 3402 #line 782 "go.y" 3403 { 3404 (yyval.node) = nod(OANDAND, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 3405 } 3406 break; 3407 3408 case 96: 3409 3410 /* Line 1806 of yacc.c */ 3411 #line 786 "go.y" 3412 { 3413 (yyval.node) = nod(OEQ, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 3414 } 3415 break; 3416 3417 case 97: 3418 3419 /* Line 1806 of yacc.c */ 3420 #line 790 "go.y" 3421 { 3422 (yyval.node) = nod(ONE, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 3423 } 3424 break; 3425 3426 case 98: 3427 3428 /* Line 1806 of yacc.c */ 3429 #line 794 "go.y" 3430 { 3431 (yyval.node) = nod(OLT, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 3432 } 3433 break; 3434 3435 case 99: 3436 3437 /* Line 1806 of yacc.c */ 3438 #line 798 "go.y" 3439 { 3440 (yyval.node) = nod(OLE, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 3441 } 3442 break; 3443 3444 case 100: 3445 3446 /* Line 1806 of yacc.c */ 3447 #line 802 "go.y" 3448 { 3449 (yyval.node) = nod(OGE, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 3450 } 3451 break; 3452 3453 case 101: 3454 3455 /* Line 1806 of yacc.c */ 3456 #line 806 "go.y" 3457 { 3458 (yyval.node) = nod(OGT, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 3459 } 3460 break; 3461 3462 case 102: 3463 3464 /* Line 1806 of yacc.c */ 3465 #line 810 "go.y" 3466 { 3467 (yyval.node) = nod(OADD, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 3468 } 3469 break; 3470 3471 case 103: 3472 3473 /* Line 1806 of yacc.c */ 3474 #line 814 "go.y" 3475 { 3476 (yyval.node) = nod(OSUB, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 3477 } 3478 break; 3479 3480 case 104: 3481 3482 /* Line 1806 of yacc.c */ 3483 #line 818 "go.y" 3484 { 3485 (yyval.node) = nod(OOR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 3486 } 3487 break; 3488 3489 case 105: 3490 3491 /* Line 1806 of yacc.c */ 3492 #line 822 "go.y" 3493 { 3494 (yyval.node) = nod(OXOR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 3495 } 3496 break; 3497 3498 case 106: 3499 3500 /* Line 1806 of yacc.c */ 3501 #line 826 "go.y" 3502 { 3503 (yyval.node) = nod(OMUL, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 3504 } 3505 break; 3506 3507 case 107: 3508 3509 /* Line 1806 of yacc.c */ 3510 #line 830 "go.y" 3511 { 3512 (yyval.node) = nod(ODIV, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 3513 } 3514 break; 3515 3516 case 108: 3517 3518 /* Line 1806 of yacc.c */ 3519 #line 834 "go.y" 3520 { 3521 (yyval.node) = nod(OMOD, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 3522 } 3523 break; 3524 3525 case 109: 3526 3527 /* Line 1806 of yacc.c */ 3528 #line 838 "go.y" 3529 { 3530 (yyval.node) = nod(OAND, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 3531 } 3532 break; 3533 3534 case 110: 3535 3536 /* Line 1806 of yacc.c */ 3537 #line 842 "go.y" 3538 { 3539 (yyval.node) = nod(OANDNOT, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 3540 } 3541 break; 3542 3543 case 111: 3544 3545 /* Line 1806 of yacc.c */ 3546 #line 846 "go.y" 3547 { 3548 (yyval.node) = nod(OLSH, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 3549 } 3550 break; 3551 3552 case 112: 3553 3554 /* Line 1806 of yacc.c */ 3555 #line 850 "go.y" 3556 { 3557 (yyval.node) = nod(ORSH, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 3558 } 3559 break; 3560 3561 case 113: 3562 3563 /* Line 1806 of yacc.c */ 3564 #line 855 "go.y" 3565 { 3566 (yyval.node) = nod(OSEND, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 3567 } 3568 break; 3569 3570 case 115: 3571 3572 /* Line 1806 of yacc.c */ 3573 #line 862 "go.y" 3574 { 3575 (yyval.node) = nod(OIND, (yyvsp[(2) - (2)].node), N); 3576 } 3577 break; 3578 3579 case 116: 3580 3581 /* Line 1806 of yacc.c */ 3582 #line 866 "go.y" 3583 { 3584 if((yyvsp[(2) - (2)].node)->op == OCOMPLIT) { 3585 // Special case for &T{...}: turn into (*T){...}. 3586 (yyval.node) = (yyvsp[(2) - (2)].node); 3587 (yyval.node)->right = nod(OIND, (yyval.node)->right, N); 3588 (yyval.node)->right->implicit = 1; 3589 } else { 3590 (yyval.node) = nod(OADDR, (yyvsp[(2) - (2)].node), N); 3591 } 3592 } 3593 break; 3594 3595 case 117: 3596 3597 /* Line 1806 of yacc.c */ 3598 #line 877 "go.y" 3599 { 3600 (yyval.node) = nod(OPLUS, (yyvsp[(2) - (2)].node), N); 3601 } 3602 break; 3603 3604 case 118: 3605 3606 /* Line 1806 of yacc.c */ 3607 #line 881 "go.y" 3608 { 3609 (yyval.node) = nod(OMINUS, (yyvsp[(2) - (2)].node), N); 3610 } 3611 break; 3612 3613 case 119: 3614 3615 /* Line 1806 of yacc.c */ 3616 #line 885 "go.y" 3617 { 3618 (yyval.node) = nod(ONOT, (yyvsp[(2) - (2)].node), N); 3619 } 3620 break; 3621 3622 case 120: 3623 3624 /* Line 1806 of yacc.c */ 3625 #line 889 "go.y" 3626 { 3627 yyerror("the bitwise complement operator is ^"); 3628 (yyval.node) = nod(OCOM, (yyvsp[(2) - (2)].node), N); 3629 } 3630 break; 3631 3632 case 121: 3633 3634 /* Line 1806 of yacc.c */ 3635 #line 894 "go.y" 3636 { 3637 (yyval.node) = nod(OCOM, (yyvsp[(2) - (2)].node), N); 3638 } 3639 break; 3640 3641 case 122: 3642 3643 /* Line 1806 of yacc.c */ 3644 #line 898 "go.y" 3645 { 3646 (yyval.node) = nod(ORECV, (yyvsp[(2) - (2)].node), N); 3647 } 3648 break; 3649 3650 case 123: 3651 3652 /* Line 1806 of yacc.c */ 3653 #line 908 "go.y" 3654 { 3655 (yyval.node) = nod(OCALL, (yyvsp[(1) - (3)].node), N); 3656 } 3657 break; 3658 3659 case 124: 3660 3661 /* Line 1806 of yacc.c */ 3662 #line 912 "go.y" 3663 { 3664 (yyval.node) = nod(OCALL, (yyvsp[(1) - (5)].node), N); 3665 (yyval.node)->list = (yyvsp[(3) - (5)].list); 3666 } 3667 break; 3668 3669 case 125: 3670 3671 /* Line 1806 of yacc.c */ 3672 #line 917 "go.y" 3673 { 3674 (yyval.node) = nod(OCALL, (yyvsp[(1) - (6)].node), N); 3675 (yyval.node)->list = (yyvsp[(3) - (6)].list); 3676 (yyval.node)->isddd = 1; 3677 } 3678 break; 3679 3680 case 126: 3681 3682 /* Line 1806 of yacc.c */ 3683 #line 925 "go.y" 3684 { 3685 (yyval.node) = nodlit((yyvsp[(1) - (1)].val)); 3686 } 3687 break; 3688 3689 case 128: 3690 3691 /* Line 1806 of yacc.c */ 3692 #line 930 "go.y" 3693 { 3694 if((yyvsp[(1) - (3)].node)->op == OPACK) { 3695 Sym *s; 3696 s = restrictlookup((yyvsp[(3) - (3)].sym)->name, (yyvsp[(1) - (3)].node)->pkg); 3697 (yyvsp[(1) - (3)].node)->used = 1; 3698 (yyval.node) = oldname(s); 3699 break; 3700 } 3701 (yyval.node) = nod(OXDOT, (yyvsp[(1) - (3)].node), newname((yyvsp[(3) - (3)].sym))); 3702 } 3703 break; 3704 3705 case 129: 3706 3707 /* Line 1806 of yacc.c */ 3708 #line 941 "go.y" 3709 { 3710 (yyval.node) = nod(ODOTTYPE, (yyvsp[(1) - (5)].node), (yyvsp[(4) - (5)].node)); 3711 } 3712 break; 3713 3714 case 130: 3715 3716 /* Line 1806 of yacc.c */ 3717 #line 945 "go.y" 3718 { 3719 (yyval.node) = nod(OTYPESW, N, (yyvsp[(1) - (5)].node)); 3720 } 3721 break; 3722 3723 case 131: 3724 3725 /* Line 1806 of yacc.c */ 3726 #line 949 "go.y" 3727 { 3728 (yyval.node) = nod(OINDEX, (yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node)); 3729 } 3730 break; 3731 3732 case 132: 3733 3734 /* Line 1806 of yacc.c */ 3735 #line 953 "go.y" 3736 { 3737 (yyval.node) = nod(OSLICE, (yyvsp[(1) - (6)].node), nod(OKEY, (yyvsp[(3) - (6)].node), (yyvsp[(5) - (6)].node))); 3738 } 3739 break; 3740 3741 case 133: 3742 3743 /* Line 1806 of yacc.c */ 3744 #line 957 "go.y" 3745 { 3746 if((yyvsp[(5) - (8)].node) == N) 3747 yyerror("middle index required in 3-index slice"); 3748 if((yyvsp[(7) - (8)].node) == N) 3749 yyerror("final index required in 3-index slice"); 3750 (yyval.node) = nod(OSLICE3, (yyvsp[(1) - (8)].node), nod(OKEY, (yyvsp[(3) - (8)].node), nod(OKEY, (yyvsp[(5) - (8)].node), (yyvsp[(7) - (8)].node)))); 3751 } 3752 break; 3753 3754 case 135: 3755 3756 /* Line 1806 of yacc.c */ 3757 #line 966 "go.y" 3758 { 3759 // conversion 3760 (yyval.node) = nod(OCALL, (yyvsp[(1) - (5)].node), N); 3761 (yyval.node)->list = list1((yyvsp[(3) - (5)].node)); 3762 } 3763 break; 3764 3765 case 136: 3766 3767 /* Line 1806 of yacc.c */ 3768 #line 972 "go.y" 3769 { 3770 (yyval.node) = (yyvsp[(3) - (5)].node); 3771 (yyval.node)->right = (yyvsp[(1) - (5)].node); 3772 (yyval.node)->list = (yyvsp[(4) - (5)].list); 3773 fixlbrace((yyvsp[(2) - (5)].i)); 3774 } 3775 break; 3776 3777 case 137: 3778 3779 /* Line 1806 of yacc.c */ 3780 #line 979 "go.y" 3781 { 3782 (yyval.node) = (yyvsp[(3) - (5)].node); 3783 (yyval.node)->right = (yyvsp[(1) - (5)].node); 3784 (yyval.node)->list = (yyvsp[(4) - (5)].list); 3785 } 3786 break; 3787 3788 case 138: 3789 3790 /* Line 1806 of yacc.c */ 3791 #line 985 "go.y" 3792 { 3793 yyerror("cannot parenthesize type in composite literal"); 3794 (yyval.node) = (yyvsp[(5) - (7)].node); 3795 (yyval.node)->right = (yyvsp[(2) - (7)].node); 3796 (yyval.node)->list = (yyvsp[(6) - (7)].list); 3797 } 3798 break; 3799 3800 case 140: 3801 3802 /* Line 1806 of yacc.c */ 3803 #line 994 "go.y" 3804 { 3805 // composite expression. 3806 // make node early so we get the right line number. 3807 (yyval.node) = nod(OCOMPLIT, N, N); 3808 } 3809 break; 3810 3811 case 141: 3812 3813 /* Line 1806 of yacc.c */ 3814 #line 1002 "go.y" 3815 { 3816 (yyval.node) = nod(OKEY, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 3817 } 3818 break; 3819 3820 case 142: 3821 3822 /* Line 1806 of yacc.c */ 3823 #line 1008 "go.y" 3824 { 3825 // These nodes do not carry line numbers. 3826 // Since a composite literal commonly spans several lines, 3827 // the line number on errors may be misleading. 3828 // Introduce a wrapper node to give the correct line. 3829 (yyval.node) = (yyvsp[(1) - (1)].node); 3830 switch((yyval.node)->op) { 3831 case ONAME: 3832 case ONONAME: 3833 case OTYPE: 3834 case OPACK: 3835 case OLITERAL: 3836 (yyval.node) = nod(OPAREN, (yyval.node), N); 3837 (yyval.node)->implicit = 1; 3838 } 3839 } 3840 break; 3841 3842 case 143: 3843 3844 /* Line 1806 of yacc.c */ 3845 #line 1025 "go.y" 3846 { 3847 (yyval.node) = (yyvsp[(2) - (4)].node); 3848 (yyval.node)->list = (yyvsp[(3) - (4)].list); 3849 } 3850 break; 3851 3852 case 145: 3853 3854 /* Line 1806 of yacc.c */ 3855 #line 1033 "go.y" 3856 { 3857 (yyval.node) = (yyvsp[(2) - (4)].node); 3858 (yyval.node)->list = (yyvsp[(3) - (4)].list); 3859 } 3860 break; 3861 3862 case 147: 3863 3864 /* Line 1806 of yacc.c */ 3865 #line 1041 "go.y" 3866 { 3867 (yyval.node) = (yyvsp[(2) - (3)].node); 3868 3869 // Need to know on lhs of := whether there are ( ). 3870 // Don't bother with the OPAREN in other cases: 3871 // it's just a waste of memory and time. 3872 switch((yyval.node)->op) { 3873 case ONAME: 3874 case ONONAME: 3875 case OPACK: 3876 case OTYPE: 3877 case OLITERAL: 3878 case OTYPESW: 3879 (yyval.node) = nod(OPAREN, (yyval.node), N); 3880 } 3881 } 3882 break; 3883 3884 case 151: 3885 3886 /* Line 1806 of yacc.c */ 3887 #line 1067 "go.y" 3888 { 3889 (yyval.i) = LBODY; 3890 } 3891 break; 3892 3893 case 152: 3894 3895 /* Line 1806 of yacc.c */ 3896 #line 1071 "go.y" 3897 { 3898 (yyval.i) = '{'; 3899 } 3900 break; 3901 3902 case 153: 3903 3904 /* Line 1806 of yacc.c */ 3905 #line 1082 "go.y" 3906 { 3907 if((yyvsp[(1) - (1)].sym) == S) 3908 (yyval.node) = N; 3909 else 3910 (yyval.node) = newname((yyvsp[(1) - (1)].sym)); 3911 } 3912 break; 3913 3914 case 154: 3915 3916 /* Line 1806 of yacc.c */ 3917 #line 1091 "go.y" 3918 { 3919 (yyval.node) = dclname((yyvsp[(1) - (1)].sym)); 3920 } 3921 break; 3922 3923 case 155: 3924 3925 /* Line 1806 of yacc.c */ 3926 #line 1096 "go.y" 3927 { 3928 (yyval.node) = N; 3929 } 3930 break; 3931 3932 case 157: 3933 3934 /* Line 1806 of yacc.c */ 3935 #line 1103 "go.y" 3936 { 3937 (yyval.sym) = (yyvsp[(1) - (1)].sym); 3938 // during imports, unqualified non-exported identifiers are from builtinpkg 3939 if(importpkg != nil && !exportname((yyvsp[(1) - (1)].sym)->name)) 3940 (yyval.sym) = pkglookup((yyvsp[(1) - (1)].sym)->name, builtinpkg); 3941 } 3942 break; 3943 3944 case 159: 3945 3946 /* Line 1806 of yacc.c */ 3947 #line 1111 "go.y" 3948 { 3949 (yyval.sym) = S; 3950 } 3951 break; 3952 3953 case 160: 3954 3955 /* Line 1806 of yacc.c */ 3956 #line 1117 "go.y" 3957 { 3958 Pkg *p; 3959 3960 if((yyvsp[(2) - (4)].val).u.sval->len == 0) 3961 p = importpkg; 3962 else { 3963 if(isbadimport((yyvsp[(2) - (4)].val).u.sval)) 3964 errorexit(); 3965 p = mkpkg((yyvsp[(2) - (4)].val).u.sval); 3966 } 3967 (yyval.sym) = pkglookup((yyvsp[(4) - (4)].sym)->name, p); 3968 } 3969 break; 3970 3971 case 161: 3972 3973 /* Line 1806 of yacc.c */ 3974 #line 1130 "go.y" 3975 { 3976 Pkg *p; 3977 3978 if((yyvsp[(2) - (4)].val).u.sval->len == 0) 3979 p = importpkg; 3980 else { 3981 if(isbadimport((yyvsp[(2) - (4)].val).u.sval)) 3982 errorexit(); 3983 p = mkpkg((yyvsp[(2) - (4)].val).u.sval); 3984 } 3985 (yyval.sym) = pkglookup("?", p); 3986 } 3987 break; 3988 3989 case 162: 3990 3991 /* Line 1806 of yacc.c */ 3992 #line 1145 "go.y" 3993 { 3994 (yyval.node) = oldname((yyvsp[(1) - (1)].sym)); 3995 if((yyval.node)->pack != N) 3996 (yyval.node)->pack->used = 1; 3997 } 3998 break; 3999 4000 case 164: 4001 4002 /* Line 1806 of yacc.c */ 4003 #line 1165 "go.y" 4004 { 4005 yyerror("final argument in variadic function missing type"); 4006 (yyval.node) = nod(ODDD, typenod(typ(TINTER)), N); 4007 } 4008 break; 4009 4010 case 165: 4011 4012 /* Line 1806 of yacc.c */ 4013 #line 1170 "go.y" 4014 { 4015 (yyval.node) = nod(ODDD, (yyvsp[(2) - (2)].node), N); 4016 } 4017 break; 4018 4019 case 171: 4020 4021 /* Line 1806 of yacc.c */ 4022 #line 1181 "go.y" 4023 { 4024 (yyval.node) = nod(OTPAREN, (yyvsp[(2) - (3)].node), N); 4025 } 4026 break; 4027 4028 case 175: 4029 4030 /* Line 1806 of yacc.c */ 4031 #line 1190 "go.y" 4032 { 4033 (yyval.node) = nod(OIND, (yyvsp[(2) - (2)].node), N); 4034 } 4035 break; 4036 4037 case 180: 4038 4039 /* Line 1806 of yacc.c */ 4040 #line 1200 "go.y" 4041 { 4042 (yyval.node) = nod(OTPAREN, (yyvsp[(2) - (3)].node), N); 4043 } 4044 break; 4045 4046 case 190: 4047 4048 /* Line 1806 of yacc.c */ 4049 #line 1221 "go.y" 4050 { 4051 if((yyvsp[(1) - (3)].node)->op == OPACK) { 4052 Sym *s; 4053 s = restrictlookup((yyvsp[(3) - (3)].sym)->name, (yyvsp[(1) - (3)].node)->pkg); 4054 (yyvsp[(1) - (3)].node)->used = 1; 4055 (yyval.node) = oldname(s); 4056 break; 4057 } 4058 (yyval.node) = nod(OXDOT, (yyvsp[(1) - (3)].node), newname((yyvsp[(3) - (3)].sym))); 4059 } 4060 break; 4061 4062 case 191: 4063 4064 /* Line 1806 of yacc.c */ 4065 #line 1234 "go.y" 4066 { 4067 (yyval.node) = nod(OTARRAY, (yyvsp[(2) - (4)].node), (yyvsp[(4) - (4)].node)); 4068 } 4069 break; 4070 4071 case 192: 4072 4073 /* Line 1806 of yacc.c */ 4074 #line 1238 "go.y" 4075 { 4076 // array literal of nelem 4077 (yyval.node) = nod(OTARRAY, nod(ODDD, N, N), (yyvsp[(4) - (4)].node)); 4078 } 4079 break; 4080 4081 case 193: 4082 4083 /* Line 1806 of yacc.c */ 4084 #line 1243 "go.y" 4085 { 4086 (yyval.node) = nod(OTCHAN, (yyvsp[(2) - (2)].node), N); 4087 (yyval.node)->etype = Cboth; 4088 } 4089 break; 4090 4091 case 194: 4092 4093 /* Line 1806 of yacc.c */ 4094 #line 1248 "go.y" 4095 { 4096 (yyval.node) = nod(OTCHAN, (yyvsp[(3) - (3)].node), N); 4097 (yyval.node)->etype = Csend; 4098 } 4099 break; 4100 4101 case 195: 4102 4103 /* Line 1806 of yacc.c */ 4104 #line 1253 "go.y" 4105 { 4106 (yyval.node) = nod(OTMAP, (yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node)); 4107 } 4108 break; 4109 4110 case 198: 4111 4112 /* Line 1806 of yacc.c */ 4113 #line 1261 "go.y" 4114 { 4115 (yyval.node) = nod(OIND, (yyvsp[(2) - (2)].node), N); 4116 } 4117 break; 4118 4119 case 199: 4120 4121 /* Line 1806 of yacc.c */ 4122 #line 1267 "go.y" 4123 { 4124 (yyval.node) = nod(OTCHAN, (yyvsp[(3) - (3)].node), N); 4125 (yyval.node)->etype = Crecv; 4126 } 4127 break; 4128 4129 case 200: 4130 4131 /* Line 1806 of yacc.c */ 4132 #line 1274 "go.y" 4133 { 4134 (yyval.node) = nod(OTSTRUCT, N, N); 4135 (yyval.node)->list = (yyvsp[(3) - (5)].list); 4136 fixlbrace((yyvsp[(2) - (5)].i)); 4137 } 4138 break; 4139 4140 case 201: 4141 4142 /* Line 1806 of yacc.c */ 4143 #line 1280 "go.y" 4144 { 4145 (yyval.node) = nod(OTSTRUCT, N, N); 4146 fixlbrace((yyvsp[(2) - (3)].i)); 4147 } 4148 break; 4149 4150 case 202: 4151 4152 /* Line 1806 of yacc.c */ 4153 #line 1287 "go.y" 4154 { 4155 (yyval.node) = nod(OTINTER, N, N); 4156 (yyval.node)->list = (yyvsp[(3) - (5)].list); 4157 fixlbrace((yyvsp[(2) - (5)].i)); 4158 } 4159 break; 4160 4161 case 203: 4162 4163 /* Line 1806 of yacc.c */ 4164 #line 1293 "go.y" 4165 { 4166 (yyval.node) = nod(OTINTER, N, N); 4167 fixlbrace((yyvsp[(2) - (3)].i)); 4168 } 4169 break; 4170 4171 case 204: 4172 4173 /* Line 1806 of yacc.c */ 4174 #line 1304 "go.y" 4175 { 4176 (yyval.node) = (yyvsp[(2) - (3)].node); 4177 if((yyval.node) == N) 4178 break; 4179 if(noescape && (yyvsp[(3) - (3)].list) != nil) 4180 yyerror("can only use //go:noescape with external func implementations"); 4181 (yyval.node)->nbody = (yyvsp[(3) - (3)].list); 4182 (yyval.node)->endlineno = lineno; 4183 (yyval.node)->noescape = noescape; 4184 funcbody((yyval.node)); 4185 } 4186 break; 4187 4188 case 205: 4189 4190 /* Line 1806 of yacc.c */ 4191 #line 1318 "go.y" 4192 { 4193 Node *t; 4194 4195 (yyval.node) = N; 4196 (yyvsp[(3) - (5)].list) = checkarglist((yyvsp[(3) - (5)].list), 1); 4197 4198 if(strcmp((yyvsp[(1) - (5)].sym)->name, "init") == 0) { 4199 (yyvsp[(1) - (5)].sym) = renameinit(); 4200 if((yyvsp[(3) - (5)].list) != nil || (yyvsp[(5) - (5)].list) != nil) 4201 yyerror("func init must have no arguments and no return values"); 4202 } 4203 if(strcmp(localpkg->name, "main") == 0 && strcmp((yyvsp[(1) - (5)].sym)->name, "main") == 0) { 4204 if((yyvsp[(3) - (5)].list) != nil || (yyvsp[(5) - (5)].list) != nil) 4205 yyerror("func main must have no arguments and no return values"); 4206 } 4207 4208 t = nod(OTFUNC, N, N); 4209 t->list = (yyvsp[(3) - (5)].list); 4210 t->rlist = (yyvsp[(5) - (5)].list); 4211 4212 (yyval.node) = nod(ODCLFUNC, N, N); 4213 (yyval.node)->nname = newname((yyvsp[(1) - (5)].sym)); 4214 (yyval.node)->nname->defn = (yyval.node); 4215 (yyval.node)->nname->ntype = t; // TODO: check if nname already has an ntype 4216 declare((yyval.node)->nname, PFUNC); 4217 4218 funchdr((yyval.node)); 4219 } 4220 break; 4221 4222 case 206: 4223 4224 /* Line 1806 of yacc.c */ 4225 #line 1347 "go.y" 4226 { 4227 Node *rcvr, *t; 4228 4229 (yyval.node) = N; 4230 (yyvsp[(2) - (8)].list) = checkarglist((yyvsp[(2) - (8)].list), 0); 4231 (yyvsp[(6) - (8)].list) = checkarglist((yyvsp[(6) - (8)].list), 1); 4232 4233 if((yyvsp[(2) - (8)].list) == nil) { 4234 yyerror("method has no receiver"); 4235 break; 4236 } 4237 if((yyvsp[(2) - (8)].list)->next != nil) { 4238 yyerror("method has multiple receivers"); 4239 break; 4240 } 4241 rcvr = (yyvsp[(2) - (8)].list)->n; 4242 if(rcvr->op != ODCLFIELD) { 4243 yyerror("bad receiver in method"); 4244 break; 4245 } 4246 if(rcvr->right->op == OTPAREN || (rcvr->right->op == OIND && rcvr->right->left->op == OTPAREN)) 4247 yyerror("cannot parenthesize receiver type"); 4248 4249 t = nod(OTFUNC, rcvr, N); 4250 t->list = (yyvsp[(6) - (8)].list); 4251 t->rlist = (yyvsp[(8) - (8)].list); 4252 4253 (yyval.node) = nod(ODCLFUNC, N, N); 4254 (yyval.node)->shortname = newname((yyvsp[(4) - (8)].sym)); 4255 (yyval.node)->nname = methodname1((yyval.node)->shortname, rcvr->right); 4256 (yyval.node)->nname->defn = (yyval.node); 4257 (yyval.node)->nname->ntype = t; 4258 (yyval.node)->nname->nointerface = nointerface; 4259 declare((yyval.node)->nname, PFUNC); 4260 4261 funchdr((yyval.node)); 4262 } 4263 break; 4264 4265 case 207: 4266 4267 /* Line 1806 of yacc.c */ 4268 #line 1387 "go.y" 4269 { 4270 Sym *s; 4271 Type *t; 4272 4273 (yyval.node) = N; 4274 4275 s = (yyvsp[(1) - (5)].sym); 4276 t = functype(N, (yyvsp[(3) - (5)].list), (yyvsp[(5) - (5)].list)); 4277 4278 importsym(s, ONAME); 4279 if(s->def != N && s->def->op == ONAME) { 4280 if(eqtype(t, s->def->type)) { 4281 dclcontext = PDISCARD; // since we skip funchdr below 4282 break; 4283 } 4284 yyerror("inconsistent definition for func %S during import\n\t%T\n\t%T", s, s->def->type, t); 4285 } 4286 4287 (yyval.node) = newname(s); 4288 (yyval.node)->type = t; 4289 declare((yyval.node), PFUNC); 4290 4291 funchdr((yyval.node)); 4292 } 4293 break; 4294 4295 case 208: 4296 4297 /* Line 1806 of yacc.c */ 4298 #line 1412 "go.y" 4299 { 4300 (yyval.node) = methodname1(newname((yyvsp[(4) - (8)].sym)), (yyvsp[(2) - (8)].list)->n->right); 4301 (yyval.node)->type = functype((yyvsp[(2) - (8)].list)->n, (yyvsp[(6) - (8)].list), (yyvsp[(8) - (8)].list)); 4302 4303 checkwidth((yyval.node)->type); 4304 addmethod((yyvsp[(4) - (8)].sym), (yyval.node)->type, 0, nointerface); 4305 nointerface = 0; 4306 funchdr((yyval.node)); 4307 4308 // inl.c's inlnode in on a dotmeth node expects to find the inlineable body as 4309 // (dotmeth's type)->nname->inl, and dotmeth's type has been pulled 4310 // out by typecheck's lookdot as this $$->ttype. So by providing 4311 // this back link here we avoid special casing there. 4312 (yyval.node)->type->nname = (yyval.node); 4313 } 4314 break; 4315 4316 case 209: 4317 4318 /* Line 1806 of yacc.c */ 4319 #line 1430 "go.y" 4320 { 4321 (yyvsp[(3) - (5)].list) = checkarglist((yyvsp[(3) - (5)].list), 1); 4322 (yyval.node) = nod(OTFUNC, N, N); 4323 (yyval.node)->list = (yyvsp[(3) - (5)].list); 4324 (yyval.node)->rlist = (yyvsp[(5) - (5)].list); 4325 } 4326 break; 4327 4328 case 210: 4329 4330 /* Line 1806 of yacc.c */ 4331 #line 1438 "go.y" 4332 { 4333 (yyval.list) = nil; 4334 } 4335 break; 4336 4337 case 211: 4338 4339 /* Line 1806 of yacc.c */ 4340 #line 1442 "go.y" 4341 { 4342 (yyval.list) = (yyvsp[(2) - (3)].list); 4343 if((yyval.list) == nil) 4344 (yyval.list) = list1(nod(OEMPTY, N, N)); 4345 } 4346 break; 4347 4348 case 212: 4349 4350 /* Line 1806 of yacc.c */ 4351 #line 1450 "go.y" 4352 { 4353 (yyval.list) = nil; 4354 } 4355 break; 4356 4357 case 213: 4358 4359 /* Line 1806 of yacc.c */ 4360 #line 1454 "go.y" 4361 { 4362 (yyval.list) = list1(nod(ODCLFIELD, N, (yyvsp[(1) - (1)].node))); 4363 } 4364 break; 4365 4366 case 214: 4367 4368 /* Line 1806 of yacc.c */ 4369 #line 1458 "go.y" 4370 { 4371 (yyvsp[(2) - (3)].list) = checkarglist((yyvsp[(2) - (3)].list), 0); 4372 (yyval.list) = (yyvsp[(2) - (3)].list); 4373 } 4374 break; 4375 4376 case 215: 4377 4378 /* Line 1806 of yacc.c */ 4379 #line 1465 "go.y" 4380 { 4381 closurehdr((yyvsp[(1) - (1)].node)); 4382 } 4383 break; 4384 4385 case 216: 4386 4387 /* Line 1806 of yacc.c */ 4388 #line 1471 "go.y" 4389 { 4390 (yyval.node) = closurebody((yyvsp[(3) - (4)].list)); 4391 fixlbrace((yyvsp[(2) - (4)].i)); 4392 } 4393 break; 4394 4395 case 217: 4396 4397 /* Line 1806 of yacc.c */ 4398 #line 1476 "go.y" 4399 { 4400 (yyval.node) = closurebody(nil); 4401 } 4402 break; 4403 4404 case 218: 4405 4406 /* Line 1806 of yacc.c */ 4407 #line 1487 "go.y" 4408 { 4409 (yyval.list) = nil; 4410 } 4411 break; 4412 4413 case 219: 4414 4415 /* Line 1806 of yacc.c */ 4416 #line 1491 "go.y" 4417 { 4418 (yyval.list) = concat((yyvsp[(1) - (3)].list), (yyvsp[(2) - (3)].list)); 4419 if(nsyntaxerrors == 0) 4420 testdclstack(); 4421 nointerface = 0; 4422 noescape = 0; 4423 } 4424 break; 4425 4426 case 221: 4427 4428 /* Line 1806 of yacc.c */ 4429 #line 1502 "go.y" 4430 { 4431 (yyval.list) = concat((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)); 4432 } 4433 break; 4434 4435 case 223: 4436 4437 /* Line 1806 of yacc.c */ 4438 #line 1509 "go.y" 4439 { 4440 (yyval.list) = concat((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)); 4441 } 4442 break; 4443 4444 case 224: 4445 4446 /* Line 1806 of yacc.c */ 4447 #line 1515 "go.y" 4448 { 4449 (yyval.list) = list1((yyvsp[(1) - (1)].node)); 4450 } 4451 break; 4452 4453 case 225: 4454 4455 /* Line 1806 of yacc.c */ 4456 #line 1519 "go.y" 4457 { 4458 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); 4459 } 4460 break; 4461 4462 case 227: 4463 4464 /* Line 1806 of yacc.c */ 4465 #line 1526 "go.y" 4466 { 4467 (yyval.list) = concat((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)); 4468 } 4469 break; 4470 4471 case 228: 4472 4473 /* Line 1806 of yacc.c */ 4474 #line 1532 "go.y" 4475 { 4476 (yyval.list) = list1((yyvsp[(1) - (1)].node)); 4477 } 4478 break; 4479 4480 case 229: 4481 4482 /* Line 1806 of yacc.c */ 4483 #line 1536 "go.y" 4484 { 4485 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); 4486 } 4487 break; 4488 4489 case 230: 4490 4491 /* Line 1806 of yacc.c */ 4492 #line 1542 "go.y" 4493 { 4494 NodeList *l; 4495 4496 Node *n; 4497 l = (yyvsp[(1) - (3)].list); 4498 if(l == nil) { 4499 // ? symbol, during import (list1(N) == nil) 4500 n = (yyvsp[(2) - (3)].node); 4501 if(n->op == OIND) 4502 n = n->left; 4503 n = embedded(n->sym, importpkg); 4504 n->right = (yyvsp[(2) - (3)].node); 4505 n->val = (yyvsp[(3) - (3)].val); 4506 (yyval.list) = list1(n); 4507 break; 4508 } 4509 4510 for(l=(yyvsp[(1) - (3)].list); l; l=l->next) { 4511 l->n = nod(ODCLFIELD, l->n, (yyvsp[(2) - (3)].node)); 4512 l->n->val = (yyvsp[(3) - (3)].val); 4513 } 4514 } 4515 break; 4516 4517 case 231: 4518 4519 /* Line 1806 of yacc.c */ 4520 #line 1565 "go.y" 4521 { 4522 (yyvsp[(1) - (2)].node)->val = (yyvsp[(2) - (2)].val); 4523 (yyval.list) = list1((yyvsp[(1) - (2)].node)); 4524 } 4525 break; 4526 4527 case 232: 4528 4529 /* Line 1806 of yacc.c */ 4530 #line 1570 "go.y" 4531 { 4532 (yyvsp[(2) - (4)].node)->val = (yyvsp[(4) - (4)].val); 4533 (yyval.list) = list1((yyvsp[(2) - (4)].node)); 4534 yyerror("cannot parenthesize embedded type"); 4535 } 4536 break; 4537 4538 case 233: 4539 4540 /* Line 1806 of yacc.c */ 4541 #line 1576 "go.y" 4542 { 4543 (yyvsp[(2) - (3)].node)->right = nod(OIND, (yyvsp[(2) - (3)].node)->right, N); 4544 (yyvsp[(2) - (3)].node)->val = (yyvsp[(3) - (3)].val); 4545 (yyval.list) = list1((yyvsp[(2) - (3)].node)); 4546 } 4547 break; 4548 4549 case 234: 4550 4551 /* Line 1806 of yacc.c */ 4552 #line 1582 "go.y" 4553 { 4554 (yyvsp[(3) - (5)].node)->right = nod(OIND, (yyvsp[(3) - (5)].node)->right, N); 4555 (yyvsp[(3) - (5)].node)->val = (yyvsp[(5) - (5)].val); 4556 (yyval.list) = list1((yyvsp[(3) - (5)].node)); 4557 yyerror("cannot parenthesize embedded type"); 4558 } 4559 break; 4560 4561 case 235: 4562 4563 /* Line 1806 of yacc.c */ 4564 #line 1589 "go.y" 4565 { 4566 (yyvsp[(3) - (5)].node)->right = nod(OIND, (yyvsp[(3) - (5)].node)->right, N); 4567 (yyvsp[(3) - (5)].node)->val = (yyvsp[(5) - (5)].val); 4568 (yyval.list) = list1((yyvsp[(3) - (5)].node)); 4569 yyerror("cannot parenthesize embedded type"); 4570 } 4571 break; 4572 4573 case 236: 4574 4575 /* Line 1806 of yacc.c */ 4576 #line 1598 "go.y" 4577 { 4578 Node *n; 4579 4580 (yyval.sym) = (yyvsp[(1) - (1)].sym); 4581 n = oldname((yyvsp[(1) - (1)].sym)); 4582 if(n->pack != N) 4583 n->pack->used = 1; 4584 } 4585 break; 4586 4587 case 237: 4588 4589 /* Line 1806 of yacc.c */ 4590 #line 1607 "go.y" 4591 { 4592 Pkg *pkg; 4593 4594 if((yyvsp[(1) - (3)].sym)->def == N || (yyvsp[(1) - (3)].sym)->def->op != OPACK) { 4595 yyerror("%S is not a package", (yyvsp[(1) - (3)].sym)); 4596 pkg = localpkg; 4597 } else { 4598 (yyvsp[(1) - (3)].sym)->def->used = 1; 4599 pkg = (yyvsp[(1) - (3)].sym)->def->pkg; 4600 } 4601 (yyval.sym) = restrictlookup((yyvsp[(3) - (3)].sym)->name, pkg); 4602 } 4603 break; 4604 4605 case 238: 4606 4607 /* Line 1806 of yacc.c */ 4608 #line 1622 "go.y" 4609 { 4610 (yyval.node) = embedded((yyvsp[(1) - (1)].sym), localpkg); 4611 } 4612 break; 4613 4614 case 239: 4615 4616 /* Line 1806 of yacc.c */ 4617 #line 1628 "go.y" 4618 { 4619 (yyval.node) = nod(ODCLFIELD, (yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node)); 4620 ifacedcl((yyval.node)); 4621 } 4622 break; 4623 4624 case 240: 4625 4626 /* Line 1806 of yacc.c */ 4627 #line 1633 "go.y" 4628 { 4629 (yyval.node) = nod(ODCLFIELD, N, oldname((yyvsp[(1) - (1)].sym))); 4630 } 4631 break; 4632 4633 case 241: 4634 4635 /* Line 1806 of yacc.c */ 4636 #line 1637 "go.y" 4637 { 4638 (yyval.node) = nod(ODCLFIELD, N, oldname((yyvsp[(2) - (3)].sym))); 4639 yyerror("cannot parenthesize embedded type"); 4640 } 4641 break; 4642 4643 case 242: 4644 4645 /* Line 1806 of yacc.c */ 4646 #line 1644 "go.y" 4647 { 4648 // without func keyword 4649 (yyvsp[(2) - (4)].list) = checkarglist((yyvsp[(2) - (4)].list), 1); 4650 (yyval.node) = nod(OTFUNC, fakethis(), N); 4651 (yyval.node)->list = (yyvsp[(2) - (4)].list); 4652 (yyval.node)->rlist = (yyvsp[(4) - (4)].list); 4653 } 4654 break; 4655 4656 case 244: 4657 4658 /* Line 1806 of yacc.c */ 4659 #line 1658 "go.y" 4660 { 4661 (yyval.node) = nod(ONONAME, N, N); 4662 (yyval.node)->sym = (yyvsp[(1) - (2)].sym); 4663 (yyval.node) = nod(OKEY, (yyval.node), (yyvsp[(2) - (2)].node)); 4664 } 4665 break; 4666 4667 case 245: 4668 4669 /* Line 1806 of yacc.c */ 4670 #line 1664 "go.y" 4671 { 4672 (yyval.node) = nod(ONONAME, N, N); 4673 (yyval.node)->sym = (yyvsp[(1) - (2)].sym); 4674 (yyval.node) = nod(OKEY, (yyval.node), (yyvsp[(2) - (2)].node)); 4675 } 4676 break; 4677 4678 case 247: 4679 4680 /* Line 1806 of yacc.c */ 4681 #line 1673 "go.y" 4682 { 4683 (yyval.list) = list1((yyvsp[(1) - (1)].node)); 4684 } 4685 break; 4686 4687 case 248: 4688 4689 /* Line 1806 of yacc.c */ 4690 #line 1677 "go.y" 4691 { 4692 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); 4693 } 4694 break; 4695 4696 case 249: 4697 4698 /* Line 1806 of yacc.c */ 4699 #line 1682 "go.y" 4700 { 4701 (yyval.list) = nil; 4702 } 4703 break; 4704 4705 case 250: 4706 4707 /* Line 1806 of yacc.c */ 4708 #line 1686 "go.y" 4709 { 4710 (yyval.list) = (yyvsp[(1) - (2)].list); 4711 } 4712 break; 4713 4714 case 251: 4715 4716 /* Line 1806 of yacc.c */ 4717 #line 1694 "go.y" 4718 { 4719 (yyval.node) = N; 4720 } 4721 break; 4722 4723 case 253: 4724 4725 /* Line 1806 of yacc.c */ 4726 #line 1699 "go.y" 4727 { 4728 (yyval.node) = liststmt((yyvsp[(1) - (1)].list)); 4729 } 4730 break; 4731 4732 case 255: 4733 4734 /* Line 1806 of yacc.c */ 4735 #line 1704 "go.y" 4736 { 4737 (yyval.node) = N; 4738 } 4739 break; 4740 4741 case 261: 4742 4743 /* Line 1806 of yacc.c */ 4744 #line 1715 "go.y" 4745 { 4746 (yyvsp[(1) - (2)].node) = nod(OLABEL, (yyvsp[(1) - (2)].node), N); 4747 (yyvsp[(1) - (2)].node)->sym = dclstack; // context, for goto restrictions 4748 } 4749 break; 4750 4751 case 262: 4752 4753 /* Line 1806 of yacc.c */ 4754 #line 1720 "go.y" 4755 { 4756 NodeList *l; 4757 4758 (yyvsp[(1) - (4)].node)->defn = (yyvsp[(4) - (4)].node); 4759 l = list1((yyvsp[(1) - (4)].node)); 4760 if((yyvsp[(4) - (4)].node)) 4761 l = list(l, (yyvsp[(4) - (4)].node)); 4762 (yyval.node) = liststmt(l); 4763 } 4764 break; 4765 4766 case 263: 4767 4768 /* Line 1806 of yacc.c */ 4769 #line 1730 "go.y" 4770 { 4771 // will be converted to OFALL 4772 (yyval.node) = nod(OXFALL, N, N); 4773 } 4774 break; 4775 4776 case 264: 4777 4778 /* Line 1806 of yacc.c */ 4779 #line 1735 "go.y" 4780 { 4781 (yyval.node) = nod(OBREAK, (yyvsp[(2) - (2)].node), N); 4782 } 4783 break; 4784 4785 case 265: 4786 4787 /* Line 1806 of yacc.c */ 4788 #line 1739 "go.y" 4789 { 4790 (yyval.node) = nod(OCONTINUE, (yyvsp[(2) - (2)].node), N); 4791 } 4792 break; 4793 4794 case 266: 4795 4796 /* Line 1806 of yacc.c */ 4797 #line 1743 "go.y" 4798 { 4799 (yyval.node) = nod(OPROC, (yyvsp[(2) - (2)].node), N); 4800 } 4801 break; 4802 4803 case 267: 4804 4805 /* Line 1806 of yacc.c */ 4806 #line 1747 "go.y" 4807 { 4808 (yyval.node) = nod(ODEFER, (yyvsp[(2) - (2)].node), N); 4809 } 4810 break; 4811 4812 case 268: 4813 4814 /* Line 1806 of yacc.c */ 4815 #line 1751 "go.y" 4816 { 4817 (yyval.node) = nod(OGOTO, (yyvsp[(2) - (2)].node), N); 4818 (yyval.node)->sym = dclstack; // context, for goto restrictions 4819 } 4820 break; 4821 4822 case 269: 4823 4824 /* Line 1806 of yacc.c */ 4825 #line 1756 "go.y" 4826 { 4827 (yyval.node) = nod(ORETURN, N, N); 4828 (yyval.node)->list = (yyvsp[(2) - (2)].list); 4829 if((yyval.node)->list == nil && curfn != N) { 4830 NodeList *l; 4831 4832 for(l=curfn->dcl; l; l=l->next) { 4833 if(l->n->class == PPARAM) 4834 continue; 4835 if(l->n->class != PPARAMOUT) 4836 break; 4837 if(l->n->sym->def != l->n) 4838 yyerror("%s is shadowed during return", l->n->sym->name); 4839 } 4840 } 4841 } 4842 break; 4843 4844 case 270: 4845 4846 /* Line 1806 of yacc.c */ 4847 #line 1775 "go.y" 4848 { 4849 (yyval.list) = nil; 4850 if((yyvsp[(1) - (1)].node) != N) 4851 (yyval.list) = list1((yyvsp[(1) - (1)].node)); 4852 } 4853 break; 4854 4855 case 271: 4856 4857 /* Line 1806 of yacc.c */ 4858 #line 1781 "go.y" 4859 { 4860 (yyval.list) = (yyvsp[(1) - (3)].list); 4861 if((yyvsp[(3) - (3)].node) != N) 4862 (yyval.list) = list((yyval.list), (yyvsp[(3) - (3)].node)); 4863 } 4864 break; 4865 4866 case 272: 4867 4868 /* Line 1806 of yacc.c */ 4869 #line 1789 "go.y" 4870 { 4871 (yyval.list) = list1((yyvsp[(1) - (1)].node)); 4872 } 4873 break; 4874 4875 case 273: 4876 4877 /* Line 1806 of yacc.c */ 4878 #line 1793 "go.y" 4879 { 4880 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); 4881 } 4882 break; 4883 4884 case 274: 4885 4886 /* Line 1806 of yacc.c */ 4887 #line 1799 "go.y" 4888 { 4889 (yyval.list) = list1((yyvsp[(1) - (1)].node)); 4890 } 4891 break; 4892 4893 case 275: 4894 4895 /* Line 1806 of yacc.c */ 4896 #line 1803 "go.y" 4897 { 4898 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); 4899 } 4900 break; 4901 4902 case 276: 4903 4904 /* Line 1806 of yacc.c */ 4905 #line 1809 "go.y" 4906 { 4907 (yyval.list) = list1((yyvsp[(1) - (1)].node)); 4908 } 4909 break; 4910 4911 case 277: 4912 4913 /* Line 1806 of yacc.c */ 4914 #line 1813 "go.y" 4915 { 4916 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); 4917 } 4918 break; 4919 4920 case 278: 4921 4922 /* Line 1806 of yacc.c */ 4923 #line 1819 "go.y" 4924 { 4925 (yyval.list) = list1((yyvsp[(1) - (1)].node)); 4926 } 4927 break; 4928 4929 case 279: 4930 4931 /* Line 1806 of yacc.c */ 4932 #line 1823 "go.y" 4933 { 4934 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); 4935 } 4936 break; 4937 4938 case 280: 4939 4940 /* Line 1806 of yacc.c */ 4941 #line 1832 "go.y" 4942 { 4943 (yyval.list) = list1((yyvsp[(1) - (1)].node)); 4944 } 4945 break; 4946 4947 case 281: 4948 4949 /* Line 1806 of yacc.c */ 4950 #line 1836 "go.y" 4951 { 4952 (yyval.list) = list1((yyvsp[(1) - (1)].node)); 4953 } 4954 break; 4955 4956 case 282: 4957 4958 /* Line 1806 of yacc.c */ 4959 #line 1840 "go.y" 4960 { 4961 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); 4962 } 4963 break; 4964 4965 case 283: 4966 4967 /* Line 1806 of yacc.c */ 4968 #line 1844 "go.y" 4969 { 4970 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); 4971 } 4972 break; 4973 4974 case 284: 4975 4976 /* Line 1806 of yacc.c */ 4977 #line 1849 "go.y" 4978 { 4979 (yyval.list) = nil; 4980 } 4981 break; 4982 4983 case 285: 4984 4985 /* Line 1806 of yacc.c */ 4986 #line 1853 "go.y" 4987 { 4988 (yyval.list) = (yyvsp[(1) - (2)].list); 4989 } 4990 break; 4991 4992 case 290: 4993 4994 /* Line 1806 of yacc.c */ 4995 #line 1867 "go.y" 4996 { 4997 (yyval.node) = N; 4998 } 4999 break; 5000 5001 case 292: 5002 5003 /* Line 1806 of yacc.c */ 5004 #line 1873 "go.y" 5005 { 5006 (yyval.list) = nil; 5007 } 5008 break; 5009 5010 case 294: 5011 5012 /* Line 1806 of yacc.c */ 5013 #line 1879 "go.y" 5014 { 5015 (yyval.node) = N; 5016 } 5017 break; 5018 5019 case 296: 5020 5021 /* Line 1806 of yacc.c */ 5022 #line 1885 "go.y" 5023 { 5024 (yyval.list) = nil; 5025 } 5026 break; 5027 5028 case 298: 5029 5030 /* Line 1806 of yacc.c */ 5031 #line 1891 "go.y" 5032 { 5033 (yyval.list) = nil; 5034 } 5035 break; 5036 5037 case 300: 5038 5039 /* Line 1806 of yacc.c */ 5040 #line 1897 "go.y" 5041 { 5042 (yyval.list) = nil; 5043 } 5044 break; 5045 5046 case 302: 5047 5048 /* Line 1806 of yacc.c */ 5049 #line 1903 "go.y" 5050 { 5051 (yyval.val).ctype = CTxxx; 5052 } 5053 break; 5054 5055 case 304: 5056 5057 /* Line 1806 of yacc.c */ 5058 #line 1913 "go.y" 5059 { 5060 importimport((yyvsp[(2) - (4)].sym), (yyvsp[(3) - (4)].val).u.sval); 5061 } 5062 break; 5063 5064 case 305: 5065 5066 /* Line 1806 of yacc.c */ 5067 #line 1917 "go.y" 5068 { 5069 importvar((yyvsp[(2) - (4)].sym), (yyvsp[(3) - (4)].type)); 5070 } 5071 break; 5072 5073 case 306: 5074 5075 /* Line 1806 of yacc.c */ 5076 #line 1921 "go.y" 5077 { 5078 importconst((yyvsp[(2) - (5)].sym), types[TIDEAL], (yyvsp[(4) - (5)].node)); 5079 } 5080 break; 5081 5082 case 307: 5083 5084 /* Line 1806 of yacc.c */ 5085 #line 1925 "go.y" 5086 { 5087 importconst((yyvsp[(2) - (6)].sym), (yyvsp[(3) - (6)].type), (yyvsp[(5) - (6)].node)); 5088 } 5089 break; 5090 5091 case 308: 5092 5093 /* Line 1806 of yacc.c */ 5094 #line 1929 "go.y" 5095 { 5096 importtype((yyvsp[(2) - (4)].type), (yyvsp[(3) - (4)].type)); 5097 } 5098 break; 5099 5100 case 309: 5101 5102 /* Line 1806 of yacc.c */ 5103 #line 1933 "go.y" 5104 { 5105 if((yyvsp[(2) - (4)].node) == N) { 5106 dclcontext = PEXTERN; // since we skip the funcbody below 5107 break; 5108 } 5109 5110 (yyvsp[(2) - (4)].node)->inl = (yyvsp[(3) - (4)].list); 5111 5112 funcbody((yyvsp[(2) - (4)].node)); 5113 importlist = list(importlist, (yyvsp[(2) - (4)].node)); 5114 5115 if(debug['E']) { 5116 print("import [%Z] func %lN \n", importpkg->path, (yyvsp[(2) - (4)].node)); 5117 if(debug['m'] > 2 && (yyvsp[(2) - (4)].node)->inl) 5118 print("inl body:%+H\n", (yyvsp[(2) - (4)].node)->inl); 5119 } 5120 } 5121 break; 5122 5123 case 310: 5124 5125 /* Line 1806 of yacc.c */ 5126 #line 1953 "go.y" 5127 { 5128 (yyval.sym) = (yyvsp[(1) - (1)].sym); 5129 structpkg = (yyval.sym)->pkg; 5130 } 5131 break; 5132 5133 case 311: 5134 5135 /* Line 1806 of yacc.c */ 5136 #line 1960 "go.y" 5137 { 5138 (yyval.type) = pkgtype((yyvsp[(1) - (1)].sym)); 5139 importsym((yyvsp[(1) - (1)].sym), OTYPE); 5140 } 5141 break; 5142 5143 case 317: 5144 5145 /* Line 1806 of yacc.c */ 5146 #line 1980 "go.y" 5147 { 5148 (yyval.type) = pkgtype((yyvsp[(1) - (1)].sym)); 5149 } 5150 break; 5151 5152 case 318: 5153 5154 /* Line 1806 of yacc.c */ 5155 #line 1984 "go.y" 5156 { 5157 // predefined name like uint8 5158 (yyvsp[(1) - (1)].sym) = pkglookup((yyvsp[(1) - (1)].sym)->name, builtinpkg); 5159 if((yyvsp[(1) - (1)].sym)->def == N || (yyvsp[(1) - (1)].sym)->def->op != OTYPE) { 5160 yyerror("%s is not a type", (yyvsp[(1) - (1)].sym)->name); 5161 (yyval.type) = T; 5162 } else 5163 (yyval.type) = (yyvsp[(1) - (1)].sym)->def->type; 5164 } 5165 break; 5166 5167 case 319: 5168 5169 /* Line 1806 of yacc.c */ 5170 #line 1994 "go.y" 5171 { 5172 (yyval.type) = aindex(N, (yyvsp[(3) - (3)].type)); 5173 } 5174 break; 5175 5176 case 320: 5177 5178 /* Line 1806 of yacc.c */ 5179 #line 1998 "go.y" 5180 { 5181 (yyval.type) = aindex(nodlit((yyvsp[(2) - (4)].val)), (yyvsp[(4) - (4)].type)); 5182 } 5183 break; 5184 5185 case 321: 5186 5187 /* Line 1806 of yacc.c */ 5188 #line 2002 "go.y" 5189 { 5190 (yyval.type) = maptype((yyvsp[(3) - (5)].type), (yyvsp[(5) - (5)].type)); 5191 } 5192 break; 5193 5194 case 322: 5195 5196 /* Line 1806 of yacc.c */ 5197 #line 2006 "go.y" 5198 { 5199 (yyval.type) = tostruct((yyvsp[(3) - (4)].list)); 5200 } 5201 break; 5202 5203 case 323: 5204 5205 /* Line 1806 of yacc.c */ 5206 #line 2010 "go.y" 5207 { 5208 (yyval.type) = tointerface((yyvsp[(3) - (4)].list)); 5209 } 5210 break; 5211 5212 case 324: 5213 5214 /* Line 1806 of yacc.c */ 5215 #line 2014 "go.y" 5216 { 5217 (yyval.type) = ptrto((yyvsp[(2) - (2)].type)); 5218 } 5219 break; 5220 5221 case 325: 5222 5223 /* Line 1806 of yacc.c */ 5224 #line 2018 "go.y" 5225 { 5226 (yyval.type) = typ(TCHAN); 5227 (yyval.type)->type = (yyvsp[(2) - (2)].type); 5228 (yyval.type)->chan = Cboth; 5229 } 5230 break; 5231 5232 case 326: 5233 5234 /* Line 1806 of yacc.c */ 5235 #line 2024 "go.y" 5236 { 5237 (yyval.type) = typ(TCHAN); 5238 (yyval.type)->type = (yyvsp[(3) - (4)].type); 5239 (yyval.type)->chan = Cboth; 5240 } 5241 break; 5242 5243 case 327: 5244 5245 /* Line 1806 of yacc.c */ 5246 #line 2030 "go.y" 5247 { 5248 (yyval.type) = typ(TCHAN); 5249 (yyval.type)->type = (yyvsp[(3) - (3)].type); 5250 (yyval.type)->chan = Csend; 5251 } 5252 break; 5253 5254 case 328: 5255 5256 /* Line 1806 of yacc.c */ 5257 #line 2038 "go.y" 5258 { 5259 (yyval.type) = typ(TCHAN); 5260 (yyval.type)->type = (yyvsp[(3) - (3)].type); 5261 (yyval.type)->chan = Crecv; 5262 } 5263 break; 5264 5265 case 329: 5266 5267 /* Line 1806 of yacc.c */ 5268 #line 2046 "go.y" 5269 { 5270 (yyval.type) = functype(nil, (yyvsp[(3) - (5)].list), (yyvsp[(5) - (5)].list)); 5271 } 5272 break; 5273 5274 case 330: 5275 5276 /* Line 1806 of yacc.c */ 5277 #line 2052 "go.y" 5278 { 5279 (yyval.node) = nod(ODCLFIELD, N, typenod((yyvsp[(2) - (3)].type))); 5280 if((yyvsp[(1) - (3)].sym)) 5281 (yyval.node)->left = newname((yyvsp[(1) - (3)].sym)); 5282 (yyval.node)->val = (yyvsp[(3) - (3)].val); 5283 } 5284 break; 5285 5286 case 331: 5287 5288 /* Line 1806 of yacc.c */ 5289 #line 2059 "go.y" 5290 { 5291 Type *t; 5292 5293 t = typ(TARRAY); 5294 t->bound = -1; 5295 t->type = (yyvsp[(3) - (4)].type); 5296 5297 (yyval.node) = nod(ODCLFIELD, N, typenod(t)); 5298 if((yyvsp[(1) - (4)].sym)) 5299 (yyval.node)->left = newname((yyvsp[(1) - (4)].sym)); 5300 (yyval.node)->isddd = 1; 5301 (yyval.node)->val = (yyvsp[(4) - (4)].val); 5302 } 5303 break; 5304 5305 case 332: 5306 5307 /* Line 1806 of yacc.c */ 5308 #line 2075 "go.y" 5309 { 5310 Sym *s; 5311 Pkg *p; 5312 5313 if((yyvsp[(1) - (3)].sym) != S && strcmp((yyvsp[(1) - (3)].sym)->name, "?") != 0) { 5314 (yyval.node) = nod(ODCLFIELD, newname((yyvsp[(1) - (3)].sym)), typenod((yyvsp[(2) - (3)].type))); 5315 (yyval.node)->val = (yyvsp[(3) - (3)].val); 5316 } else { 5317 s = (yyvsp[(2) - (3)].type)->sym; 5318 if(s == S && isptr[(yyvsp[(2) - (3)].type)->etype]) 5319 s = (yyvsp[(2) - (3)].type)->type->sym; 5320 p = importpkg; 5321 if((yyvsp[(1) - (3)].sym) != S) 5322 p = (yyvsp[(1) - (3)].sym)->pkg; 5323 (yyval.node) = embedded(s, p); 5324 (yyval.node)->right = typenod((yyvsp[(2) - (3)].type)); 5325 (yyval.node)->val = (yyvsp[(3) - (3)].val); 5326 } 5327 } 5328 break; 5329 5330 case 333: 5331 5332 /* Line 1806 of yacc.c */ 5333 #line 2097 "go.y" 5334 { 5335 (yyval.node) = nod(ODCLFIELD, newname((yyvsp[(1) - (5)].sym)), typenod(functype(fakethis(), (yyvsp[(3) - (5)].list), (yyvsp[(5) - (5)].list)))); 5336 } 5337 break; 5338 5339 case 334: 5340 5341 /* Line 1806 of yacc.c */ 5342 #line 2101 "go.y" 5343 { 5344 (yyval.node) = nod(ODCLFIELD, N, typenod((yyvsp[(1) - (1)].type))); 5345 } 5346 break; 5347 5348 case 335: 5349 5350 /* Line 1806 of yacc.c */ 5351 #line 2106 "go.y" 5352 { 5353 (yyval.list) = nil; 5354 } 5355 break; 5356 5357 case 337: 5358 5359 /* Line 1806 of yacc.c */ 5360 #line 2113 "go.y" 5361 { 5362 (yyval.list) = (yyvsp[(2) - (3)].list); 5363 } 5364 break; 5365 5366 case 338: 5367 5368 /* Line 1806 of yacc.c */ 5369 #line 2117 "go.y" 5370 { 5371 (yyval.list) = list1(nod(ODCLFIELD, N, typenod((yyvsp[(1) - (1)].type)))); 5372 } 5373 break; 5374 5375 case 339: 5376 5377 /* Line 1806 of yacc.c */ 5378 #line 2127 "go.y" 5379 { 5380 (yyval.node) = nodlit((yyvsp[(1) - (1)].val)); 5381 } 5382 break; 5383 5384 case 340: 5385 5386 /* Line 1806 of yacc.c */ 5387 #line 2131 "go.y" 5388 { 5389 (yyval.node) = nodlit((yyvsp[(2) - (2)].val)); 5390 switch((yyval.node)->val.ctype){ 5391 case CTINT: 5392 case CTRUNE: 5393 mpnegfix((yyval.node)->val.u.xval); 5394 break; 5395 case CTFLT: 5396 mpnegflt((yyval.node)->val.u.fval); 5397 break; 5398 default: 5399 yyerror("bad negated constant"); 5400 } 5401 } 5402 break; 5403 5404 case 341: 5405 5406 /* Line 1806 of yacc.c */ 5407 #line 2146 "go.y" 5408 { 5409 (yyval.node) = oldname(pkglookup((yyvsp[(1) - (1)].sym)->name, builtinpkg)); 5410 if((yyval.node)->op != OLITERAL) 5411 yyerror("bad constant %S", (yyval.node)->sym); 5412 } 5413 break; 5414 5415 case 343: 5416 5417 /* Line 1806 of yacc.c */ 5418 #line 2155 "go.y" 5419 { 5420 if((yyvsp[(2) - (5)].node)->val.ctype == CTRUNE && (yyvsp[(4) - (5)].node)->val.ctype == CTINT) { 5421 (yyval.node) = (yyvsp[(2) - (5)].node); 5422 mpaddfixfix((yyvsp[(2) - (5)].node)->val.u.xval, (yyvsp[(4) - (5)].node)->val.u.xval, 0); 5423 break; 5424 } 5425 (yyvsp[(4) - (5)].node)->val.u.cval->real = (yyvsp[(4) - (5)].node)->val.u.cval->imag; 5426 mpmovecflt(&(yyvsp[(4) - (5)].node)->val.u.cval->imag, 0.0); 5427 (yyval.node) = nodcplxlit((yyvsp[(2) - (5)].node)->val, (yyvsp[(4) - (5)].node)->val); 5428 } 5429 break; 5430 5431 case 346: 5432 5433 /* Line 1806 of yacc.c */ 5434 #line 2171 "go.y" 5435 { 5436 (yyval.list) = list1((yyvsp[(1) - (1)].node)); 5437 } 5438 break; 5439 5440 case 347: 5441 5442 /* Line 1806 of yacc.c */ 5443 #line 2175 "go.y" 5444 { 5445 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); 5446 } 5447 break; 5448 5449 case 348: 5450 5451 /* Line 1806 of yacc.c */ 5452 #line 2181 "go.y" 5453 { 5454 (yyval.list) = list1((yyvsp[(1) - (1)].node)); 5455 } 5456 break; 5457 5458 case 349: 5459 5460 /* Line 1806 of yacc.c */ 5461 #line 2185 "go.y" 5462 { 5463 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); 5464 } 5465 break; 5466 5467 case 350: 5468 5469 /* Line 1806 of yacc.c */ 5470 #line 2191 "go.y" 5471 { 5472 (yyval.list) = list1((yyvsp[(1) - (1)].node)); 5473 } 5474 break; 5475 5476 case 351: 5477 5478 /* Line 1806 of yacc.c */ 5479 #line 2195 "go.y" 5480 { 5481 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); 5482 } 5483 break; 5484 5485 5486 5487 /* Line 1806 of yacc.c */ 5488 #line 5490 "y.tab.c" 5489 default: break; 5490 } 5491 /* User semantic actions sometimes alter yychar, and that requires 5492 that yytoken be updated with the new translation. We take the 5493 approach of translating immediately before every use of yytoken. 5494 One alternative is translating here after every semantic action, 5495 but that translation would be missed if the semantic action invokes 5496 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 5497 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 5498 incorrect destructor might then be invoked immediately. In the 5499 case of YYERROR or YYBACKUP, subsequent parser actions might lead 5500 to an incorrect destructor call or verbose syntax error message 5501 before the lookahead is translated. */ 5502 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 5503 5504 YYPOPSTACK (yylen); 5505 yylen = 0; 5506 YY_STACK_PRINT (yyss, yyssp); 5507 5508 *++yyvsp = yyval; 5509 5510 /* Now `shift' the result of the reduction. Determine what state 5511 that goes to, based on the state we popped back to and the rule 5512 number reduced by. */ 5513 5514 yyn = yyr1[yyn]; 5515 5516 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 5517 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 5518 yystate = yytable[yystate]; 5519 else 5520 yystate = yydefgoto[yyn - YYNTOKENS]; 5521 5522 goto yynewstate; 5523 5524 5525 /*------------------------------------. 5526 | yyerrlab -- here on detecting error | 5527 `------------------------------------*/ 5528 yyerrlab: 5529 /* Make sure we have latest lookahead translation. See comments at 5530 user semantic actions for why this is necessary. */ 5531 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); 5532 5533 /* If not already recovering from an error, report this error. */ 5534 if (!yyerrstatus) 5535 { 5536 ++yynerrs; 5537 #if ! YYERROR_VERBOSE 5538 yyerror (YY_("syntax error")); 5539 #else 5540 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ 5541 yyssp, yytoken) 5542 { 5543 char *yymsgp = YY_("syntax error"); 5544 int yysyntax_error_status; 5545 yysyntax_error_status = YYSYNTAX_ERROR; 5546 if (yysyntax_error_status == 0) 5547 yymsgp = yymsg; 5548 else if (yysyntax_error_status == 1) 5549 { 5550 if (yymsg != yymsgbuf) 5551 YYSTACK_FREE (yymsg); 5552 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); 5553 if (!yymsg) 5554 { 5555 yymsg = yymsgbuf; 5556 yymsg_alloc = sizeof yymsgbuf; 5557 yysyntax_error_status = 2; 5558 } 5559 else 5560 { 5561 yysyntax_error_status = YYSYNTAX_ERROR; 5562 yymsgp = yymsg; 5563 } 5564 } 5565 yyerror (yymsgp); 5566 if (yysyntax_error_status == 2) 5567 goto yyexhaustedlab; 5568 } 5569 # undef YYSYNTAX_ERROR 5570 #endif 5571 } 5572 5573 5574 5575 if (yyerrstatus == 3) 5576 { 5577 /* If just tried and failed to reuse lookahead token after an 5578 error, discard it. */ 5579 5580 if (yychar <= YYEOF) 5581 { 5582 /* Return failure if at end of input. */ 5583 if (yychar == YYEOF) 5584 YYABORT; 5585 } 5586 else 5587 { 5588 yydestruct ("Error: discarding", 5589 yytoken, &yylval); 5590 yychar = YYEMPTY; 5591 } 5592 } 5593 5594 /* Else will try to reuse lookahead token after shifting the error 5595 token. */ 5596 goto yyerrlab1; 5597 5598 5599 /*---------------------------------------------------. 5600 | yyerrorlab -- error raised explicitly by YYERROR. | 5601 `---------------------------------------------------*/ 5602 yyerrorlab: 5603 5604 /* Pacify compilers like GCC when the user code never invokes 5605 YYERROR and the label yyerrorlab therefore never appears in user 5606 code. */ 5607 if (/*CONSTCOND*/ 0) 5608 goto yyerrorlab; 5609 5610 /* Do not reclaim the symbols of the rule which action triggered 5611 this YYERROR. */ 5612 YYPOPSTACK (yylen); 5613 yylen = 0; 5614 YY_STACK_PRINT (yyss, yyssp); 5615 yystate = *yyssp; 5616 goto yyerrlab1; 5617 5618 5619 /*-------------------------------------------------------------. 5620 | yyerrlab1 -- common code for both syntax error and YYERROR. | 5621 `-------------------------------------------------------------*/ 5622 yyerrlab1: 5623 yyerrstatus = 3; /* Each real token shifted decrements this. */ 5624 5625 for (;;) 5626 { 5627 yyn = yypact[yystate]; 5628 if (!yypact_value_is_default (yyn)) 5629 { 5630 yyn += YYTERROR; 5631 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 5632 { 5633 yyn = yytable[yyn]; 5634 if (0 < yyn) 5635 break; 5636 } 5637 } 5638 5639 /* Pop the current state because it cannot handle the error token. */ 5640 if (yyssp == yyss) 5641 YYABORT; 5642 5643 5644 yydestruct ("Error: popping", 5645 yystos[yystate], yyvsp); 5646 YYPOPSTACK (1); 5647 yystate = *yyssp; 5648 YY_STACK_PRINT (yyss, yyssp); 5649 } 5650 5651 *++yyvsp = yylval; 5652 5653 5654 /* Shift the error token. */ 5655 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 5656 5657 yystate = yyn; 5658 goto yynewstate; 5659 5660 5661 /*-------------------------------------. 5662 | yyacceptlab -- YYACCEPT comes here. | 5663 `-------------------------------------*/ 5664 yyacceptlab: 5665 yyresult = 0; 5666 goto yyreturn; 5667 5668 /*-----------------------------------. 5669 | yyabortlab -- YYABORT comes here. | 5670 `-----------------------------------*/ 5671 yyabortlab: 5672 yyresult = 1; 5673 goto yyreturn; 5674 5675 #if !defined(yyoverflow) || YYERROR_VERBOSE 5676 /*-------------------------------------------------. 5677 | yyexhaustedlab -- memory exhaustion comes here. | 5678 `-------------------------------------------------*/ 5679 yyexhaustedlab: 5680 yyerror (YY_("memory exhausted")); 5681 yyresult = 2; 5682 /* Fall through. */ 5683 #endif 5684 5685 yyreturn: 5686 if (yychar != YYEMPTY) 5687 { 5688 /* Make sure we have latest lookahead translation. See comments at 5689 user semantic actions for why this is necessary. */ 5690 yytoken = YYTRANSLATE (yychar); 5691 yydestruct ("Cleanup: discarding lookahead", 5692 yytoken, &yylval); 5693 } 5694 /* Do not reclaim the symbols of the rule which action triggered 5695 this YYABORT or YYACCEPT. */ 5696 YYPOPSTACK (yylen); 5697 YY_STACK_PRINT (yyss, yyssp); 5698 while (yyssp != yyss) 5699 { 5700 yydestruct ("Cleanup: popping", 5701 yystos[*yyssp], yyvsp); 5702 YYPOPSTACK (1); 5703 } 5704 #ifndef yyoverflow 5705 if (yyss != yyssa) 5706 YYSTACK_FREE (yyss); 5707 #endif 5708 #if YYERROR_VERBOSE 5709 if (yymsg != yymsgbuf) 5710 YYSTACK_FREE (yymsg); 5711 #endif 5712 /* Make sure YYID is used. */ 5713 return YYID (yyresult); 5714 } 5715 5716 5717 5718 /* Line 2067 of yacc.c */ 5719 #line 2199 "go.y" 5720 5721 5722 static void 5723 fixlbrace(int lbr) 5724 { 5725 // If the opening brace was an LBODY, 5726 // set up for another one now that we're done. 5727 // See comment in lex.c about loophack. 5728 if(lbr == LBODY) 5729 loophack = 1; 5730 } 5731 5732