github.com/tcnksm/go@v0.0.0-20141208075154-439b32936367/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, 1326, 1355, 1393, 1418, 682 1436, 1445, 1448, 1456, 1460, 1464, 1471, 1477, 1482, 1494, 683 1497, 1508, 1509, 1515, 1516, 1522, 1526, 1532, 1533, 1539, 684 1543, 1549, 1572, 1577, 1583, 1589, 1596, 1605, 1614, 1629, 685 1635, 1640, 1644, 1651, 1664, 1665, 1671, 1677, 1680, 1684, 686 1690, 1693, 1702, 1705, 1706, 1710, 1711, 1717, 1718, 1719, 687 1720, 1721, 1723, 1722, 1737, 1743, 1747, 1751, 1755, 1759, 688 1764, 1783, 1789, 1797, 1801, 1807, 1811, 1817, 1821, 1827, 689 1831, 1840, 1844, 1848, 1852, 1858, 1861, 1869, 1870, 1872, 690 1873, 1876, 1879, 1882, 1885, 1888, 1891, 1894, 1897, 1900, 691 1903, 1906, 1909, 1912, 1915, 1921, 1925, 1929, 1933, 1937, 692 1941, 1961, 1968, 1979, 1980, 1981, 1984, 1985, 1988, 1992, 693 2002, 2006, 2010, 2014, 2018, 2022, 2026, 2032, 2038, 2046, 694 2054, 2060, 2067, 2083, 2105, 2109, 2115, 2118, 2121, 2125, 695 2135, 2139, 2158, 2166, 2167, 2179, 2180, 2183, 2187, 2193, 696 2197, 2203, 2207 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 funcbody((yyval.node)); 3829 } 3830 break; 3831 3832 case 206: 3833 #line 1327 "go.y" 3834 { 3835 Node *t; 3836 3837 (yyval.node) = N; 3838 (yyvsp[(3) - (5)].list) = checkarglist((yyvsp[(3) - (5)].list), 1); 3839 3840 if(strcmp((yyvsp[(1) - (5)].sym)->name, "init") == 0) { 3841 (yyvsp[(1) - (5)].sym) = renameinit(); 3842 if((yyvsp[(3) - (5)].list) != nil || (yyvsp[(5) - (5)].list) != nil) 3843 yyerror("func init must have no arguments and no return values"); 3844 } 3845 if(strcmp(localpkg->name, "main") == 0 && strcmp((yyvsp[(1) - (5)].sym)->name, "main") == 0) { 3846 if((yyvsp[(3) - (5)].list) != nil || (yyvsp[(5) - (5)].list) != nil) 3847 yyerror("func main must have no arguments and no return values"); 3848 } 3849 3850 t = nod(OTFUNC, N, N); 3851 t->list = (yyvsp[(3) - (5)].list); 3852 t->rlist = (yyvsp[(5) - (5)].list); 3853 3854 (yyval.node) = nod(ODCLFUNC, N, N); 3855 (yyval.node)->nname = newname((yyvsp[(1) - (5)].sym)); 3856 (yyval.node)->nname->defn = (yyval.node); 3857 (yyval.node)->nname->ntype = t; // TODO: check if nname already has an ntype 3858 declare((yyval.node)->nname, PFUNC); 3859 3860 funchdr((yyval.node)); 3861 } 3862 break; 3863 3864 case 207: 3865 #line 1356 "go.y" 3866 { 3867 Node *rcvr, *t; 3868 3869 (yyval.node) = N; 3870 (yyvsp[(2) - (8)].list) = checkarglist((yyvsp[(2) - (8)].list), 0); 3871 (yyvsp[(6) - (8)].list) = checkarglist((yyvsp[(6) - (8)].list), 1); 3872 3873 if((yyvsp[(2) - (8)].list) == nil) { 3874 yyerror("method has no receiver"); 3875 break; 3876 } 3877 if((yyvsp[(2) - (8)].list)->next != nil) { 3878 yyerror("method has multiple receivers"); 3879 break; 3880 } 3881 rcvr = (yyvsp[(2) - (8)].list)->n; 3882 if(rcvr->op != ODCLFIELD) { 3883 yyerror("bad receiver in method"); 3884 break; 3885 } 3886 3887 t = nod(OTFUNC, rcvr, N); 3888 t->list = (yyvsp[(6) - (8)].list); 3889 t->rlist = (yyvsp[(8) - (8)].list); 3890 3891 (yyval.node) = nod(ODCLFUNC, N, N); 3892 (yyval.node)->shortname = newname((yyvsp[(4) - (8)].sym)); 3893 (yyval.node)->nname = methodname1((yyval.node)->shortname, rcvr->right); 3894 (yyval.node)->nname->defn = (yyval.node); 3895 (yyval.node)->nname->ntype = t; 3896 (yyval.node)->nname->nointerface = nointerface; 3897 declare((yyval.node)->nname, PFUNC); 3898 3899 funchdr((yyval.node)); 3900 } 3901 break; 3902 3903 case 208: 3904 #line 1394 "go.y" 3905 { 3906 Sym *s; 3907 Type *t; 3908 3909 (yyval.node) = N; 3910 3911 s = (yyvsp[(1) - (5)].sym); 3912 t = functype(N, (yyvsp[(3) - (5)].list), (yyvsp[(5) - (5)].list)); 3913 3914 importsym(s, ONAME); 3915 if(s->def != N && s->def->op == ONAME) { 3916 if(eqtype(t, s->def->type)) { 3917 dclcontext = PDISCARD; // since we skip funchdr below 3918 break; 3919 } 3920 yyerror("inconsistent definition for func %S during import\n\t%T\n\t%T", s, s->def->type, t); 3921 } 3922 3923 (yyval.node) = newname(s); 3924 (yyval.node)->type = t; 3925 declare((yyval.node), PFUNC); 3926 3927 funchdr((yyval.node)); 3928 } 3929 break; 3930 3931 case 209: 3932 #line 1419 "go.y" 3933 { 3934 (yyval.node) = methodname1(newname((yyvsp[(4) - (8)].sym)), (yyvsp[(2) - (8)].list)->n->right); 3935 (yyval.node)->type = functype((yyvsp[(2) - (8)].list)->n, (yyvsp[(6) - (8)].list), (yyvsp[(8) - (8)].list)); 3936 3937 checkwidth((yyval.node)->type); 3938 addmethod((yyvsp[(4) - (8)].sym), (yyval.node)->type, 0, nointerface); 3939 nointerface = 0; 3940 funchdr((yyval.node)); 3941 3942 // inl.c's inlnode in on a dotmeth node expects to find the inlineable body as 3943 // (dotmeth's type)->nname->inl, and dotmeth's type has been pulled 3944 // out by typecheck's lookdot as this $$->ttype. So by providing 3945 // this back link here we avoid special casing there. 3946 (yyval.node)->type->nname = (yyval.node); 3947 } 3948 break; 3949 3950 case 210: 3951 #line 1437 "go.y" 3952 { 3953 (yyvsp[(3) - (5)].list) = checkarglist((yyvsp[(3) - (5)].list), 1); 3954 (yyval.node) = nod(OTFUNC, N, N); 3955 (yyval.node)->list = (yyvsp[(3) - (5)].list); 3956 (yyval.node)->rlist = (yyvsp[(5) - (5)].list); 3957 } 3958 break; 3959 3960 case 211: 3961 #line 1445 "go.y" 3962 { 3963 (yyval.list) = nil; 3964 } 3965 break; 3966 3967 case 212: 3968 #line 1449 "go.y" 3969 { 3970 (yyval.list) = (yyvsp[(2) - (3)].list); 3971 if((yyval.list) == nil) 3972 (yyval.list) = list1(nod(OEMPTY, N, N)); 3973 } 3974 break; 3975 3976 case 213: 3977 #line 1457 "go.y" 3978 { 3979 (yyval.list) = nil; 3980 } 3981 break; 3982 3983 case 214: 3984 #line 1461 "go.y" 3985 { 3986 (yyval.list) = list1(nod(ODCLFIELD, N, (yyvsp[(1) - (1)].node))); 3987 } 3988 break; 3989 3990 case 215: 3991 #line 1465 "go.y" 3992 { 3993 (yyvsp[(2) - (3)].list) = checkarglist((yyvsp[(2) - (3)].list), 0); 3994 (yyval.list) = (yyvsp[(2) - (3)].list); 3995 } 3996 break; 3997 3998 case 216: 3999 #line 1472 "go.y" 4000 { 4001 closurehdr((yyvsp[(1) - (1)].node)); 4002 } 4003 break; 4004 4005 case 217: 4006 #line 1478 "go.y" 4007 { 4008 (yyval.node) = closurebody((yyvsp[(3) - (4)].list)); 4009 fixlbrace((yyvsp[(2) - (4)].i)); 4010 } 4011 break; 4012 4013 case 218: 4014 #line 1483 "go.y" 4015 { 4016 (yyval.node) = closurebody(nil); 4017 } 4018 break; 4019 4020 case 219: 4021 #line 1494 "go.y" 4022 { 4023 (yyval.list) = nil; 4024 } 4025 break; 4026 4027 case 220: 4028 #line 1498 "go.y" 4029 { 4030 (yyval.list) = concat((yyvsp[(1) - (3)].list), (yyvsp[(2) - (3)].list)); 4031 if(nsyntaxerrors == 0) 4032 testdclstack(); 4033 nointerface = 0; 4034 noescape = 0; 4035 nosplit = 0; 4036 } 4037 break; 4038 4039 case 222: 4040 #line 1510 "go.y" 4041 { 4042 (yyval.list) = concat((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)); 4043 } 4044 break; 4045 4046 case 224: 4047 #line 1517 "go.y" 4048 { 4049 (yyval.list) = concat((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)); 4050 } 4051 break; 4052 4053 case 225: 4054 #line 1523 "go.y" 4055 { 4056 (yyval.list) = list1((yyvsp[(1) - (1)].node)); 4057 } 4058 break; 4059 4060 case 226: 4061 #line 1527 "go.y" 4062 { 4063 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); 4064 } 4065 break; 4066 4067 case 228: 4068 #line 1534 "go.y" 4069 { 4070 (yyval.list) = concat((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)); 4071 } 4072 break; 4073 4074 case 229: 4075 #line 1540 "go.y" 4076 { 4077 (yyval.list) = list1((yyvsp[(1) - (1)].node)); 4078 } 4079 break; 4080 4081 case 230: 4082 #line 1544 "go.y" 4083 { 4084 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); 4085 } 4086 break; 4087 4088 case 231: 4089 #line 1550 "go.y" 4090 { 4091 NodeList *l; 4092 4093 Node *n; 4094 l = (yyvsp[(1) - (3)].list); 4095 if(l == nil) { 4096 // ? symbol, during import (list1(N) == nil) 4097 n = (yyvsp[(2) - (3)].node); 4098 if(n->op == OIND) 4099 n = n->left; 4100 n = embedded(n->sym, importpkg); 4101 n->right = (yyvsp[(2) - (3)].node); 4102 n->val = (yyvsp[(3) - (3)].val); 4103 (yyval.list) = list1(n); 4104 break; 4105 } 4106 4107 for(l=(yyvsp[(1) - (3)].list); l; l=l->next) { 4108 l->n = nod(ODCLFIELD, l->n, (yyvsp[(2) - (3)].node)); 4109 l->n->val = (yyvsp[(3) - (3)].val); 4110 } 4111 } 4112 break; 4113 4114 case 232: 4115 #line 1573 "go.y" 4116 { 4117 (yyvsp[(1) - (2)].node)->val = (yyvsp[(2) - (2)].val); 4118 (yyval.list) = list1((yyvsp[(1) - (2)].node)); 4119 } 4120 break; 4121 4122 case 233: 4123 #line 1578 "go.y" 4124 { 4125 (yyvsp[(2) - (4)].node)->val = (yyvsp[(4) - (4)].val); 4126 (yyval.list) = list1((yyvsp[(2) - (4)].node)); 4127 yyerror("cannot parenthesize embedded type"); 4128 } 4129 break; 4130 4131 case 234: 4132 #line 1584 "go.y" 4133 { 4134 (yyvsp[(2) - (3)].node)->right = nod(OIND, (yyvsp[(2) - (3)].node)->right, N); 4135 (yyvsp[(2) - (3)].node)->val = (yyvsp[(3) - (3)].val); 4136 (yyval.list) = list1((yyvsp[(2) - (3)].node)); 4137 } 4138 break; 4139 4140 case 235: 4141 #line 1590 "go.y" 4142 { 4143 (yyvsp[(3) - (5)].node)->right = nod(OIND, (yyvsp[(3) - (5)].node)->right, N); 4144 (yyvsp[(3) - (5)].node)->val = (yyvsp[(5) - (5)].val); 4145 (yyval.list) = list1((yyvsp[(3) - (5)].node)); 4146 yyerror("cannot parenthesize embedded type"); 4147 } 4148 break; 4149 4150 case 236: 4151 #line 1597 "go.y" 4152 { 4153 (yyvsp[(3) - (5)].node)->right = nod(OIND, (yyvsp[(3) - (5)].node)->right, N); 4154 (yyvsp[(3) - (5)].node)->val = (yyvsp[(5) - (5)].val); 4155 (yyval.list) = list1((yyvsp[(3) - (5)].node)); 4156 yyerror("cannot parenthesize embedded type"); 4157 } 4158 break; 4159 4160 case 237: 4161 #line 1606 "go.y" 4162 { 4163 Node *n; 4164 4165 (yyval.sym) = (yyvsp[(1) - (1)].sym); 4166 n = oldname((yyvsp[(1) - (1)].sym)); 4167 if(n->pack != N) 4168 n->pack->used = 1; 4169 } 4170 break; 4171 4172 case 238: 4173 #line 1615 "go.y" 4174 { 4175 Pkg *pkg; 4176 4177 if((yyvsp[(1) - (3)].sym)->def == N || (yyvsp[(1) - (3)].sym)->def->op != OPACK) { 4178 yyerror("%S is not a package", (yyvsp[(1) - (3)].sym)); 4179 pkg = localpkg; 4180 } else { 4181 (yyvsp[(1) - (3)].sym)->def->used = 1; 4182 pkg = (yyvsp[(1) - (3)].sym)->def->pkg; 4183 } 4184 (yyval.sym) = restrictlookup((yyvsp[(3) - (3)].sym)->name, pkg); 4185 } 4186 break; 4187 4188 case 239: 4189 #line 1630 "go.y" 4190 { 4191 (yyval.node) = embedded((yyvsp[(1) - (1)].sym), localpkg); 4192 } 4193 break; 4194 4195 case 240: 4196 #line 1636 "go.y" 4197 { 4198 (yyval.node) = nod(ODCLFIELD, (yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node)); 4199 ifacedcl((yyval.node)); 4200 } 4201 break; 4202 4203 case 241: 4204 #line 1641 "go.y" 4205 { 4206 (yyval.node) = nod(ODCLFIELD, N, oldname((yyvsp[(1) - (1)].sym))); 4207 } 4208 break; 4209 4210 case 242: 4211 #line 1645 "go.y" 4212 { 4213 (yyval.node) = nod(ODCLFIELD, N, oldname((yyvsp[(2) - (3)].sym))); 4214 yyerror("cannot parenthesize embedded type"); 4215 } 4216 break; 4217 4218 case 243: 4219 #line 1652 "go.y" 4220 { 4221 // without func keyword 4222 (yyvsp[(2) - (4)].list) = checkarglist((yyvsp[(2) - (4)].list), 1); 4223 (yyval.node) = nod(OTFUNC, fakethis(), N); 4224 (yyval.node)->list = (yyvsp[(2) - (4)].list); 4225 (yyval.node)->rlist = (yyvsp[(4) - (4)].list); 4226 } 4227 break; 4228 4229 case 245: 4230 #line 1666 "go.y" 4231 { 4232 (yyval.node) = nod(ONONAME, N, N); 4233 (yyval.node)->sym = (yyvsp[(1) - (2)].sym); 4234 (yyval.node) = nod(OKEY, (yyval.node), (yyvsp[(2) - (2)].node)); 4235 } 4236 break; 4237 4238 case 246: 4239 #line 1672 "go.y" 4240 { 4241 (yyval.node) = nod(ONONAME, N, N); 4242 (yyval.node)->sym = (yyvsp[(1) - (2)].sym); 4243 (yyval.node) = nod(OKEY, (yyval.node), (yyvsp[(2) - (2)].node)); 4244 } 4245 break; 4246 4247 case 248: 4248 #line 1681 "go.y" 4249 { 4250 (yyval.list) = list1((yyvsp[(1) - (1)].node)); 4251 } 4252 break; 4253 4254 case 249: 4255 #line 1685 "go.y" 4256 { 4257 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); 4258 } 4259 break; 4260 4261 case 250: 4262 #line 1690 "go.y" 4263 { 4264 (yyval.list) = nil; 4265 } 4266 break; 4267 4268 case 251: 4269 #line 1694 "go.y" 4270 { 4271 (yyval.list) = (yyvsp[(1) - (2)].list); 4272 } 4273 break; 4274 4275 case 252: 4276 #line 1702 "go.y" 4277 { 4278 (yyval.node) = N; 4279 } 4280 break; 4281 4282 case 254: 4283 #line 1707 "go.y" 4284 { 4285 (yyval.node) = liststmt((yyvsp[(1) - (1)].list)); 4286 } 4287 break; 4288 4289 case 256: 4290 #line 1712 "go.y" 4291 { 4292 (yyval.node) = N; 4293 } 4294 break; 4295 4296 case 262: 4297 #line 1723 "go.y" 4298 { 4299 (yyvsp[(1) - (2)].node) = nod(OLABEL, (yyvsp[(1) - (2)].node), N); 4300 (yyvsp[(1) - (2)].node)->sym = dclstack; // context, for goto restrictions 4301 } 4302 break; 4303 4304 case 263: 4305 #line 1728 "go.y" 4306 { 4307 NodeList *l; 4308 4309 (yyvsp[(1) - (4)].node)->defn = (yyvsp[(4) - (4)].node); 4310 l = list1((yyvsp[(1) - (4)].node)); 4311 if((yyvsp[(4) - (4)].node)) 4312 l = list(l, (yyvsp[(4) - (4)].node)); 4313 (yyval.node) = liststmt(l); 4314 } 4315 break; 4316 4317 case 264: 4318 #line 1738 "go.y" 4319 { 4320 // will be converted to OFALL 4321 (yyval.node) = nod(OXFALL, N, N); 4322 (yyval.node)->xoffset = block; 4323 } 4324 break; 4325 4326 case 265: 4327 #line 1744 "go.y" 4328 { 4329 (yyval.node) = nod(OBREAK, (yyvsp[(2) - (2)].node), N); 4330 } 4331 break; 4332 4333 case 266: 4334 #line 1748 "go.y" 4335 { 4336 (yyval.node) = nod(OCONTINUE, (yyvsp[(2) - (2)].node), N); 4337 } 4338 break; 4339 4340 case 267: 4341 #line 1752 "go.y" 4342 { 4343 (yyval.node) = nod(OPROC, (yyvsp[(2) - (2)].node), N); 4344 } 4345 break; 4346 4347 case 268: 4348 #line 1756 "go.y" 4349 { 4350 (yyval.node) = nod(ODEFER, (yyvsp[(2) - (2)].node), N); 4351 } 4352 break; 4353 4354 case 269: 4355 #line 1760 "go.y" 4356 { 4357 (yyval.node) = nod(OGOTO, (yyvsp[(2) - (2)].node), N); 4358 (yyval.node)->sym = dclstack; // context, for goto restrictions 4359 } 4360 break; 4361 4362 case 270: 4363 #line 1765 "go.y" 4364 { 4365 (yyval.node) = nod(ORETURN, N, N); 4366 (yyval.node)->list = (yyvsp[(2) - (2)].list); 4367 if((yyval.node)->list == nil && curfn != N) { 4368 NodeList *l; 4369 4370 for(l=curfn->dcl; l; l=l->next) { 4371 if(l->n->class == PPARAM) 4372 continue; 4373 if(l->n->class != PPARAMOUT) 4374 break; 4375 if(l->n->sym->def != l->n) 4376 yyerror("%s is shadowed during return", l->n->sym->name); 4377 } 4378 } 4379 } 4380 break; 4381 4382 case 271: 4383 #line 1784 "go.y" 4384 { 4385 (yyval.list) = nil; 4386 if((yyvsp[(1) - (1)].node) != N) 4387 (yyval.list) = list1((yyvsp[(1) - (1)].node)); 4388 } 4389 break; 4390 4391 case 272: 4392 #line 1790 "go.y" 4393 { 4394 (yyval.list) = (yyvsp[(1) - (3)].list); 4395 if((yyvsp[(3) - (3)].node) != N) 4396 (yyval.list) = list((yyval.list), (yyvsp[(3) - (3)].node)); 4397 } 4398 break; 4399 4400 case 273: 4401 #line 1798 "go.y" 4402 { 4403 (yyval.list) = list1((yyvsp[(1) - (1)].node)); 4404 } 4405 break; 4406 4407 case 274: 4408 #line 1802 "go.y" 4409 { 4410 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); 4411 } 4412 break; 4413 4414 case 275: 4415 #line 1808 "go.y" 4416 { 4417 (yyval.list) = list1((yyvsp[(1) - (1)].node)); 4418 } 4419 break; 4420 4421 case 276: 4422 #line 1812 "go.y" 4423 { 4424 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); 4425 } 4426 break; 4427 4428 case 277: 4429 #line 1818 "go.y" 4430 { 4431 (yyval.list) = list1((yyvsp[(1) - (1)].node)); 4432 } 4433 break; 4434 4435 case 278: 4436 #line 1822 "go.y" 4437 { 4438 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); 4439 } 4440 break; 4441 4442 case 279: 4443 #line 1828 "go.y" 4444 { 4445 (yyval.list) = list1((yyvsp[(1) - (1)].node)); 4446 } 4447 break; 4448 4449 case 280: 4450 #line 1832 "go.y" 4451 { 4452 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); 4453 } 4454 break; 4455 4456 case 281: 4457 #line 1841 "go.y" 4458 { 4459 (yyval.list) = list1((yyvsp[(1) - (1)].node)); 4460 } 4461 break; 4462 4463 case 282: 4464 #line 1845 "go.y" 4465 { 4466 (yyval.list) = list1((yyvsp[(1) - (1)].node)); 4467 } 4468 break; 4469 4470 case 283: 4471 #line 1849 "go.y" 4472 { 4473 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); 4474 } 4475 break; 4476 4477 case 284: 4478 #line 1853 "go.y" 4479 { 4480 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); 4481 } 4482 break; 4483 4484 case 285: 4485 #line 1858 "go.y" 4486 { 4487 (yyval.list) = nil; 4488 } 4489 break; 4490 4491 case 286: 4492 #line 1862 "go.y" 4493 { 4494 (yyval.list) = (yyvsp[(1) - (2)].list); 4495 } 4496 break; 4497 4498 case 291: 4499 #line 1876 "go.y" 4500 { 4501 (yyval.node) = N; 4502 } 4503 break; 4504 4505 case 293: 4506 #line 1882 "go.y" 4507 { 4508 (yyval.list) = nil; 4509 } 4510 break; 4511 4512 case 295: 4513 #line 1888 "go.y" 4514 { 4515 (yyval.node) = N; 4516 } 4517 break; 4518 4519 case 297: 4520 #line 1894 "go.y" 4521 { 4522 (yyval.list) = nil; 4523 } 4524 break; 4525 4526 case 299: 4527 #line 1900 "go.y" 4528 { 4529 (yyval.list) = nil; 4530 } 4531 break; 4532 4533 case 301: 4534 #line 1906 "go.y" 4535 { 4536 (yyval.list) = nil; 4537 } 4538 break; 4539 4540 case 303: 4541 #line 1912 "go.y" 4542 { 4543 (yyval.val).ctype = CTxxx; 4544 } 4545 break; 4546 4547 case 305: 4548 #line 1922 "go.y" 4549 { 4550 importimport((yyvsp[(2) - (4)].sym), (yyvsp[(3) - (4)].val).u.sval); 4551 } 4552 break; 4553 4554 case 306: 4555 #line 1926 "go.y" 4556 { 4557 importvar((yyvsp[(2) - (4)].sym), (yyvsp[(3) - (4)].type)); 4558 } 4559 break; 4560 4561 case 307: 4562 #line 1930 "go.y" 4563 { 4564 importconst((yyvsp[(2) - (5)].sym), types[TIDEAL], (yyvsp[(4) - (5)].node)); 4565 } 4566 break; 4567 4568 case 308: 4569 #line 1934 "go.y" 4570 { 4571 importconst((yyvsp[(2) - (6)].sym), (yyvsp[(3) - (6)].type), (yyvsp[(5) - (6)].node)); 4572 } 4573 break; 4574 4575 case 309: 4576 #line 1938 "go.y" 4577 { 4578 importtype((yyvsp[(2) - (4)].type), (yyvsp[(3) - (4)].type)); 4579 } 4580 break; 4581 4582 case 310: 4583 #line 1942 "go.y" 4584 { 4585 if((yyvsp[(2) - (4)].node) == N) { 4586 dclcontext = PEXTERN; // since we skip the funcbody below 4587 break; 4588 } 4589 4590 (yyvsp[(2) - (4)].node)->inl = (yyvsp[(3) - (4)].list); 4591 4592 funcbody((yyvsp[(2) - (4)].node)); 4593 importlist = list(importlist, (yyvsp[(2) - (4)].node)); 4594 4595 if(debug['E']) { 4596 print("import [%Z] func %lN \n", importpkg->path, (yyvsp[(2) - (4)].node)); 4597 if(debug['m'] > 2 && (yyvsp[(2) - (4)].node)->inl) 4598 print("inl body:%+H\n", (yyvsp[(2) - (4)].node)->inl); 4599 } 4600 } 4601 break; 4602 4603 case 311: 4604 #line 1962 "go.y" 4605 { 4606 (yyval.sym) = (yyvsp[(1) - (1)].sym); 4607 structpkg = (yyval.sym)->pkg; 4608 } 4609 break; 4610 4611 case 312: 4612 #line 1969 "go.y" 4613 { 4614 (yyval.type) = pkgtype((yyvsp[(1) - (1)].sym)); 4615 importsym((yyvsp[(1) - (1)].sym), OTYPE); 4616 } 4617 break; 4618 4619 case 318: 4620 #line 1989 "go.y" 4621 { 4622 (yyval.type) = pkgtype((yyvsp[(1) - (1)].sym)); 4623 } 4624 break; 4625 4626 case 319: 4627 #line 1993 "go.y" 4628 { 4629 // predefined name like uint8 4630 (yyvsp[(1) - (1)].sym) = pkglookup((yyvsp[(1) - (1)].sym)->name, builtinpkg); 4631 if((yyvsp[(1) - (1)].sym)->def == N || (yyvsp[(1) - (1)].sym)->def->op != OTYPE) { 4632 yyerror("%s is not a type", (yyvsp[(1) - (1)].sym)->name); 4633 (yyval.type) = T; 4634 } else 4635 (yyval.type) = (yyvsp[(1) - (1)].sym)->def->type; 4636 } 4637 break; 4638 4639 case 320: 4640 #line 2003 "go.y" 4641 { 4642 (yyval.type) = aindex(N, (yyvsp[(3) - (3)].type)); 4643 } 4644 break; 4645 4646 case 321: 4647 #line 2007 "go.y" 4648 { 4649 (yyval.type) = aindex(nodlit((yyvsp[(2) - (4)].val)), (yyvsp[(4) - (4)].type)); 4650 } 4651 break; 4652 4653 case 322: 4654 #line 2011 "go.y" 4655 { 4656 (yyval.type) = maptype((yyvsp[(3) - (5)].type), (yyvsp[(5) - (5)].type)); 4657 } 4658 break; 4659 4660 case 323: 4661 #line 2015 "go.y" 4662 { 4663 (yyval.type) = tostruct((yyvsp[(3) - (4)].list)); 4664 } 4665 break; 4666 4667 case 324: 4668 #line 2019 "go.y" 4669 { 4670 (yyval.type) = tointerface((yyvsp[(3) - (4)].list)); 4671 } 4672 break; 4673 4674 case 325: 4675 #line 2023 "go.y" 4676 { 4677 (yyval.type) = ptrto((yyvsp[(2) - (2)].type)); 4678 } 4679 break; 4680 4681 case 326: 4682 #line 2027 "go.y" 4683 { 4684 (yyval.type) = typ(TCHAN); 4685 (yyval.type)->type = (yyvsp[(2) - (2)].type); 4686 (yyval.type)->chan = Cboth; 4687 } 4688 break; 4689 4690 case 327: 4691 #line 2033 "go.y" 4692 { 4693 (yyval.type) = typ(TCHAN); 4694 (yyval.type)->type = (yyvsp[(3) - (4)].type); 4695 (yyval.type)->chan = Cboth; 4696 } 4697 break; 4698 4699 case 328: 4700 #line 2039 "go.y" 4701 { 4702 (yyval.type) = typ(TCHAN); 4703 (yyval.type)->type = (yyvsp[(3) - (3)].type); 4704 (yyval.type)->chan = Csend; 4705 } 4706 break; 4707 4708 case 329: 4709 #line 2047 "go.y" 4710 { 4711 (yyval.type) = typ(TCHAN); 4712 (yyval.type)->type = (yyvsp[(3) - (3)].type); 4713 (yyval.type)->chan = Crecv; 4714 } 4715 break; 4716 4717 case 330: 4718 #line 2055 "go.y" 4719 { 4720 (yyval.type) = functype(nil, (yyvsp[(3) - (5)].list), (yyvsp[(5) - (5)].list)); 4721 } 4722 break; 4723 4724 case 331: 4725 #line 2061 "go.y" 4726 { 4727 (yyval.node) = nod(ODCLFIELD, N, typenod((yyvsp[(2) - (3)].type))); 4728 if((yyvsp[(1) - (3)].sym)) 4729 (yyval.node)->left = newname((yyvsp[(1) - (3)].sym)); 4730 (yyval.node)->val = (yyvsp[(3) - (3)].val); 4731 } 4732 break; 4733 4734 case 332: 4735 #line 2068 "go.y" 4736 { 4737 Type *t; 4738 4739 t = typ(TARRAY); 4740 t->bound = -1; 4741 t->type = (yyvsp[(3) - (4)].type); 4742 4743 (yyval.node) = nod(ODCLFIELD, N, typenod(t)); 4744 if((yyvsp[(1) - (4)].sym)) 4745 (yyval.node)->left = newname((yyvsp[(1) - (4)].sym)); 4746 (yyval.node)->isddd = 1; 4747 (yyval.node)->val = (yyvsp[(4) - (4)].val); 4748 } 4749 break; 4750 4751 case 333: 4752 #line 2084 "go.y" 4753 { 4754 Sym *s; 4755 Pkg *p; 4756 4757 if((yyvsp[(1) - (3)].sym) != S && strcmp((yyvsp[(1) - (3)].sym)->name, "?") != 0) { 4758 (yyval.node) = nod(ODCLFIELD, newname((yyvsp[(1) - (3)].sym)), typenod((yyvsp[(2) - (3)].type))); 4759 (yyval.node)->val = (yyvsp[(3) - (3)].val); 4760 } else { 4761 s = (yyvsp[(2) - (3)].type)->sym; 4762 if(s == S && isptr[(yyvsp[(2) - (3)].type)->etype]) 4763 s = (yyvsp[(2) - (3)].type)->type->sym; 4764 p = importpkg; 4765 if((yyvsp[(1) - (3)].sym) != S) 4766 p = (yyvsp[(1) - (3)].sym)->pkg; 4767 (yyval.node) = embedded(s, p); 4768 (yyval.node)->right = typenod((yyvsp[(2) - (3)].type)); 4769 (yyval.node)->val = (yyvsp[(3) - (3)].val); 4770 } 4771 } 4772 break; 4773 4774 case 334: 4775 #line 2106 "go.y" 4776 { 4777 (yyval.node) = nod(ODCLFIELD, newname((yyvsp[(1) - (5)].sym)), typenod(functype(fakethis(), (yyvsp[(3) - (5)].list), (yyvsp[(5) - (5)].list)))); 4778 } 4779 break; 4780 4781 case 335: 4782 #line 2110 "go.y" 4783 { 4784 (yyval.node) = nod(ODCLFIELD, N, typenod((yyvsp[(1) - (1)].type))); 4785 } 4786 break; 4787 4788 case 336: 4789 #line 2115 "go.y" 4790 { 4791 (yyval.list) = nil; 4792 } 4793 break; 4794 4795 case 338: 4796 #line 2122 "go.y" 4797 { 4798 (yyval.list) = (yyvsp[(2) - (3)].list); 4799 } 4800 break; 4801 4802 case 339: 4803 #line 2126 "go.y" 4804 { 4805 (yyval.list) = list1(nod(ODCLFIELD, N, typenod((yyvsp[(1) - (1)].type)))); 4806 } 4807 break; 4808 4809 case 340: 4810 #line 2136 "go.y" 4811 { 4812 (yyval.node) = nodlit((yyvsp[(1) - (1)].val)); 4813 } 4814 break; 4815 4816 case 341: 4817 #line 2140 "go.y" 4818 { 4819 (yyval.node) = nodlit((yyvsp[(2) - (2)].val)); 4820 switch((yyval.node)->val.ctype){ 4821 case CTINT: 4822 case CTRUNE: 4823 mpnegfix((yyval.node)->val.u.xval); 4824 break; 4825 case CTFLT: 4826 mpnegflt((yyval.node)->val.u.fval); 4827 break; 4828 case CTCPLX: 4829 mpnegflt(&(yyval.node)->val.u.cval->real); 4830 mpnegflt(&(yyval.node)->val.u.cval->imag); 4831 break; 4832 default: 4833 yyerror("bad negated constant"); 4834 } 4835 } 4836 break; 4837 4838 case 342: 4839 #line 2159 "go.y" 4840 { 4841 (yyval.node) = oldname(pkglookup((yyvsp[(1) - (1)].sym)->name, builtinpkg)); 4842 if((yyval.node)->op != OLITERAL) 4843 yyerror("bad constant %S", (yyval.node)->sym); 4844 } 4845 break; 4846 4847 case 344: 4848 #line 2168 "go.y" 4849 { 4850 if((yyvsp[(2) - (5)].node)->val.ctype == CTRUNE && (yyvsp[(4) - (5)].node)->val.ctype == CTINT) { 4851 (yyval.node) = (yyvsp[(2) - (5)].node); 4852 mpaddfixfix((yyvsp[(2) - (5)].node)->val.u.xval, (yyvsp[(4) - (5)].node)->val.u.xval, 0); 4853 break; 4854 } 4855 (yyvsp[(4) - (5)].node)->val.u.cval->real = (yyvsp[(4) - (5)].node)->val.u.cval->imag; 4856 mpmovecflt(&(yyvsp[(4) - (5)].node)->val.u.cval->imag, 0.0); 4857 (yyval.node) = nodcplxlit((yyvsp[(2) - (5)].node)->val, (yyvsp[(4) - (5)].node)->val); 4858 } 4859 break; 4860 4861 case 347: 4862 #line 2184 "go.y" 4863 { 4864 (yyval.list) = list1((yyvsp[(1) - (1)].node)); 4865 } 4866 break; 4867 4868 case 348: 4869 #line 2188 "go.y" 4870 { 4871 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); 4872 } 4873 break; 4874 4875 case 349: 4876 #line 2194 "go.y" 4877 { 4878 (yyval.list) = list1((yyvsp[(1) - (1)].node)); 4879 } 4880 break; 4881 4882 case 350: 4883 #line 2198 "go.y" 4884 { 4885 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); 4886 } 4887 break; 4888 4889 case 351: 4890 #line 2204 "go.y" 4891 { 4892 (yyval.list) = list1((yyvsp[(1) - (1)].node)); 4893 } 4894 break; 4895 4896 case 352: 4897 #line 2208 "go.y" 4898 { 4899 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); 4900 } 4901 break; 4902 4903 4904 /* Line 1267 of yacc.c. */ 4905 #line 4907 "y.tab.c" 4906 default: break; 4907 } 4908 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 4909 4910 YYPOPSTACK (yylen); 4911 yylen = 0; 4912 YY_STACK_PRINT (yyss, yyssp); 4913 4914 *++yyvsp = yyval; 4915 4916 4917 /* Now `shift' the result of the reduction. Determine what state 4918 that goes to, based on the state we popped back to and the rule 4919 number reduced by. */ 4920 4921 yyn = yyr1[yyn]; 4922 4923 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 4924 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 4925 yystate = yytable[yystate]; 4926 else 4927 yystate = yydefgoto[yyn - YYNTOKENS]; 4928 4929 goto yynewstate; 4930 4931 4932 /*------------------------------------. 4933 | yyerrlab -- here on detecting error | 4934 `------------------------------------*/ 4935 yyerrlab: 4936 /* If not already recovering from an error, report this error. */ 4937 if (!yyerrstatus) 4938 { 4939 ++yynerrs; 4940 #if ! YYERROR_VERBOSE 4941 yyerror (YY_("syntax error")); 4942 #else 4943 { 4944 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); 4945 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) 4946 { 4947 YYSIZE_T yyalloc = 2 * yysize; 4948 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) 4949 yyalloc = YYSTACK_ALLOC_MAXIMUM; 4950 if (yymsg != yymsgbuf) 4951 YYSTACK_FREE (yymsg); 4952 yymsg = (char *) YYSTACK_ALLOC (yyalloc); 4953 if (yymsg) 4954 yymsg_alloc = yyalloc; 4955 else 4956 { 4957 yymsg = yymsgbuf; 4958 yymsg_alloc = sizeof yymsgbuf; 4959 } 4960 } 4961 4962 if (0 < yysize && yysize <= yymsg_alloc) 4963 { 4964 (void) yysyntax_error (yymsg, yystate, yychar); 4965 yyerror (yymsg); 4966 } 4967 else 4968 { 4969 yyerror (YY_("syntax error")); 4970 if (yysize != 0) 4971 goto yyexhaustedlab; 4972 } 4973 } 4974 #endif 4975 } 4976 4977 4978 4979 if (yyerrstatus == 3) 4980 { 4981 /* If just tried and failed to reuse look-ahead token after an 4982 error, discard it. */ 4983 4984 if (yychar <= YYEOF) 4985 { 4986 /* Return failure if at end of input. */ 4987 if (yychar == YYEOF) 4988 YYABORT; 4989 } 4990 else 4991 { 4992 yydestruct ("Error: discarding", 4993 yytoken, &yylval); 4994 yychar = YYEMPTY; 4995 } 4996 } 4997 4998 /* Else will try to reuse look-ahead token after shifting the error 4999 token. */ 5000 goto yyerrlab1; 5001 5002 5003 /*---------------------------------------------------. 5004 | yyerrorlab -- error raised explicitly by YYERROR. | 5005 `---------------------------------------------------*/ 5006 yyerrorlab: 5007 5008 /* Pacify compilers like GCC when the user code never invokes 5009 YYERROR and the label yyerrorlab therefore never appears in user 5010 code. */ 5011 if (/*CONSTCOND*/ 0) 5012 goto yyerrorlab; 5013 5014 /* Do not reclaim the symbols of the rule which action triggered 5015 this YYERROR. */ 5016 YYPOPSTACK (yylen); 5017 yylen = 0; 5018 YY_STACK_PRINT (yyss, yyssp); 5019 yystate = *yyssp; 5020 goto yyerrlab1; 5021 5022 5023 /*-------------------------------------------------------------. 5024 | yyerrlab1 -- common code for both syntax error and YYERROR. | 5025 `-------------------------------------------------------------*/ 5026 yyerrlab1: 5027 yyerrstatus = 3; /* Each real token shifted decrements this. */ 5028 5029 for (;;) 5030 { 5031 yyn = yypact[yystate]; 5032 if (yyn != YYPACT_NINF) 5033 { 5034 yyn += YYTERROR; 5035 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 5036 { 5037 yyn = yytable[yyn]; 5038 if (0 < yyn) 5039 break; 5040 } 5041 } 5042 5043 /* Pop the current state because it cannot handle the error token. */ 5044 if (yyssp == yyss) 5045 YYABORT; 5046 5047 5048 yydestruct ("Error: popping", 5049 yystos[yystate], yyvsp); 5050 YYPOPSTACK (1); 5051 yystate = *yyssp; 5052 YY_STACK_PRINT (yyss, yyssp); 5053 } 5054 5055 if (yyn == YYFINAL) 5056 YYACCEPT; 5057 5058 *++yyvsp = yylval; 5059 5060 5061 /* Shift the error token. */ 5062 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 5063 5064 yystate = yyn; 5065 goto yynewstate; 5066 5067 5068 /*-------------------------------------. 5069 | yyacceptlab -- YYACCEPT comes here. | 5070 `-------------------------------------*/ 5071 yyacceptlab: 5072 yyresult = 0; 5073 goto yyreturn; 5074 5075 /*-----------------------------------. 5076 | yyabortlab -- YYABORT comes here. | 5077 `-----------------------------------*/ 5078 yyabortlab: 5079 yyresult = 1; 5080 goto yyreturn; 5081 5082 #ifndef yyoverflow 5083 /*-------------------------------------------------. 5084 | yyexhaustedlab -- memory exhaustion comes here. | 5085 `-------------------------------------------------*/ 5086 yyexhaustedlab: 5087 yyerror (YY_("memory exhausted")); 5088 yyresult = 2; 5089 /* Fall through. */ 5090 #endif 5091 5092 yyreturn: 5093 if (yychar != YYEOF && yychar != YYEMPTY) 5094 yydestruct ("Cleanup: discarding lookahead", 5095 yytoken, &yylval); 5096 /* Do not reclaim the symbols of the rule which action triggered 5097 this YYABORT or YYACCEPT. */ 5098 YYPOPSTACK (yylen); 5099 YY_STACK_PRINT (yyss, yyssp); 5100 while (yyssp != yyss) 5101 { 5102 yydestruct ("Cleanup: popping", 5103 yystos[*yyssp], yyvsp); 5104 YYPOPSTACK (1); 5105 } 5106 #ifndef yyoverflow 5107 if (yyss != yyssa) 5108 YYSTACK_FREE (yyss); 5109 #endif 5110 #if YYERROR_VERBOSE 5111 if (yymsg != yymsgbuf) 5112 YYSTACK_FREE (yymsg); 5113 #endif 5114 /* Make sure YYID is used. */ 5115 return YYID (yyresult); 5116 } 5117 5118 5119 #line 2212 "go.y" 5120 5121 5122 static void 5123 fixlbrace(int lbr) 5124 { 5125 // If the opening brace was an LBODY, 5126 // set up for another one now that we're done. 5127 // See comment in lex.c about loophack. 5128 if(lbr == LBODY) 5129 loophack = 1; 5130 } 5131 5132