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