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