github.com/golang-haiku/go-1.4.3@v0.0.0-20190609233734-1f5ae41cc308/src/cmd/cc/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 LORE = 258, 70 LXORE = 259, 71 LANDE = 260, 72 LLSHE = 261, 73 LRSHE = 262, 74 LMDE = 263, 75 LDVE = 264, 76 LMLE = 265, 77 LME = 266, 78 LPE = 267, 79 LOROR = 268, 80 LANDAND = 269, 81 LNE = 270, 82 LEQ = 271, 83 LGE = 272, 84 LLE = 273, 85 LRSH = 274, 86 LLSH = 275, 87 LMG = 276, 88 LPP = 277, 89 LMM = 278, 90 LNAME = 279, 91 LTYPE = 280, 92 LFCONST = 281, 93 LDCONST = 282, 94 LCONST = 283, 95 LLCONST = 284, 96 LUCONST = 285, 97 LULCONST = 286, 98 LVLCONST = 287, 99 LUVLCONST = 288, 100 LSTRING = 289, 101 LLSTRING = 290, 102 LAUTO = 291, 103 LBREAK = 292, 104 LCASE = 293, 105 LCHAR = 294, 106 LCONTINUE = 295, 107 LDEFAULT = 296, 108 LDO = 297, 109 LDOUBLE = 298, 110 LELSE = 299, 111 LEXTERN = 300, 112 LFLOAT = 301, 113 LFOR = 302, 114 LGOTO = 303, 115 LIF = 304, 116 LINT = 305, 117 LLONG = 306, 118 LPREFETCH = 307, 119 LREGISTER = 308, 120 LRETURN = 309, 121 LSHORT = 310, 122 LSIZEOF = 311, 123 LUSED = 312, 124 LSTATIC = 313, 125 LSTRUCT = 314, 126 LSWITCH = 315, 127 LTYPEDEF = 316, 128 LTYPESTR = 317, 129 LUNION = 318, 130 LUNSIGNED = 319, 131 LWHILE = 320, 132 LVOID = 321, 133 LENUM = 322, 134 LSIGNED = 323, 135 LCONSTNT = 324, 136 LVOLATILE = 325, 137 LSET = 326, 138 LSIGNOF = 327, 139 LRESTRICT = 328, 140 LINLINE = 329 141 }; 142 #endif 143 /* Tokens. */ 144 #define LORE 258 145 #define LXORE 259 146 #define LANDE 260 147 #define LLSHE 261 148 #define LRSHE 262 149 #define LMDE 263 150 #define LDVE 264 151 #define LMLE 265 152 #define LME 266 153 #define LPE 267 154 #define LOROR 268 155 #define LANDAND 269 156 #define LNE 270 157 #define LEQ 271 158 #define LGE 272 159 #define LLE 273 160 #define LRSH 274 161 #define LLSH 275 162 #define LMG 276 163 #define LPP 277 164 #define LMM 278 165 #define LNAME 279 166 #define LTYPE 280 167 #define LFCONST 281 168 #define LDCONST 282 169 #define LCONST 283 170 #define LLCONST 284 171 #define LUCONST 285 172 #define LULCONST 286 173 #define LVLCONST 287 174 #define LUVLCONST 288 175 #define LSTRING 289 176 #define LLSTRING 290 177 #define LAUTO 291 178 #define LBREAK 292 179 #define LCASE 293 180 #define LCHAR 294 181 #define LCONTINUE 295 182 #define LDEFAULT 296 183 #define LDO 297 184 #define LDOUBLE 298 185 #define LELSE 299 186 #define LEXTERN 300 187 #define LFLOAT 301 188 #define LFOR 302 189 #define LGOTO 303 190 #define LIF 304 191 #define LINT 305 192 #define LLONG 306 193 #define LPREFETCH 307 194 #define LREGISTER 308 195 #define LRETURN 309 196 #define LSHORT 310 197 #define LSIZEOF 311 198 #define LUSED 312 199 #define LSTATIC 313 200 #define LSTRUCT 314 201 #define LSWITCH 315 202 #define LTYPEDEF 316 203 #define LTYPESTR 317 204 #define LUNION 318 205 #define LUNSIGNED 319 206 #define LWHILE 320 207 #define LVOID 321 208 #define LENUM 322 209 #define LSIGNED 323 210 #define LCONSTNT 324 211 #define LVOLATILE 325 212 #define LSET 326 213 #define LSIGNOF 327 214 #define LRESTRICT 328 215 #define LINLINE 329 216 217 218 219 220 /* Copy the first part of user declarations. */ 221 #line 31 "cc.y" 222 223 #include <u.h> 224 #include <stdio.h> /* if we don't, bison will, and cc.h re-#defines getc */ 225 #include "cc.h" 226 227 228 /* Enabling traces. */ 229 #ifndef YYDEBUG 230 # define YYDEBUG 0 231 #endif 232 233 /* Enabling verbose error messages. */ 234 #ifdef YYERROR_VERBOSE 235 # undef YYERROR_VERBOSE 236 # define YYERROR_VERBOSE 1 237 #else 238 # define YYERROR_VERBOSE 0 239 #endif 240 241 /* Enabling the token table. */ 242 #ifndef YYTOKEN_TABLE 243 # define YYTOKEN_TABLE 0 244 #endif 245 246 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 247 typedef union YYSTYPE 248 #line 36 "cc.y" 249 { 250 Node* node; 251 Sym* sym; 252 Type* type; 253 struct 254 { 255 Type* t; 256 uchar c; 257 } tycl; 258 struct 259 { 260 Type* t1; 261 Type* t2; 262 Type* t3; 263 uchar c; 264 } tyty; 265 struct 266 { 267 char* s; 268 int32 l; 269 } sval; 270 int32 lval; 271 double dval; 272 vlong vval; 273 } 274 /* Line 193 of yacc.c. */ 275 #line 276 "y.tab.c" 276 YYSTYPE; 277 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ 278 # define YYSTYPE_IS_DECLARED 1 279 # define YYSTYPE_IS_TRIVIAL 1 280 #endif 281 282 283 284 /* Copy the second part of user declarations. */ 285 286 287 /* Line 216 of yacc.c. */ 288 #line 289 "y.tab.c" 289 290 #ifdef short 291 # undef short 292 #endif 293 294 #ifdef YYTYPE_UINT8 295 typedef YYTYPE_UINT8 yytype_uint8; 296 #else 297 typedef unsigned char yytype_uint8; 298 #endif 299 300 #ifdef YYTYPE_INT8 301 typedef YYTYPE_INT8 yytype_int8; 302 #elif (defined __STDC__ || defined __C99__FUNC__ \ 303 || defined __cplusplus || defined _MSC_VER) 304 typedef signed char yytype_int8; 305 #else 306 typedef short int yytype_int8; 307 #endif 308 309 #ifdef YYTYPE_UINT16 310 typedef YYTYPE_UINT16 yytype_uint16; 311 #else 312 typedef unsigned short int yytype_uint16; 313 #endif 314 315 #ifdef YYTYPE_INT16 316 typedef YYTYPE_INT16 yytype_int16; 317 #else 318 typedef short int yytype_int16; 319 #endif 320 321 #ifndef YYSIZE_T 322 # ifdef __SIZE_TYPE__ 323 # define YYSIZE_T __SIZE_TYPE__ 324 # elif defined size_t 325 # define YYSIZE_T size_t 326 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ 327 || defined __cplusplus || defined _MSC_VER) 328 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 329 # define YYSIZE_T size_t 330 # else 331 # define YYSIZE_T unsigned int 332 # endif 333 #endif 334 335 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 336 337 #ifndef YY_ 338 # if defined YYENABLE_NLS && YYENABLE_NLS 339 # if ENABLE_NLS 340 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 341 # define YY_(msgid) dgettext ("bison-runtime", msgid) 342 # endif 343 # endif 344 # ifndef YY_ 345 # define YY_(msgid) msgid 346 # endif 347 #endif 348 349 /* Suppress unused-variable warnings by "using" E. */ 350 #if ! defined lint || defined __GNUC__ 351 # define YYUSE(e) ((void) (e)) 352 #else 353 # define YYUSE(e) /* empty */ 354 #endif 355 356 /* Identity function, used to suppress warnings about constant conditions. */ 357 #ifndef lint 358 # define YYID(n) (n) 359 #else 360 #if (defined __STDC__ || defined __C99__FUNC__ \ 361 || defined __cplusplus || defined _MSC_VER) 362 static int 363 YYID (int i) 364 #else 365 static int 366 YYID (i) 367 int i; 368 #endif 369 { 370 return i; 371 } 372 #endif 373 374 #if ! defined yyoverflow || YYERROR_VERBOSE 375 376 /* The parser invokes alloca or malloc; define the necessary symbols. */ 377 378 # ifdef YYSTACK_USE_ALLOCA 379 # if YYSTACK_USE_ALLOCA 380 # ifdef __GNUC__ 381 # define YYSTACK_ALLOC __builtin_alloca 382 # elif defined __BUILTIN_VA_ARG_INCR 383 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 384 # elif defined _AIX 385 # define YYSTACK_ALLOC __alloca 386 # elif defined _MSC_VER 387 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 388 # define alloca _alloca 389 # else 390 # define YYSTACK_ALLOC alloca 391 # if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 392 || defined __cplusplus || defined _MSC_VER) 393 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 394 # ifndef _STDLIB_H 395 # define _STDLIB_H 1 396 # endif 397 # endif 398 # endif 399 # endif 400 # endif 401 402 # ifdef YYSTACK_ALLOC 403 /* Pacify GCC's `empty if-body' warning. */ 404 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) 405 # ifndef YYSTACK_ALLOC_MAXIMUM 406 /* The OS might guarantee only one guard page at the bottom of the stack, 407 and a page size can be as small as 4096 bytes. So we cannot safely 408 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 409 to allow for a few compiler-allocated temporary stack slots. */ 410 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 411 # endif 412 # else 413 # define YYSTACK_ALLOC YYMALLOC 414 # define YYSTACK_FREE YYFREE 415 # ifndef YYSTACK_ALLOC_MAXIMUM 416 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 417 # endif 418 # if (defined __cplusplus && ! defined _STDLIB_H \ 419 && ! ((defined YYMALLOC || defined malloc) \ 420 && (defined YYFREE || defined free))) 421 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 422 # ifndef _STDLIB_H 423 # define _STDLIB_H 1 424 # endif 425 # endif 426 # ifndef YYMALLOC 427 # define YYMALLOC malloc 428 # if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 429 || defined __cplusplus || defined _MSC_VER) 430 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 431 # endif 432 # endif 433 # ifndef YYFREE 434 # define YYFREE free 435 # if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 436 || defined __cplusplus || defined _MSC_VER) 437 void free (void *); /* INFRINGES ON USER NAME SPACE */ 438 # endif 439 # endif 440 # endif 441 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */ 442 443 444 #if (! defined yyoverflow \ 445 && (! defined __cplusplus \ 446 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 447 448 /* A type that is properly aligned for any stack member. */ 449 union yyalloc 450 { 451 yytype_int16 yyss; 452 YYSTYPE yyvs; 453 }; 454 455 /* The size of the maximum gap between one aligned stack and the next. */ 456 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 457 458 /* The size of an array large to enough to hold all stacks, each with 459 N elements. */ 460 # define YYSTACK_BYTES(N) \ 461 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ 462 + YYSTACK_GAP_MAXIMUM) 463 464 /* Copy COUNT objects from FROM to TO. The source and destination do 465 not overlap. */ 466 # ifndef YYCOPY 467 # if defined __GNUC__ && 1 < __GNUC__ 468 # define YYCOPY(To, From, Count) \ 469 __builtin_memcpy (To, From, (Count) * sizeof (*(From))) 470 # else 471 # define YYCOPY(To, From, Count) \ 472 do \ 473 { \ 474 YYSIZE_T yyi; \ 475 for (yyi = 0; yyi < (Count); yyi++) \ 476 (To)[yyi] = (From)[yyi]; \ 477 } \ 478 while (YYID (0)) 479 # endif 480 # endif 481 482 /* Relocate STACK from its old location to the new one. The 483 local variables YYSIZE and YYSTACKSIZE give the old and new number of 484 elements in the stack, and YYPTR gives the new location of the 485 stack. Advance YYPTR to a properly aligned location for the next 486 stack. */ 487 # define YYSTACK_RELOCATE(Stack) \ 488 do \ 489 { \ 490 YYSIZE_T yynewbytes; \ 491 YYCOPY (&yyptr->Stack, Stack, yysize); \ 492 Stack = &yyptr->Stack; \ 493 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 494 yyptr += yynewbytes / sizeof (*yyptr); \ 495 } \ 496 while (YYID (0)) 497 498 #endif 499 500 /* YYFINAL -- State number of the termination state. */ 501 #define YYFINAL 2 502 /* YYLAST -- Last index in YYTABLE. */ 503 #define YYLAST 1188 504 505 /* YYNTOKENS -- Number of terminals. */ 506 #define YYNTOKENS 99 507 /* YYNNTS -- Number of nonterminals. */ 508 #define YYNNTS 75 509 /* YYNRULES -- Number of rules. */ 510 #define YYNRULES 247 511 /* YYNRULES -- Number of states. */ 512 #define YYNSTATES 417 513 514 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 515 #define YYUNDEFTOK 2 516 #define YYMAXUTOK 329 517 518 #define YYTRANSLATE(YYX) \ 519 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 520 521 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ 522 static const yytype_uint8 yytranslate[] = 523 { 524 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 525 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 526 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 527 2, 2, 2, 97, 2, 2, 2, 35, 22, 2, 528 38, 93, 33, 31, 4, 32, 36, 34, 2, 2, 529 2, 2, 2, 2, 2, 2, 2, 2, 17, 3, 530 25, 5, 26, 16, 2, 2, 2, 2, 2, 2, 531 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 532 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 533 2, 37, 2, 94, 21, 2, 2, 2, 2, 2, 534 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 535 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 536 2, 2, 2, 95, 20, 96, 98, 2, 2, 2, 537 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 538 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 539 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 540 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 541 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 542 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 543 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 544 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 545 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 546 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 547 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 548 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 549 2, 2, 2, 2, 2, 2, 1, 2, 6, 7, 550 8, 9, 10, 11, 12, 13, 14, 15, 18, 19, 551 23, 24, 27, 28, 29, 30, 39, 40, 41, 42, 552 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 553 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 554 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 555 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 556 83, 84, 85, 86, 87, 88, 89, 90, 91, 92 557 }; 558 559 #if YYDEBUG 560 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 561 YYRHS. */ 562 static const yytype_uint16 yyprhs[] = 563 { 564 0, 0, 3, 4, 7, 10, 14, 15, 16, 23, 565 25, 26, 31, 35, 37, 41, 43, 47, 52, 57, 566 60, 64, 66, 67, 72, 76, 77, 82, 84, 88, 567 89, 94, 95, 101, 102, 104, 106, 110, 112, 116, 568 119, 120, 122, 125, 129, 131, 133, 138, 143, 146, 569 150, 154, 156, 160, 164, 167, 170, 173, 177, 179, 570 182, 184, 186, 189, 190, 192, 194, 197, 200, 204, 571 208, 212, 213, 216, 219, 221, 224, 228, 231, 234, 572 237, 239, 242, 244, 247, 250, 251, 254, 260, 268, 573 269, 280, 286, 294, 298, 304, 307, 310, 314, 320, 574 326, 332, 333, 335, 336, 338, 340, 342, 346, 348, 575 352, 356, 360, 364, 368, 372, 376, 380, 384, 388, 576 392, 396, 400, 404, 408, 412, 416, 420, 426, 430, 577 434, 438, 442, 446, 450, 454, 458, 462, 466, 470, 578 472, 478, 486, 488, 491, 494, 497, 500, 503, 506, 579 509, 512, 515, 518, 522, 528, 534, 539, 544, 548, 580 552, 555, 558, 560, 562, 564, 566, 568, 570, 572, 581 574, 576, 578, 580, 582, 585, 587, 590, 591, 593, 582 595, 599, 600, 605, 606, 608, 610, 612, 614, 617, 583 620, 624, 627, 631, 633, 635, 638, 639, 644, 647, 584 650, 651, 656, 659, 662, 663, 664, 672, 673, 679, 585 681, 683, 686, 687, 690, 692, 694, 696, 698, 701, 586 703, 705, 707, 711, 714, 718, 720, 722, 724, 726, 587 728, 730, 732, 734, 736, 738, 740, 742, 744, 746, 588 748, 750, 752, 754, 756, 758, 760, 762 589 }; 590 591 /* YYRHS -- A `-1'-separated list of the rules' RHS. */ 592 static const yytype_int16 yyrhs[] = 593 { 594 100, 0, -1, -1, 100, 101, -1, 152, 3, -1, 595 152, 104, 3, -1, -1, -1, 152, 106, 102, 111, 596 103, 129, -1, 106, -1, -1, 106, 105, 5, 123, 597 -1, 104, 4, 104, -1, 107, -1, 33, 163, 106, 598 -1, 172, -1, 38, 106, 93, -1, 107, 38, 127, 599 93, -1, 107, 37, 139, 94, -1, 155, 3, -1, 600 155, 109, 3, -1, 106, -1, -1, 106, 110, 5, 601 123, -1, 109, 4, 109, -1, -1, 111, 155, 112, 602 3, -1, 106, -1, 112, 4, 112, -1, -1, 154, 603 114, 116, 3, -1, -1, 113, 154, 115, 116, 3, 604 -1, -1, 117, -1, 118, -1, 117, 4, 117, -1, 605 106, -1, 172, 17, 140, -1, 17, 140, -1, -1, 606 120, -1, 33, 163, -1, 33, 163, 120, -1, 121, 607 -1, 122, -1, 121, 38, 127, 93, -1, 121, 37, 608 139, 94, -1, 38, 93, -1, 37, 139, 94, -1, 609 38, 120, 93, -1, 142, -1, 95, 126, 96, -1, 610 37, 140, 94, -1, 36, 173, -1, 124, 5, -1, 611 123, 4, -1, 125, 123, 4, -1, 124, -1, 125, 612 124, -1, 125, -1, 123, -1, 125, 123, -1, -1, 613 128, -1, 171, -1, 154, 119, -1, 154, 106, -1, 614 36, 36, 36, -1, 128, 4, 128, -1, 95, 130, 615 96, -1, -1, 130, 108, -1, 130, 133, -1, 132, 616 -1, 131, 132, -1, 56, 142, 17, -1, 59, 17, 617 -1, 42, 17, -1, 1, 3, -1, 135, -1, 131, 618 135, -1, 138, -1, 155, 109, -1, 138, 3, -1, 619 -1, 136, 129, -1, 67, 38, 141, 93, 133, -1, 620 67, 38, 141, 93, 133, 62, 133, -1, -1, 137, 621 65, 38, 134, 3, 138, 3, 138, 93, 133, -1, 622 83, 38, 141, 93, 133, -1, 60, 133, 83, 38, 623 141, 93, 3, -1, 72, 138, 3, -1, 78, 38, 624 141, 93, 133, -1, 55, 3, -1, 58, 3, -1, 625 66, 173, 3, -1, 75, 38, 148, 93, 3, -1, 626 70, 38, 148, 93, 3, -1, 89, 38, 148, 93, 627 3, -1, -1, 141, -1, -1, 140, -1, 142, -1, 628 142, -1, 141, 4, 141, -1, 143, -1, 142, 33, 629 142, -1, 142, 34, 142, -1, 142, 35, 142, -1, 630 142, 31, 142, -1, 142, 32, 142, -1, 142, 29, 631 142, -1, 142, 30, 142, -1, 142, 25, 142, -1, 632 142, 26, 142, -1, 142, 28, 142, -1, 142, 27, 633 142, -1, 142, 24, 142, -1, 142, 23, 142, -1, 634 142, 22, 142, -1, 142, 21, 142, -1, 142, 20, 635 142, -1, 142, 19, 142, -1, 142, 18, 142, -1, 636 142, 16, 141, 17, 142, -1, 142, 5, 142, -1, 637 142, 15, 142, -1, 142, 14, 142, -1, 142, 13, 638 142, -1, 142, 12, 142, -1, 142, 11, 142, -1, 639 142, 9, 142, -1, 142, 10, 142, -1, 142, 8, 640 142, -1, 142, 7, 142, -1, 142, 6, 142, -1, 641 144, -1, 38, 154, 119, 93, 143, -1, 38, 154, 642 119, 93, 95, 126, 96, -1, 145, -1, 33, 143, 643 -1, 22, 143, -1, 31, 143, -1, 32, 143, -1, 644 97, 143, -1, 98, 143, -1, 40, 143, -1, 41, 645 143, -1, 74, 144, -1, 90, 144, -1, 38, 141, 646 93, -1, 74, 38, 154, 119, 93, -1, 90, 38, 647 154, 119, 93, -1, 145, 38, 148, 93, -1, 145, 648 37, 141, 94, -1, 145, 39, 173, -1, 145, 36, 649 173, -1, 145, 40, -1, 145, 41, -1, 171, -1, 650 46, -1, 47, -1, 48, -1, 49, -1, 45, -1, 651 44, -1, 50, -1, 51, -1, 146, -1, 147, -1, 652 52, -1, 146, 52, -1, 53, -1, 147, 53, -1, 653 -1, 149, -1, 142, -1, 149, 4, 149, -1, -1, 654 95, 151, 113, 96, -1, -1, 155, -1, 156, -1, 655 168, -1, 165, -1, 156, 162, -1, 168, 162, -1, 656 165, 156, 163, -1, 165, 168, -1, 165, 168, 162, 657 -1, 153, -1, 153, -1, 77, 173, -1, -1, 77, 658 173, 157, 150, -1, 77, 150, -1, 81, 173, -1, 659 -1, 81, 173, 158, 150, -1, 81, 150, -1, 85, 660 173, -1, -1, -1, 85, 173, 159, 95, 160, 167, 661 96, -1, -1, 85, 95, 161, 167, 96, -1, 43, 662 -1, 164, -1, 162, 164, -1, -1, 163, 170, -1, 663 168, -1, 170, -1, 169, -1, 166, -1, 165, 166, 664 -1, 170, -1, 169, -1, 42, -1, 42, 5, 142, 665 -1, 167, 4, -1, 167, 4, 167, -1, 57, -1, 666 73, -1, 68, -1, 69, -1, 86, -1, 82, -1, 667 64, -1, 61, -1, 84, -1, 54, -1, 76, -1, 668 63, -1, 79, -1, 80, -1, 71, -1, 92, -1, 669 87, -1, 88, -1, 91, -1, 42, -1, 173, -1, 670 42, -1, 43, -1 671 }; 672 673 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ 674 static const yytype_uint16 yyrline[] = 675 { 676 0, 101, 101, 102, 108, 112, 114, 128, 113, 143, 677 148, 147, 155, 158, 159, 166, 167, 171, 175, 184, 678 188, 194, 200, 199, 211, 224, 225, 228, 232, 239, 679 238, 244, 243, 250, 254, 257, 261, 264, 269, 273, 680 282, 285, 288, 293, 298, 301, 302, 306, 312, 316, 681 320, 326, 327, 333, 337, 342, 345, 346, 350, 351, 682 357, 358, 359, 365, 368, 375, 376, 381, 386, 390, 683 396, 406, 409, 413, 419, 420, 426, 430, 434, 440, 684 444, 445, 451, 452, 458, 459, 459, 470, 476, 484, 685 484, 495, 499, 503, 508, 522, 526, 530, 534, 538, 686 542, 548, 551, 554, 557, 560, 567, 568, 574, 575, 687 579, 583, 587, 591, 595, 599, 603, 607, 611, 615, 688 619, 623, 627, 631, 635, 639, 643, 647, 651, 655, 689 659, 663, 667, 671, 675, 679, 683, 687, 691, 697, 690 698, 705, 713, 714, 718, 722, 726, 730, 734, 738, 691 742, 746, 750, 756, 760, 766, 772, 780, 784, 789, 692 794, 798, 802, 803, 810, 817, 824, 831, 838, 845, 693 852, 859, 860, 863, 873, 891, 901, 919, 922, 925, 694 926, 933, 932, 955, 959, 962, 967, 972, 978, 986, 695 992, 998, 1004, 1012, 1020, 1027, 1033, 1032, 1044, 1053, 696 1059, 1058, 1070, 1078, 1087, 1091, 1086, 1108, 1107, 1116, 697 1122, 1123, 1129, 1132, 1138, 1139, 1140, 1143, 1144, 1150, 698 1151, 1154, 1158, 1162, 1163, 1166, 1167, 1168, 1169, 1170, 699 1171, 1172, 1173, 1174, 1177, 1178, 1179, 1180, 1181, 1182, 700 1183, 1186, 1187, 1188, 1191, 1206, 1218, 1219 701 }; 702 #endif 703 704 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE 705 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 706 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 707 static const char *const yytname[] = 708 { 709 "$end", "error", "$undefined", "';'", "','", "'='", "LORE", "LXORE", 710 "LANDE", "LLSHE", "LRSHE", "LMDE", "LDVE", "LMLE", "LME", "LPE", "'?'", 711 "':'", "LOROR", "LANDAND", "'|'", "'^'", "'&'", "LNE", "LEQ", "'<'", 712 "'>'", "LGE", "LLE", "LRSH", "LLSH", "'+'", "'-'", "'*'", "'/'", "'%'", 713 "'.'", "'['", "'('", "LMG", "LPP", "LMM", "LNAME", "LTYPE", "LFCONST", 714 "LDCONST", "LCONST", "LLCONST", "LUCONST", "LULCONST", "LVLCONST", 715 "LUVLCONST", "LSTRING", "LLSTRING", "LAUTO", "LBREAK", "LCASE", "LCHAR", 716 "LCONTINUE", "LDEFAULT", "LDO", "LDOUBLE", "LELSE", "LEXTERN", "LFLOAT", 717 "LFOR", "LGOTO", "LIF", "LINT", "LLONG", "LPREFETCH", "LREGISTER", 718 "LRETURN", "LSHORT", "LSIZEOF", "LUSED", "LSTATIC", "LSTRUCT", "LSWITCH", 719 "LTYPEDEF", "LTYPESTR", "LUNION", "LUNSIGNED", "LWHILE", "LVOID", 720 "LENUM", "LSIGNED", "LCONSTNT", "LVOLATILE", "LSET", "LSIGNOF", 721 "LRESTRICT", "LINLINE", "')'", "']'", "'{'", "'}'", "'!'", "'~'", 722 "$accept", "prog", "xdecl", "@1", "@2", "xdlist", "@3", "xdecor", 723 "xdecor2", "adecl", "adlist", "@4", "pdecl", "pdlist", "edecl", "@5", 724 "@6", "zedlist", "edlist", "edecor", "abdecor", "abdecor1", "abdecor2", 725 "abdecor3", "init", "qual", "qlist", "ilist", "zarglist", "arglist", 726 "block", "slist", "labels", "label", "stmnt", "forexpr", "ulstmnt", "@7", 727 "@8", "zcexpr", "zexpr", "lexpr", "cexpr", "expr", "xuexpr", "uexpr", 728 "pexpr", "string", "lstring", "zelist", "elist", "sbody", "@9", 729 "zctlist", "types", "tlist", "ctlist", "complex", "@10", "@11", "@12", 730 "@13", "@14", "gctnlist", "zgnlist", "gctname", "gcnlist", "gcname", 731 "enum", "tname", "cname", "gname", "name", "tag", "ltag", 0 732 }; 733 #endif 734 735 # ifdef YYPRINT 736 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to 737 token YYLEX-NUM. */ 738 static const yytype_uint16 yytoknum[] = 739 { 740 0, 256, 257, 59, 44, 61, 258, 259, 260, 261, 741 262, 263, 264, 265, 266, 267, 63, 58, 268, 269, 742 124, 94, 38, 270, 271, 60, 62, 272, 273, 274, 743 275, 43, 45, 42, 47, 37, 46, 91, 40, 276, 744 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 745 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 746 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 747 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 748 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 749 327, 328, 329, 41, 93, 123, 125, 33, 126 750 }; 751 # endif 752 753 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 754 static const yytype_uint8 yyr1[] = 755 { 756 0, 99, 100, 100, 101, 101, 102, 103, 101, 104, 757 105, 104, 104, 106, 106, 107, 107, 107, 107, 108, 758 108, 109, 110, 109, 109, 111, 111, 112, 112, 114, 759 113, 115, 113, 116, 116, 117, 117, 118, 118, 118, 760 119, 119, 120, 120, 120, 121, 121, 121, 122, 122, 761 122, 123, 123, 124, 124, 124, 125, 125, 125, 125, 762 126, 126, 126, 127, 127, 128, 128, 128, 128, 128, 763 129, 130, 130, 130, 131, 131, 132, 132, 132, 133, 764 133, 133, 134, 134, 135, 136, 135, 135, 135, 137, 765 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, 766 135, 138, 138, 139, 139, 140, 141, 141, 142, 142, 767 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 768 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 769 142, 142, 142, 142, 142, 142, 142, 142, 142, 143, 770 143, 143, 144, 144, 144, 144, 144, 144, 144, 144, 771 144, 144, 144, 145, 145, 145, 145, 145, 145, 145, 772 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 773 145, 145, 145, 146, 146, 147, 147, 148, 148, 149, 774 149, 151, 150, 152, 152, 153, 153, 153, 153, 153, 775 153, 153, 153, 154, 155, 156, 157, 156, 156, 156, 776 158, 156, 156, 156, 159, 160, 156, 161, 156, 156, 777 162, 162, 163, 163, 164, 164, 164, 165, 165, 166, 778 166, 167, 167, 167, 167, 168, 168, 168, 168, 168, 779 168, 168, 168, 168, 169, 169, 169, 169, 169, 169, 780 169, 170, 170, 170, 171, 172, 173, 173 781 }; 782 783 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 784 static const yytype_uint8 yyr2[] = 785 { 786 0, 2, 0, 2, 2, 3, 0, 0, 6, 1, 787 0, 4, 3, 1, 3, 1, 3, 4, 4, 2, 788 3, 1, 0, 4, 3, 0, 4, 1, 3, 0, 789 4, 0, 5, 0, 1, 1, 3, 1, 3, 2, 790 0, 1, 2, 3, 1, 1, 4, 4, 2, 3, 791 3, 1, 3, 3, 2, 2, 2, 3, 1, 2, 792 1, 1, 2, 0, 1, 1, 2, 2, 3, 3, 793 3, 0, 2, 2, 1, 2, 3, 2, 2, 2, 794 1, 2, 1, 2, 2, 0, 2, 5, 7, 0, 795 10, 5, 7, 3, 5, 2, 2, 3, 5, 5, 796 5, 0, 1, 0, 1, 1, 1, 3, 1, 3, 797 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 798 3, 3, 3, 3, 3, 3, 3, 5, 3, 3, 799 3, 3, 3, 3, 3, 3, 3, 3, 3, 1, 800 5, 7, 1, 2, 2, 2, 2, 2, 2, 2, 801 2, 2, 2, 3, 5, 5, 4, 4, 3, 3, 802 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 803 1, 1, 1, 1, 2, 1, 2, 0, 1, 1, 804 3, 0, 4, 0, 1, 1, 1, 1, 2, 2, 805 3, 2, 3, 1, 1, 2, 0, 4, 2, 2, 806 0, 4, 2, 2, 0, 0, 7, 0, 5, 1, 807 1, 2, 0, 2, 1, 1, 1, 1, 2, 1, 808 1, 1, 3, 2, 3, 1, 1, 1, 1, 1, 809 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 810 1, 1, 1, 1, 1, 1, 1, 1 811 }; 812 813 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state 814 STATE-NUM when YYTABLE doesn't specify something else to do. Zero 815 means the default is an error. */ 816 static const yytype_uint8 yydefact[] = 817 { 818 2, 183, 1, 209, 234, 225, 232, 236, 231, 227, 819 228, 239, 226, 235, 0, 237, 238, 0, 230, 233, 820 0, 229, 241, 242, 243, 240, 3, 0, 194, 184, 821 185, 187, 217, 186, 220, 219, 246, 247, 181, 198, 822 195, 202, 199, 207, 203, 4, 212, 0, 0, 6, 823 13, 15, 245, 188, 210, 214, 216, 215, 212, 218, 824 191, 189, 0, 0, 0, 0, 0, 0, 0, 5, 825 0, 25, 0, 103, 63, 211, 190, 192, 0, 193, 826 29, 197, 201, 221, 0, 205, 14, 213, 16, 12, 827 9, 7, 0, 0, 0, 0, 0, 0, 0, 0, 828 244, 168, 167, 163, 164, 165, 166, 169, 170, 173, 829 175, 0, 0, 0, 0, 0, 104, 105, 108, 139, 830 142, 171, 172, 162, 0, 0, 64, 40, 65, 182, 831 31, 33, 0, 223, 208, 0, 0, 0, 0, 11, 832 51, 144, 145, 146, 143, 0, 106, 40, 149, 150, 833 0, 151, 0, 152, 147, 148, 18, 0, 0, 0, 834 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 835 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 836 0, 0, 0, 0, 0, 0, 0, 0, 0, 177, 837 0, 160, 161, 174, 176, 0, 17, 0, 212, 103, 838 0, 67, 66, 41, 44, 45, 33, 0, 37, 0, 839 34, 35, 15, 222, 224, 0, 71, 8, 27, 0, 840 0, 0, 61, 58, 60, 0, 0, 153, 212, 0, 841 0, 40, 40, 128, 138, 137, 136, 134, 135, 133, 842 132, 131, 130, 129, 0, 126, 125, 124, 123, 122, 843 121, 120, 116, 117, 119, 118, 114, 115, 112, 113, 844 109, 110, 111, 159, 0, 179, 0, 178, 158, 68, 845 69, 42, 0, 48, 0, 103, 63, 0, 39, 30, 846 0, 0, 206, 0, 26, 0, 54, 0, 56, 55, 847 62, 59, 52, 107, 42, 0, 0, 0, 0, 157, 848 156, 0, 43, 49, 50, 0, 0, 32, 36, 38, 849 0, 244, 0, 0, 0, 0, 0, 0, 0, 0, 850 101, 0, 0, 0, 0, 70, 72, 85, 74, 73, 851 80, 0, 0, 0, 102, 0, 28, 53, 57, 0, 852 140, 154, 155, 127, 180, 47, 46, 79, 78, 95, 853 0, 96, 77, 0, 0, 0, 177, 0, 177, 0, 854 0, 177, 75, 81, 86, 0, 84, 19, 21, 0, 855 0, 76, 0, 97, 0, 0, 93, 0, 0, 0, 856 0, 101, 0, 20, 0, 141, 0, 0, 0, 0, 857 0, 0, 0, 0, 82, 0, 0, 24, 0, 87, 858 99, 98, 94, 91, 100, 101, 83, 23, 0, 0, 859 0, 92, 88, 101, 0, 0, 90 860 }; 861 862 /* YYDEFGOTO[NTERM-NUM]. */ 863 static const yytype_int16 yydefgoto[] = 864 { 865 -1, 1, 26, 71, 136, 48, 72, 208, 50, 326, 866 369, 382, 91, 219, 78, 131, 206, 209, 210, 211, 867 202, 203, 204, 205, 222, 223, 224, 225, 125, 126, 868 217, 283, 327, 328, 329, 393, 330, 331, 332, 333, 869 115, 116, 334, 146, 118, 119, 120, 121, 122, 266, 870 267, 39, 62, 27, 79, 127, 29, 30, 63, 64, 871 66, 135, 65, 53, 67, 54, 31, 32, 84, 33, 872 34, 35, 123, 51, 52 873 }; 874 875 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 876 STATE-NUM. */ 877 #define YYPACT_NINF -331 878 static const yytype_int16 yypact[] = 879 { 880 -331, 548, -331, -331, -331, -331, -331, -331, -331, -331, 881 -331, -331, -331, -331, -3, -331, -331, -3, -331, -331, 882 149, -331, -331, -331, -331, -331, -331, 264, -331, -331, 883 965, 929, -331, 965, -331, -331, -331, -331, -331, -331, 884 -75, -331, -72, -331, -60, -331, -331, 307, 60, 270, 885 156, -331, -331, 965, -331, -331, -331, -331, -331, -331, 886 965, 965, 929, -44, -44, 29, -15, 199, -10, -331, 887 307, -331, 83, 756, 849, -331, 140, 965, 889, -331, 888 -331, -331, -331, 86, 12, -331, -331, -331, -331, -331, 889 90, 929, 686, 756, 756, 756, 756, 615, 756, 756, 890 -331, -331, -331, -331, -331, -331, -331, -331, -331, -331, 891 -331, 791, 826, 756, 756, 9, -331, 1084, -331, -331, 892 708, 54, 57, -331, 110, 56, 152, 310, -331, -331, 893 -331, 279, 756, 29, -331, 29, 63, 307, 165, -331, 894 1084, -331, -331, -331, -331, 30, 1084, 44, -331, -331, 895 615, -331, 615, -331, -331, -331, -331, 756, 756, 756, 896 756, 756, 756, 756, 756, 756, 756, 756, 756, 756, 897 756, 756, 756, 756, 756, 756, 756, 756, 756, 756, 898 756, 756, 756, 756, 756, 756, 756, 157, 756, 756, 899 157, -331, -331, -331, -331, 115, -331, 849, -331, 756, 900 128, -331, -331, -331, 182, -331, 279, 756, -331, 164, 901 200, -331, 208, 1084, -331, 13, -331, -331, -331, 262, 902 157, 756, 225, 228, 165, 73, 756, -331, -331, -7, 903 150, 44, 44, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 904 1084, 1084, 1084, 1084, 28, 304, 1100, 1115, 1129, 1142, 905 1153, 1153, 433, 433, 433, 433, 333, 333, 265, 265, 906 -331, -331, -331, -331, 8, 1084, 153, 236, -331, -331, 907 -331, 147, 158, -331, 161, 756, 849, 247, -331, -331, 908 279, 756, -331, 341, -331, 307, -331, 175, -331, -331, 909 254, 228, -331, -331, 135, 721, 188, 190, 756, -331, 910 -331, 756, -331, -331, -331, 191, 211, -331, -331, -331, 911 298, 301, 338, 756, 343, 339, 439, 157, 319, 321, 912 756, 322, 323, 324, 332, -331, -331, 509, -331, -331, 913 -331, 63, 306, 372, 373, 277, -331, -331, -331, 165, 914 -331, -331, -331, 425, -331, -331, -331, -331, -331, -331, 915 1053, -331, -331, 293, 375, 756, 756, 400, 756, 756, 916 756, 756, -331, -331, -331, 396, -331, -331, 430, 285, 917 377, -331, 431, -331, 55, 381, -331, 382, 62, 64, 918 383, 615, 473, -331, 307, -331, 756, 439, 479, 490, 919 439, 439, 493, 497, -331, 307, 686, -331, 66, 440, 920 -331, -331, -331, -331, -331, 756, 499, -331, 498, 439, 921 504, -331, -331, 756, 415, 439, -331 922 }; 923 924 /* YYPGOTO[NTERM-NUM]. */ 925 static const yytype_int16 yypgoto[] = 926 { 927 -331, -331, -331, -331, -331, 445, -331, -26, -331, -331, 928 -330, -331, -331, 233, -331, -331, -331, 313, 230, -331, 929 -132, -187, -331, -331, -82, 292, -331, 181, 245, 326, 930 193, -331, -331, 198, -227, -331, 203, -331, -331, -309, 931 -181, -183, -83, -45, -38, 243, -331, -331, -331, -175, 932 226, 10, -331, -331, -1, 0, -88, 495, -331, -331, 933 -331, -331, -331, -14, -51, -28, -331, 501, -85, 218, 934 231, -24, -52, -127, -12 935 }; 936 937 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 938 positive, shift that token. If negative, reduce the rule which 939 number is the opposite. If zero, do what YYDEFACT says. 940 If YYTABLE_NINF, syntax error. */ 941 #define YYTABLE_NINF -205 942 static const yytype_int16 yytable[] = 943 { 944 28, 49, 40, 137, 212, 42, 57, 76, 44, 57, 945 139, 357, 226, 274, 145, 230, 133, 133, 272, 61, 946 -196, 68, 128, -200, 278, 75, 228, 41, 117, 57, 947 199, 229, 226, 75, 226, -204, 57, 57, 287, 36, 948 37, 86, 274, 87, 90, 298, 77, 140, 214, 75, 949 215, 38, 87, 57, 397, 141, 142, 143, 144, 226, 950 148, 149, 80, 69, 70, 406, 226, 145, 226, 145, 951 226, 83, 394, 81, 82, 154, 155, 228, 130, 212, 952 85, 199, 229, 88, 302, 244, 273, 213, 92, 353, 953 28, 132, 38, 140, 305, -10, 410, 147, 309, 296, 954 297, 201, 299, 156, 414, 264, 193, 302, 134, 282, 955 194, 218, 233, 234, 235, 236, 237, 238, 239, 240, 956 241, 242, 243, 227, 245, 246, 247, 248, 249, 250, 957 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 958 261, 262, 290, 293, 265, 128, 195, 271, 387, 196, 959 231, 269, 232, 212, 117, 390, 197, 391, 216, 408, 960 399, 198, 117, 402, 403, 199, 200, 279, 228, 292, 961 36, 37, 199, 229, 68, 263, 117, 294, 268, 140, 962 198, 375, 412, 377, 199, 200, 380, 93, 416, 36, 963 37, 36, 37, 73, 74, 335, 94, 95, 96, 36, 964 37, 220, 221, 97, 280, 98, 99, 100, 286, 101, 965 102, 103, 104, 105, 106, 107, 108, 109, 110, 275, 966 276, 273, 22, 23, 128, 281, 24, 22, 23, 288, 967 117, 24, 46, 289, 22, 23, 117, 47, 24, 111, 968 301, 36, 37, 295, 43, 86, 300, 87, 55, 60, 969 307, 55, 303, 343, 304, 112, 265, 340, 338, 218, 970 138, 56, 113, 114, 56, 284, 285, 45, 350, 337, 971 87, 55, 374, -9, -9, -10, 378, 379, 55, 55, 972 367, 341, 28, 342, 56, 345, 22, 23, 383, 384, 973 24, 56, 56, 395, 140, 55, 207, 46, 184, 185, 974 186, 347, 47, 398, 346, 354, 36, 37, 56, 368, 975 46, 265, 46, 265, 407, 47, 265, 47, 348, 36, 976 37, 36, 37, 170, 171, 172, 173, 174, 175, 176, 977 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 978 46, 349, 310, 198, -101, 47, 351, 199, 200, 36, 979 37, 140, 36, 37, 151, 153, 352, 355, 368, 356, 980 358, 359, 360, 93, 182, 183, 184, 185, 186, 368, 981 361, 365, 94, 95, 96, 366, 372, 226, 373, 97, 982 28, 98, 99, 311, 3, 101, 102, 103, 104, 105, 983 106, 107, 108, 109, 110, 4, 312, 313, 5, 314, 984 315, 316, 6, 376, 7, 8, -89, 317, 318, 9, 985 10, 319, 11, 320, 12, 111, 321, 13, 14, 322, 986 15, 16, 17, 18, 323, 19, 20, 21, 22, 23, 987 324, 112, 24, 25, 381, -22, -85, 325, 113, 114, 988 310, 168, -101, 169, 170, 171, 172, 173, 174, 175, 989 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 990 186, 93, 180, 181, 182, 183, 184, 185, 186, 386, 991 94, 95, 96, 385, 388, 389, 392, 97, 396, 98, 992 99, 311, 400, 101, 102, 103, 104, 105, 106, 107, 993 108, 109, 110, 401, 312, 313, 404, 314, 315, 316, 994 405, 411, 409, 384, -89, 317, 318, 413, 415, 319, 995 308, 320, -101, 111, 321, 89, 291, 322, 336, 277, 996 370, 306, 323, 270, 364, 362, 58, 344, 324, 112, 997 363, 93, 59, 0, -85, 0, 113, 114, 0, 0, 998 94, 95, 96, 0, 0, 0, 0, 97, 2, 98, 999 99, 311, 0, 101, 102, 103, 104, 105, 106, 107, 1000 108, 109, 110, 0, 312, 313, 0, 314, 315, 316, 1001 0, 0, 0, 0, -89, 317, 318, 0, 0, 319, 1002 0, 320, 0, 111, 321, 0, 0, 322, 0, 0, 1003 0, 3, 323, 0, 0, 0, 0, 0, 324, 112, 1004 0, 0, 4, 0, 0, 5, 113, 114, 0, 6, 1005 0, 7, 8, 0, 0, 0, 9, 10, 0, 11, 1006 0, 12, 0, 0, 13, 14, 0, 15, 16, 17, 1007 18, 0, 19, 20, 21, 22, 23, 93, 0, 24, 1008 25, 0, 0, 0, 0, 0, 94, 95, 96, 0, 1009 0, 0, 0, 97, 0, 98, 99, 100, 3, 101, 1010 102, 103, 104, 105, 106, 107, 108, 109, 110, 4, 1011 0, 0, 5, 0, 0, 0, 6, 0, 7, 8, 1012 0, 0, 0, 9, 10, 0, 11, 0, 12, 111, 1013 0, 13, 14, 0, 15, 16, 17, 18, 0, 19, 1014 20, 21, 22, 23, 0, 112, 24, 25, 93, 0, 1015 0, 0, 113, 114, 0, 0, 0, 94, 95, 96, 1016 0, 0, 0, 0, 97, 0, 98, 99, 100, 0, 1017 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 1018 0, 0, 0, 93, 187, 188, 189, 190, 191, 192, 1019 0, 0, 94, 95, 96, 0, 0, 0, 0, 97, 1020 111, 98, 99, 100, 0, 101, 102, 103, 104, 105, 1021 106, 107, 108, 109, 110, 0, 112, 0, 93, 0, 1022 0, 138, 0, 113, 114, 0, 0, 94, 95, 96, 1023 0, 0, 0, 0, 97, 111, 98, 99, 100, 0, 1024 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 1025 0, 112, 0, 93, 0, 0, 339, 0, 113, 114, 1026 0, 0, 94, 95, 96, 0, 0, 0, 0, 150, 1027 111, 98, 99, 100, 0, 101, 102, 103, 104, 105, 1028 106, 107, 108, 109, 110, 0, 112, 0, 93, 0, 1029 0, 0, 0, 113, 114, 0, 0, 94, 95, 96, 1030 0, 0, 0, 0, 152, 111, 98, 99, 100, 0, 1031 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 1032 0, 112, 0, 0, 0, 124, 0, 0, 113, 114, 1033 0, 100, 3, 0, 0, 0, 0, 0, 0, 0, 1034 111, 0, 0, 4, 0, 0, 5, 0, 0, 0, 1035 6, 0, 7, 8, 0, 0, 112, 9, 10, 0, 1036 11, 0, 12, 113, 114, 13, 14, 0, 15, 16, 1037 17, 18, 3, 19, 20, 21, 22, 23, 0, 0, 1038 24, 25, 0, 4, 0, 0, 5, 0, 0, 0, 1039 6, 0, 7, 8, 0, 0, 0, 9, 10, 0, 1040 11, 0, 12, 0, 0, 13, 14, 0, 15, 16, 1041 17, 18, 3, 19, 20, 21, 22, 23, 0, 0, 1042 24, 25, 0, 4, 0, 129, 5, 0, 0, 0, 1043 6, 0, 7, 8, 0, 0, 0, 9, 10, 0, 1044 11, 0, 12, 0, 0, 13, 14, 0, 15, 16, 1045 17, 18, 0, 19, 20, 21, 22, 23, 0, 4, 1046 24, 25, 5, 0, 0, 0, 6, 0, 7, 8, 1047 0, 0, 0, 9, 10, 0, 11, 0, 12, 0, 1048 0, 13, 0, 0, 15, 16, 0, 18, 0, 19, 1049 0, 21, 22, 23, 0, 0, 24, 25, 157, 158, 1050 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 1051 371, 169, 170, 171, 172, 173, 174, 175, 176, 177, 1052 178, 179, 180, 181, 182, 183, 184, 185, 186, 157, 1053 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 1054 168, 0, 169, 170, 171, 172, 173, 174, 175, 176, 1055 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 1056 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 1057 181, 182, 183, 184, 185, 186, 172, 173, 174, 175, 1058 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 1059 186, 173, 174, 175, 176, 177, 178, 179, 180, 181, 1060 182, 183, 184, 185, 186, 174, 175, 176, 177, 178, 1061 179, 180, 181, 182, 183, 184, 185, 186, 176, 177, 1062 178, 179, 180, 181, 182, 183, 184, 185, 186 1063 }; 1064 1065 static const yytype_int16 yycheck[] = 1066 { 1067 1, 27, 14, 91, 131, 17, 30, 58, 20, 33, 1068 92, 320, 4, 200, 97, 147, 4, 4, 199, 33, 1069 95, 47, 74, 95, 207, 53, 33, 17, 73, 53, 1070 37, 38, 4, 61, 4, 95, 60, 61, 221, 42, 1071 43, 67, 229, 67, 70, 17, 60, 92, 133, 77, 1072 135, 95, 76, 77, 384, 93, 94, 95, 96, 4, 1073 98, 99, 62, 3, 4, 395, 4, 150, 4, 152, 1074 4, 42, 381, 63, 64, 113, 114, 33, 78, 206, 1075 95, 37, 38, 93, 271, 168, 93, 132, 5, 316, 1076 91, 5, 95, 138, 275, 5, 405, 97, 281, 231, 1077 232, 127, 94, 94, 413, 188, 52, 294, 96, 96, 1078 53, 137, 157, 158, 159, 160, 161, 162, 163, 164, 1079 165, 166, 167, 93, 169, 170, 171, 172, 173, 174, 1080 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 1081 185, 186, 224, 226, 189, 197, 36, 198, 93, 93, 1082 150, 36, 152, 280, 199, 93, 4, 93, 95, 93, 1083 387, 33, 207, 390, 391, 37, 38, 3, 33, 96, 1084 42, 43, 37, 38, 200, 187, 221, 228, 190, 224, 1085 33, 356, 409, 358, 37, 38, 361, 22, 415, 42, 1086 43, 42, 43, 37, 38, 283, 31, 32, 33, 42, 1087 43, 36, 37, 38, 4, 40, 41, 42, 220, 44, 1088 45, 46, 47, 48, 49, 50, 51, 52, 53, 37, 1089 38, 93, 87, 88, 276, 17, 91, 87, 88, 4, 1090 275, 91, 33, 5, 87, 88, 281, 38, 91, 74, 1091 4, 42, 43, 93, 95, 271, 93, 271, 30, 31, 1092 3, 33, 94, 298, 93, 90, 301, 295, 4, 285, 1093 95, 30, 97, 98, 33, 3, 4, 3, 313, 94, 1094 294, 53, 355, 3, 4, 5, 359, 360, 60, 61, 1095 3, 93, 283, 93, 53, 94, 87, 88, 3, 4, 1096 91, 60, 61, 381, 339, 77, 17, 33, 33, 34, 1097 35, 3, 38, 386, 93, 317, 42, 43, 77, 335, 1098 33, 356, 33, 358, 396, 38, 361, 38, 17, 42, 1099 43, 42, 43, 19, 20, 21, 22, 23, 24, 25, 1100 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 1101 33, 3, 1, 33, 3, 38, 3, 37, 38, 42, 1102 43, 396, 42, 43, 111, 112, 17, 38, 384, 38, 1103 38, 38, 38, 22, 31, 32, 33, 34, 35, 395, 1104 38, 65, 31, 32, 33, 3, 83, 4, 3, 38, 1105 381, 40, 41, 42, 43, 44, 45, 46, 47, 48, 1106 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 1107 59, 60, 61, 3, 63, 64, 65, 66, 67, 68, 1108 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 1109 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 1110 89, 90, 91, 92, 38, 5, 95, 96, 97, 98, 1111 1, 16, 3, 18, 19, 20, 21, 22, 23, 24, 1112 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 1113 35, 22, 29, 30, 31, 32, 33, 34, 35, 38, 1114 31, 32, 33, 96, 93, 93, 93, 38, 5, 40, 1115 41, 42, 3, 44, 45, 46, 47, 48, 49, 50, 1116 51, 52, 53, 3, 55, 56, 3, 58, 59, 60, 1117 3, 3, 62, 4, 65, 66, 67, 3, 93, 70, 1118 280, 72, 3, 74, 75, 70, 224, 78, 285, 206, 1119 339, 276, 83, 197, 331, 327, 31, 301, 89, 90, 1120 327, 22, 31, -1, 95, -1, 97, 98, -1, -1, 1121 31, 32, 33, -1, -1, -1, -1, 38, 0, 40, 1122 41, 42, -1, 44, 45, 46, 47, 48, 49, 50, 1123 51, 52, 53, -1, 55, 56, -1, 58, 59, 60, 1124 -1, -1, -1, -1, 65, 66, 67, -1, -1, 70, 1125 -1, 72, -1, 74, 75, -1, -1, 78, -1, -1, 1126 -1, 43, 83, -1, -1, -1, -1, -1, 89, 90, 1127 -1, -1, 54, -1, -1, 57, 97, 98, -1, 61, 1128 -1, 63, 64, -1, -1, -1, 68, 69, -1, 71, 1129 -1, 73, -1, -1, 76, 77, -1, 79, 80, 81, 1130 82, -1, 84, 85, 86, 87, 88, 22, -1, 91, 1131 92, -1, -1, -1, -1, -1, 31, 32, 33, -1, 1132 -1, -1, -1, 38, -1, 40, 41, 42, 43, 44, 1133 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 1134 -1, -1, 57, -1, -1, -1, 61, -1, 63, 64, 1135 -1, -1, -1, 68, 69, -1, 71, -1, 73, 74, 1136 -1, 76, 77, -1, 79, 80, 81, 82, -1, 84, 1137 85, 86, 87, 88, -1, 90, 91, 92, 22, -1, 1138 -1, -1, 97, 98, -1, -1, -1, 31, 32, 33, 1139 -1, -1, -1, -1, 38, -1, 40, 41, 42, -1, 1140 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 1141 -1, -1, -1, 22, 36, 37, 38, 39, 40, 41, 1142 -1, -1, 31, 32, 33, -1, -1, -1, -1, 38, 1143 74, 40, 41, 42, -1, 44, 45, 46, 47, 48, 1144 49, 50, 51, 52, 53, -1, 90, -1, 22, -1, 1145 -1, 95, -1, 97, 98, -1, -1, 31, 32, 33, 1146 -1, -1, -1, -1, 38, 74, 40, 41, 42, -1, 1147 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 1148 -1, 90, -1, 22, -1, -1, 95, -1, 97, 98, 1149 -1, -1, 31, 32, 33, -1, -1, -1, -1, 38, 1150 74, 40, 41, 42, -1, 44, 45, 46, 47, 48, 1151 49, 50, 51, 52, 53, -1, 90, -1, 22, -1, 1152 -1, -1, -1, 97, 98, -1, -1, 31, 32, 33, 1153 -1, -1, -1, -1, 38, 74, 40, 41, 42, -1, 1154 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 1155 -1, 90, -1, -1, -1, 36, -1, -1, 97, 98, 1156 -1, 42, 43, -1, -1, -1, -1, -1, -1, -1, 1157 74, -1, -1, 54, -1, -1, 57, -1, -1, -1, 1158 61, -1, 63, 64, -1, -1, 90, 68, 69, -1, 1159 71, -1, 73, 97, 98, 76, 77, -1, 79, 80, 1160 81, 82, 43, 84, 85, 86, 87, 88, -1, -1, 1161 91, 92, -1, 54, -1, -1, 57, -1, -1, -1, 1162 61, -1, 63, 64, -1, -1, -1, 68, 69, -1, 1163 71, -1, 73, -1, -1, 76, 77, -1, 79, 80, 1164 81, 82, 43, 84, 85, 86, 87, 88, -1, -1, 1165 91, 92, -1, 54, -1, 96, 57, -1, -1, -1, 1166 61, -1, 63, 64, -1, -1, -1, 68, 69, -1, 1167 71, -1, 73, -1, -1, 76, 77, -1, 79, 80, 1168 81, 82, -1, 84, 85, 86, 87, 88, -1, 54, 1169 91, 92, 57, -1, -1, -1, 61, -1, 63, 64, 1170 -1, -1, -1, 68, 69, -1, 71, -1, 73, -1, 1171 -1, 76, -1, -1, 79, 80, -1, 82, -1, 84, 1172 -1, 86, 87, 88, -1, -1, 91, 92, 5, 6, 1173 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 1174 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 1175 27, 28, 29, 30, 31, 32, 33, 34, 35, 5, 1176 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 1177 16, -1, 18, 19, 20, 21, 22, 23, 24, 25, 1178 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 1179 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 1180 30, 31, 32, 33, 34, 35, 21, 22, 23, 24, 1181 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 1182 35, 22, 23, 24, 25, 26, 27, 28, 29, 30, 1183 31, 32, 33, 34, 35, 23, 24, 25, 26, 27, 1184 28, 29, 30, 31, 32, 33, 34, 35, 25, 26, 1185 27, 28, 29, 30, 31, 32, 33, 34, 35 1186 }; 1187 1188 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 1189 symbol of state STATE-NUM. */ 1190 static const yytype_uint8 yystos[] = 1191 { 1192 0, 100, 0, 43, 54, 57, 61, 63, 64, 68, 1193 69, 71, 73, 76, 77, 79, 80, 81, 82, 84, 1194 85, 86, 87, 88, 91, 92, 101, 152, 153, 155, 1195 156, 165, 166, 168, 169, 170, 42, 43, 95, 150, 1196 173, 150, 173, 95, 173, 3, 33, 38, 104, 106, 1197 107, 172, 173, 162, 164, 168, 169, 170, 156, 166, 1198 168, 162, 151, 157, 158, 161, 159, 163, 106, 3, 1199 4, 102, 105, 37, 38, 164, 163, 162, 113, 153, 1200 154, 150, 150, 42, 167, 95, 106, 170, 93, 104, 1201 106, 111, 5, 22, 31, 32, 33, 38, 40, 41, 1202 42, 44, 45, 46, 47, 48, 49, 50, 51, 52, 1203 53, 74, 90, 97, 98, 139, 140, 142, 143, 144, 1204 145, 146, 147, 171, 36, 127, 128, 154, 171, 96, 1205 154, 114, 5, 4, 96, 160, 103, 155, 95, 123, 1206 142, 143, 143, 143, 143, 141, 142, 154, 143, 143, 1207 38, 144, 38, 144, 143, 143, 94, 5, 6, 7, 1208 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 1209 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 1210 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 1211 39, 40, 41, 52, 53, 36, 93, 4, 33, 37, 1212 38, 106, 119, 120, 121, 122, 115, 17, 106, 116, 1213 117, 118, 172, 142, 167, 167, 95, 129, 106, 112, 1214 36, 37, 123, 124, 125, 126, 4, 93, 33, 38, 1215 119, 154, 154, 142, 142, 142, 142, 142, 142, 142, 1216 142, 142, 142, 142, 141, 142, 142, 142, 142, 142, 1217 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 1218 142, 142, 142, 173, 141, 142, 148, 149, 173, 36, 1219 128, 163, 139, 93, 120, 37, 38, 116, 140, 3, 1220 4, 17, 96, 130, 3, 4, 173, 140, 4, 5, 1221 123, 124, 96, 141, 163, 93, 119, 119, 17, 94, 1222 93, 4, 120, 94, 93, 139, 127, 3, 117, 140, 1223 1, 42, 55, 56, 58, 59, 60, 66, 67, 70, 1224 72, 75, 78, 83, 89, 96, 108, 131, 132, 133, 1225 135, 136, 137, 138, 141, 155, 112, 94, 4, 95, 1226 143, 93, 93, 142, 149, 94, 93, 3, 17, 3, 1227 142, 3, 17, 133, 173, 38, 38, 138, 38, 38, 1228 38, 38, 132, 135, 129, 65, 3, 3, 106, 109, 1229 126, 17, 83, 3, 141, 148, 3, 148, 141, 141, 1230 148, 38, 110, 3, 4, 96, 38, 93, 93, 93, 1231 93, 93, 93, 134, 138, 155, 5, 109, 141, 133, 1232 3, 3, 133, 133, 3, 3, 109, 123, 93, 62, 1233 138, 3, 133, 3, 138, 93, 133 1234 }; 1235 1236 #define yyerrok (yyerrstatus = 0) 1237 #define yyclearin (yychar = YYEMPTY) 1238 #define YYEMPTY (-2) 1239 #define YYEOF 0 1240 1241 #define YYACCEPT goto yyacceptlab 1242 #define YYABORT goto yyabortlab 1243 #define YYERROR goto yyerrorlab 1244 1245 1246 /* Like YYERROR except do call yyerror. This remains here temporarily 1247 to ease the transition to the new meaning of YYERROR, for GCC. 1248 Once GCC version 2 has supplanted version 1, this can go. */ 1249 1250 #define YYFAIL goto yyerrlab 1251 1252 #define YYRECOVERING() (!!yyerrstatus) 1253 1254 #define YYBACKUP(Token, Value) \ 1255 do \ 1256 if (yychar == YYEMPTY && yylen == 1) \ 1257 { \ 1258 yychar = (Token); \ 1259 yylval = (Value); \ 1260 yytoken = YYTRANSLATE (yychar); \ 1261 YYPOPSTACK (1); \ 1262 goto yybackup; \ 1263 } \ 1264 else \ 1265 { \ 1266 yyerror (YY_("syntax error: cannot back up")); \ 1267 YYERROR; \ 1268 } \ 1269 while (YYID (0)) 1270 1271 1272 #define YYTERROR 1 1273 #define YYERRCODE 256 1274 1275 1276 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. 1277 If N is 0, then set CURRENT to the empty location which ends 1278 the previous symbol: RHS[0] (always defined). */ 1279 1280 #define YYRHSLOC(Rhs, K) ((Rhs)[K]) 1281 #ifndef YYLLOC_DEFAULT 1282 # define YYLLOC_DEFAULT(Current, Rhs, N) \ 1283 do \ 1284 if (YYID (N)) \ 1285 { \ 1286 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ 1287 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ 1288 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ 1289 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ 1290 } \ 1291 else \ 1292 { \ 1293 (Current).first_line = (Current).last_line = \ 1294 YYRHSLOC (Rhs, 0).last_line; \ 1295 (Current).first_column = (Current).last_column = \ 1296 YYRHSLOC (Rhs, 0).last_column; \ 1297 } \ 1298 while (YYID (0)) 1299 #endif 1300 1301 1302 /* YY_LOCATION_PRINT -- Print the location on the stream. 1303 This macro was not mandated originally: define only if we know 1304 we won't break user code: when these are the locations we know. */ 1305 1306 #ifndef YY_LOCATION_PRINT 1307 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL 1308 # define YY_LOCATION_PRINT(File, Loc) \ 1309 fprintf (File, "%d.%d-%d.%d", \ 1310 (Loc).first_line, (Loc).first_column, \ 1311 (Loc).last_line, (Loc).last_column) 1312 # else 1313 # define YY_LOCATION_PRINT(File, Loc) ((void) 0) 1314 # endif 1315 #endif 1316 1317 1318 /* YYLEX -- calling `yylex' with the right arguments. */ 1319 1320 #ifdef YYLEX_PARAM 1321 # define YYLEX yylex (YYLEX_PARAM) 1322 #else 1323 # define YYLEX yylex () 1324 #endif 1325 1326 /* Enable debugging if requested. */ 1327 #if YYDEBUG 1328 1329 # ifndef YYFPRINTF 1330 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 1331 # define YYFPRINTF fprintf 1332 # endif 1333 1334 # define YYDPRINTF(Args) \ 1335 do { \ 1336 if (yydebug) \ 1337 YYFPRINTF Args; \ 1338 } while (YYID (0)) 1339 1340 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 1341 do { \ 1342 if (yydebug) \ 1343 { \ 1344 YYFPRINTF (stderr, "%s ", Title); \ 1345 yy_symbol_print (stderr, \ 1346 Type, Value); \ 1347 YYFPRINTF (stderr, "\n"); \ 1348 } \ 1349 } while (YYID (0)) 1350 1351 1352 /*--------------------------------. 1353 | Print this symbol on YYOUTPUT. | 1354 `--------------------------------*/ 1355 1356 /*ARGSUSED*/ 1357 #if (defined __STDC__ || defined __C99__FUNC__ \ 1358 || defined __cplusplus || defined _MSC_VER) 1359 static void 1360 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 1361 #else 1362 static void 1363 yy_symbol_value_print (yyoutput, yytype, yyvaluep) 1364 FILE *yyoutput; 1365 int yytype; 1366 YYSTYPE const * const yyvaluep; 1367 #endif 1368 { 1369 if (!yyvaluep) 1370 return; 1371 # ifdef YYPRINT 1372 if (yytype < YYNTOKENS) 1373 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 1374 # else 1375 YYUSE (yyoutput); 1376 # endif 1377 switch (yytype) 1378 { 1379 default: 1380 break; 1381 } 1382 } 1383 1384 1385 /*--------------------------------. 1386 | Print this symbol on YYOUTPUT. | 1387 `--------------------------------*/ 1388 1389 #if (defined __STDC__ || defined __C99__FUNC__ \ 1390 || defined __cplusplus || defined _MSC_VER) 1391 static void 1392 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 1393 #else 1394 static void 1395 yy_symbol_print (yyoutput, yytype, yyvaluep) 1396 FILE *yyoutput; 1397 int yytype; 1398 YYSTYPE const * const yyvaluep; 1399 #endif 1400 { 1401 if (yytype < YYNTOKENS) 1402 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); 1403 else 1404 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); 1405 1406 yy_symbol_value_print (yyoutput, yytype, yyvaluep); 1407 YYFPRINTF (yyoutput, ")"); 1408 } 1409 1410 /*------------------------------------------------------------------. 1411 | yy_stack_print -- Print the state stack from its BOTTOM up to its | 1412 | TOP (included). | 1413 `------------------------------------------------------------------*/ 1414 1415 #if (defined __STDC__ || defined __C99__FUNC__ \ 1416 || defined __cplusplus || defined _MSC_VER) 1417 static void 1418 yy_stack_print (yytype_int16 *bottom, yytype_int16 *top) 1419 #else 1420 static void 1421 yy_stack_print (bottom, top) 1422 yytype_int16 *bottom; 1423 yytype_int16 *top; 1424 #endif 1425 { 1426 YYFPRINTF (stderr, "Stack now"); 1427 for (; bottom <= top; ++bottom) 1428 YYFPRINTF (stderr, " %d", *bottom); 1429 YYFPRINTF (stderr, "\n"); 1430 } 1431 1432 # define YY_STACK_PRINT(Bottom, Top) \ 1433 do { \ 1434 if (yydebug) \ 1435 yy_stack_print ((Bottom), (Top)); \ 1436 } while (YYID (0)) 1437 1438 1439 /*------------------------------------------------. 1440 | Report that the YYRULE is going to be reduced. | 1441 `------------------------------------------------*/ 1442 1443 #if (defined __STDC__ || defined __C99__FUNC__ \ 1444 || defined __cplusplus || defined _MSC_VER) 1445 static void 1446 yy_reduce_print (YYSTYPE *yyvsp, int yyrule) 1447 #else 1448 static void 1449 yy_reduce_print (yyvsp, yyrule) 1450 YYSTYPE *yyvsp; 1451 int yyrule; 1452 #endif 1453 { 1454 int yynrhs = yyr2[yyrule]; 1455 int yyi; 1456 unsigned long int yylno = yyrline[yyrule]; 1457 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", 1458 yyrule - 1, yylno); 1459 /* The symbols being reduced. */ 1460 for (yyi = 0; yyi < yynrhs; yyi++) 1461 { 1462 fprintf (stderr, " $%d = ", yyi + 1); 1463 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], 1464 &(yyvsp[(yyi + 1) - (yynrhs)]) 1465 ); 1466 fprintf (stderr, "\n"); 1467 } 1468 } 1469 1470 # define YY_REDUCE_PRINT(Rule) \ 1471 do { \ 1472 if (yydebug) \ 1473 yy_reduce_print (yyvsp, Rule); \ 1474 } while (YYID (0)) 1475 1476 /* Nonzero means print parse trace. It is left uninitialized so that 1477 multiple parsers can coexist. */ 1478 int yydebug; 1479 #else /* !YYDEBUG */ 1480 # define YYDPRINTF(Args) 1481 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) 1482 # define YY_STACK_PRINT(Bottom, Top) 1483 # define YY_REDUCE_PRINT(Rule) 1484 #endif /* !YYDEBUG */ 1485 1486 1487 /* YYINITDEPTH -- initial size of the parser's stacks. */ 1488 #ifndef YYINITDEPTH 1489 # define YYINITDEPTH 200 1490 #endif 1491 1492 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 1493 if the built-in stack extension method is used). 1494 1495 Do not make this value too large; the results are undefined if 1496 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 1497 evaluated with infinite-precision integer arithmetic. */ 1498 1499 #ifndef YYMAXDEPTH 1500 # define YYMAXDEPTH 10000 1501 #endif 1502 1503 1504 1505 #if YYERROR_VERBOSE 1506 1507 # ifndef yystrlen 1508 # if defined __GLIBC__ && defined _STRING_H 1509 # define yystrlen strlen 1510 # else 1511 /* Return the length of YYSTR. */ 1512 #if (defined __STDC__ || defined __C99__FUNC__ \ 1513 || defined __cplusplus || defined _MSC_VER) 1514 static YYSIZE_T 1515 yystrlen (const char *yystr) 1516 #else 1517 static YYSIZE_T 1518 yystrlen (yystr) 1519 const char *yystr; 1520 #endif 1521 { 1522 YYSIZE_T yylen; 1523 for (yylen = 0; yystr[yylen]; yylen++) 1524 continue; 1525 return yylen; 1526 } 1527 # endif 1528 # endif 1529 1530 # ifndef yystpcpy 1531 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 1532 # define yystpcpy stpcpy 1533 # else 1534 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 1535 YYDEST. */ 1536 #if (defined __STDC__ || defined __C99__FUNC__ \ 1537 || defined __cplusplus || defined _MSC_VER) 1538 static char * 1539 yystpcpy (char *yydest, const char *yysrc) 1540 #else 1541 static char * 1542 yystpcpy (yydest, yysrc) 1543 char *yydest; 1544 const char *yysrc; 1545 #endif 1546 { 1547 char *yyd = yydest; 1548 const char *yys = yysrc; 1549 1550 while ((*yyd++ = *yys++) != '\0') 1551 continue; 1552 1553 return yyd - 1; 1554 } 1555 # endif 1556 # endif 1557 1558 # ifndef yytnamerr 1559 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary 1560 quotes and backslashes, so that it's suitable for yyerror. The 1561 heuristic is that double-quoting is unnecessary unless the string 1562 contains an apostrophe, a comma, or backslash (other than 1563 backslash-backslash). YYSTR is taken from yytname. If YYRES is 1564 null, do not copy; instead, return the length of what the result 1565 would have been. */ 1566 static YYSIZE_T 1567 yytnamerr (char *yyres, const char *yystr) 1568 { 1569 if (*yystr == '"') 1570 { 1571 YYSIZE_T yyn = 0; 1572 char const *yyp = yystr; 1573 1574 for (;;) 1575 switch (*++yyp) 1576 { 1577 case '\'': 1578 case ',': 1579 goto do_not_strip_quotes; 1580 1581 case '\\': 1582 if (*++yyp != '\\') 1583 goto do_not_strip_quotes; 1584 /* Fall through. */ 1585 default: 1586 if (yyres) 1587 yyres[yyn] = *yyp; 1588 yyn++; 1589 break; 1590 1591 case '"': 1592 if (yyres) 1593 yyres[yyn] = '\0'; 1594 return yyn; 1595 } 1596 do_not_strip_quotes: ; 1597 } 1598 1599 if (! yyres) 1600 return yystrlen (yystr); 1601 1602 return yystpcpy (yyres, yystr) - yyres; 1603 } 1604 # endif 1605 1606 /* Copy into YYRESULT an error message about the unexpected token 1607 YYCHAR while in state YYSTATE. Return the number of bytes copied, 1608 including the terminating null byte. If YYRESULT is null, do not 1609 copy anything; just return the number of bytes that would be 1610 copied. As a special case, return 0 if an ordinary "syntax error" 1611 message will do. Return YYSIZE_MAXIMUM if overflow occurs during 1612 size calculation. */ 1613 static YYSIZE_T 1614 yysyntax_error (char *yyresult, int yystate, int yychar) 1615 { 1616 int yyn = yypact[yystate]; 1617 1618 if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) 1619 return 0; 1620 else 1621 { 1622 int yytype = YYTRANSLATE (yychar); 1623 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); 1624 YYSIZE_T yysize = yysize0; 1625 YYSIZE_T yysize1; 1626 int yysize_overflow = 0; 1627 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 1628 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 1629 int yyx; 1630 1631 # if 0 1632 /* This is so xgettext sees the translatable formats that are 1633 constructed on the fly. */ 1634 YY_("syntax error, unexpected %s"); 1635 YY_("syntax error, unexpected %s, expecting %s"); 1636 YY_("syntax error, unexpected %s, expecting %s or %s"); 1637 YY_("syntax error, unexpected %s, expecting %s or %s or %s"); 1638 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); 1639 # endif 1640 char *yyfmt; 1641 char const *yyf; 1642 static char const yyunexpected[] = "syntax error, unexpected %s"; 1643 static char const yyexpecting[] = ", expecting %s"; 1644 static char const yyor[] = " or %s"; 1645 char yyformat[sizeof yyunexpected 1646 + sizeof yyexpecting - 1 1647 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) 1648 * (sizeof yyor - 1))]; 1649 char const *yyprefix = yyexpecting; 1650 1651 /* Start YYX at -YYN if negative to avoid negative indexes in 1652 YYCHECK. */ 1653 int yyxbegin = yyn < 0 ? -yyn : 0; 1654 1655 /* Stay within bounds of both yycheck and yytname. */ 1656 int yychecklim = YYLAST - yyn + 1; 1657 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 1658 int yycount = 1; 1659 1660 yyarg[0] = yytname[yytype]; 1661 yyfmt = yystpcpy (yyformat, yyunexpected); 1662 1663 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 1664 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) 1665 { 1666 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 1667 { 1668 yycount = 1; 1669 yysize = yysize0; 1670 yyformat[sizeof yyunexpected - 1] = '\0'; 1671 break; 1672 } 1673 yyarg[yycount++] = yytname[yyx]; 1674 yysize1 = yysize + yytnamerr (0, yytname[yyx]); 1675 yysize_overflow |= (yysize1 < yysize); 1676 yysize = yysize1; 1677 yyfmt = yystpcpy (yyfmt, yyprefix); 1678 yyprefix = yyor; 1679 } 1680 1681 yyf = YY_(yyformat); 1682 yysize1 = yysize + yystrlen (yyf); 1683 yysize_overflow |= (yysize1 < yysize); 1684 yysize = yysize1; 1685 1686 if (yysize_overflow) 1687 return YYSIZE_MAXIMUM; 1688 1689 if (yyresult) 1690 { 1691 /* Avoid sprintf, as that infringes on the user's name space. 1692 Don't have undefined behavior even if the translation 1693 produced a string with the wrong number of "%s"s. */ 1694 char *yyp = yyresult; 1695 int yyi = 0; 1696 while ((*yyp = *yyf) != '\0') 1697 { 1698 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) 1699 { 1700 yyp += yytnamerr (yyp, yyarg[yyi++]); 1701 yyf += 2; 1702 } 1703 else 1704 { 1705 yyp++; 1706 yyf++; 1707 } 1708 } 1709 } 1710 return yysize; 1711 } 1712 } 1713 #endif /* YYERROR_VERBOSE */ 1714 1715 1716 /*-----------------------------------------------. 1717 | Release the memory associated to this symbol. | 1718 `-----------------------------------------------*/ 1719 1720 /*ARGSUSED*/ 1721 #if (defined __STDC__ || defined __C99__FUNC__ \ 1722 || defined __cplusplus || defined _MSC_VER) 1723 static void 1724 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) 1725 #else 1726 static void 1727 yydestruct (yymsg, yytype, yyvaluep) 1728 const char *yymsg; 1729 int yytype; 1730 YYSTYPE *yyvaluep; 1731 #endif 1732 { 1733 YYUSE (yyvaluep); 1734 1735 if (!yymsg) 1736 yymsg = "Deleting"; 1737 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1738 1739 switch (yytype) 1740 { 1741 1742 default: 1743 break; 1744 } 1745 } 1746 1747 1748 /* Prevent warnings from -Wmissing-prototypes. */ 1749 1750 #ifdef YYPARSE_PARAM 1751 #if defined __STDC__ || defined __cplusplus 1752 int yyparse (void *YYPARSE_PARAM); 1753 #else 1754 int yyparse (); 1755 #endif 1756 #else /* ! YYPARSE_PARAM */ 1757 #if defined __STDC__ || defined __cplusplus 1758 int yyparse (void); 1759 #else 1760 int yyparse (); 1761 #endif 1762 #endif /* ! YYPARSE_PARAM */ 1763 1764 1765 1766 /* The look-ahead symbol. */ 1767 int yychar; 1768 1769 /* The semantic value of the look-ahead symbol. */ 1770 YYSTYPE yylval; 1771 1772 /* Number of syntax errors so far. */ 1773 int yynerrs; 1774 1775 1776 1777 /*----------. 1778 | yyparse. | 1779 `----------*/ 1780 1781 #ifdef YYPARSE_PARAM 1782 #if (defined __STDC__ || defined __C99__FUNC__ \ 1783 || defined __cplusplus || defined _MSC_VER) 1784 int 1785 yyparse (void *YYPARSE_PARAM) 1786 #else 1787 int 1788 yyparse (YYPARSE_PARAM) 1789 void *YYPARSE_PARAM; 1790 #endif 1791 #else /* ! YYPARSE_PARAM */ 1792 #if (defined __STDC__ || defined __C99__FUNC__ \ 1793 || defined __cplusplus || defined _MSC_VER) 1794 int 1795 yyparse (void) 1796 #else 1797 int 1798 yyparse () 1799 1800 #endif 1801 #endif 1802 { 1803 1804 int yystate; 1805 int yyn; 1806 int yyresult; 1807 /* Number of tokens to shift before error messages enabled. */ 1808 int yyerrstatus; 1809 /* Look-ahead token as an internal (translated) token number. */ 1810 int yytoken = 0; 1811 #if YYERROR_VERBOSE 1812 /* Buffer for error messages, and its allocated size. */ 1813 char yymsgbuf[128]; 1814 char *yymsg = yymsgbuf; 1815 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 1816 #endif 1817 1818 /* Three stacks and their tools: 1819 `yyss': related to states, 1820 `yyvs': related to semantic values, 1821 `yyls': related to locations. 1822 1823 Refer to the stacks thru separate pointers, to allow yyoverflow 1824 to reallocate them elsewhere. */ 1825 1826 /* The state stack. */ 1827 yytype_int16 yyssa[YYINITDEPTH]; 1828 yytype_int16 *yyss = yyssa; 1829 yytype_int16 *yyssp; 1830 1831 /* The semantic value stack. */ 1832 YYSTYPE yyvsa[YYINITDEPTH]; 1833 YYSTYPE *yyvs = yyvsa; 1834 YYSTYPE *yyvsp; 1835 1836 1837 1838 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 1839 1840 YYSIZE_T yystacksize = YYINITDEPTH; 1841 1842 /* The variables used to return semantic value and location from the 1843 action routines. */ 1844 YYSTYPE yyval; 1845 1846 1847 /* The number of symbols on the RHS of the reduced rule. 1848 Keep to zero when no symbol should be popped. */ 1849 int yylen = 0; 1850 1851 YYDPRINTF ((stderr, "Starting parse\n")); 1852 1853 yystate = 0; 1854 yyerrstatus = 0; 1855 yynerrs = 0; 1856 yychar = YYEMPTY; /* Cause a token to be read. */ 1857 1858 /* Initialize stack pointers. 1859 Waste one element of value and location stack 1860 so that they stay on the same level as the state stack. 1861 The wasted elements are never initialized. */ 1862 1863 yyssp = yyss; 1864 yyvsp = yyvs; 1865 1866 goto yysetstate; 1867 1868 /*------------------------------------------------------------. 1869 | yynewstate -- Push a new state, which is found in yystate. | 1870 `------------------------------------------------------------*/ 1871 yynewstate: 1872 /* In all cases, when you get here, the value and location stacks 1873 have just been pushed. So pushing a state here evens the stacks. */ 1874 yyssp++; 1875 1876 yysetstate: 1877 *yyssp = yystate; 1878 1879 if (yyss + yystacksize - 1 <= yyssp) 1880 { 1881 /* Get the current used size of the three stacks, in elements. */ 1882 YYSIZE_T yysize = yyssp - yyss + 1; 1883 1884 #ifdef yyoverflow 1885 { 1886 /* Give user a chance to reallocate the stack. Use copies of 1887 these so that the &'s don't force the real ones into 1888 memory. */ 1889 YYSTYPE *yyvs1 = yyvs; 1890 yytype_int16 *yyss1 = yyss; 1891 1892 1893 /* Each stack pointer address is followed by the size of the 1894 data in use in that stack, in bytes. This used to be a 1895 conditional around just the two extra args, but that might 1896 be undefined if yyoverflow is a macro. */ 1897 yyoverflow (YY_("memory exhausted"), 1898 &yyss1, yysize * sizeof (*yyssp), 1899 &yyvs1, yysize * sizeof (*yyvsp), 1900 1901 &yystacksize); 1902 1903 yyss = yyss1; 1904 yyvs = yyvs1; 1905 } 1906 #else /* no yyoverflow */ 1907 # ifndef YYSTACK_RELOCATE 1908 goto yyexhaustedlab; 1909 # else 1910 /* Extend the stack our own way. */ 1911 if (YYMAXDEPTH <= yystacksize) 1912 goto yyexhaustedlab; 1913 yystacksize *= 2; 1914 if (YYMAXDEPTH < yystacksize) 1915 yystacksize = YYMAXDEPTH; 1916 1917 { 1918 yytype_int16 *yyss1 = yyss; 1919 union yyalloc *yyptr = 1920 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 1921 if (! yyptr) 1922 goto yyexhaustedlab; 1923 YYSTACK_RELOCATE (yyss); 1924 YYSTACK_RELOCATE (yyvs); 1925 1926 # undef YYSTACK_RELOCATE 1927 if (yyss1 != yyssa) 1928 YYSTACK_FREE (yyss1); 1929 } 1930 # endif 1931 #endif /* no yyoverflow */ 1932 1933 yyssp = yyss + yysize - 1; 1934 yyvsp = yyvs + yysize - 1; 1935 1936 1937 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 1938 (unsigned long int) yystacksize)); 1939 1940 if (yyss + yystacksize - 1 <= yyssp) 1941 YYABORT; 1942 } 1943 1944 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1945 1946 goto yybackup; 1947 1948 /*-----------. 1949 | yybackup. | 1950 `-----------*/ 1951 yybackup: 1952 1953 /* Do appropriate processing given the current state. Read a 1954 look-ahead token if we need one and don't already have one. */ 1955 1956 /* First try to decide what to do without reference to look-ahead token. */ 1957 yyn = yypact[yystate]; 1958 if (yyn == YYPACT_NINF) 1959 goto yydefault; 1960 1961 /* Not known => get a look-ahead token if don't already have one. */ 1962 1963 /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ 1964 if (yychar == YYEMPTY) 1965 { 1966 YYDPRINTF ((stderr, "Reading a token: ")); 1967 yychar = YYLEX; 1968 } 1969 1970 if (yychar <= YYEOF) 1971 { 1972 yychar = yytoken = YYEOF; 1973 YYDPRINTF ((stderr, "Now at end of input.\n")); 1974 } 1975 else 1976 { 1977 yytoken = YYTRANSLATE (yychar); 1978 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1979 } 1980 1981 /* If the proper action on seeing token YYTOKEN is to reduce or to 1982 detect an error, take that action. */ 1983 yyn += yytoken; 1984 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 1985 goto yydefault; 1986 yyn = yytable[yyn]; 1987 if (yyn <= 0) 1988 { 1989 if (yyn == 0 || yyn == YYTABLE_NINF) 1990 goto yyerrlab; 1991 yyn = -yyn; 1992 goto yyreduce; 1993 } 1994 1995 if (yyn == YYFINAL) 1996 YYACCEPT; 1997 1998 /* Count tokens shifted since error; after three, turn off error 1999 status. */ 2000 if (yyerrstatus) 2001 yyerrstatus--; 2002 2003 /* Shift the look-ahead token. */ 2004 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 2005 2006 /* Discard the shifted token unless it is eof. */ 2007 if (yychar != YYEOF) 2008 yychar = YYEMPTY; 2009 2010 yystate = yyn; 2011 *++yyvsp = yylval; 2012 2013 goto yynewstate; 2014 2015 2016 /*-----------------------------------------------------------. 2017 | yydefault -- do the default action for the current state. | 2018 `-----------------------------------------------------------*/ 2019 yydefault: 2020 yyn = yydefact[yystate]; 2021 if (yyn == 0) 2022 goto yyerrlab; 2023 goto yyreduce; 2024 2025 2026 /*-----------------------------. 2027 | yyreduce -- Do a reduction. | 2028 `-----------------------------*/ 2029 yyreduce: 2030 /* yyn is the number of a rule to reduce with. */ 2031 yylen = yyr2[yyn]; 2032 2033 /* If YYLEN is nonzero, implement the default value of the action: 2034 `$$ = $1'. 2035 2036 Otherwise, the following line sets YYVAL to garbage. 2037 This behavior is undocumented and Bison 2038 users should not rely upon it. Assigning to YYVAL 2039 unconditionally makes the parser a bit smaller, and it avoids a 2040 GCC warning that YYVAL may be used uninitialized. */ 2041 yyval = yyvsp[1-yylen]; 2042 2043 2044 YY_REDUCE_PRINT (yyn); 2045 switch (yyn) 2046 { 2047 case 4: 2048 #line 109 "cc.y" 2049 { 2050 dodecl(xdecl, lastclass, lasttype, Z); 2051 } 2052 break; 2053 2054 case 6: 2055 #line 114 "cc.y" 2056 { 2057 lastdcl = T; 2058 firstarg = S; 2059 dodecl(xdecl, lastclass, lasttype, (yyvsp[(2) - (2)].node)); 2060 if(lastdcl == T || lastdcl->etype != TFUNC) { 2061 diag((yyvsp[(2) - (2)].node), "not a function"); 2062 lastdcl = types[TFUNC]; 2063 } 2064 thisfn = lastdcl; 2065 markdcl(); 2066 firstdcl = dclstack; 2067 argmark((yyvsp[(2) - (2)].node), 0); 2068 } 2069 break; 2070 2071 case 7: 2072 #line 128 "cc.y" 2073 { 2074 argmark((yyvsp[(2) - (4)].node), 1); 2075 } 2076 break; 2077 2078 case 8: 2079 #line 132 "cc.y" 2080 { 2081 Node *n; 2082 2083 n = revertdcl(); 2084 if(n) 2085 (yyvsp[(6) - (6)].node) = new(OLIST, n, (yyvsp[(6) - (6)].node)); 2086 if(!debug['a'] && !debug['Z']) 2087 codgen((yyvsp[(6) - (6)].node), (yyvsp[(2) - (6)].node)); 2088 } 2089 break; 2090 2091 case 9: 2092 #line 144 "cc.y" 2093 { 2094 dodecl(xdecl, lastclass, lasttype, (yyvsp[(1) - (1)].node)); 2095 } 2096 break; 2097 2098 case 10: 2099 #line 148 "cc.y" 2100 { 2101 (yyvsp[(1) - (1)].node) = dodecl(xdecl, lastclass, lasttype, (yyvsp[(1) - (1)].node)); 2102 } 2103 break; 2104 2105 case 11: 2106 #line 152 "cc.y" 2107 { 2108 doinit((yyvsp[(1) - (4)].node)->sym, (yyvsp[(1) - (4)].node)->type, 0L, (yyvsp[(4) - (4)].node)); 2109 } 2110 break; 2111 2112 case 14: 2113 #line 160 "cc.y" 2114 { 2115 (yyval.node) = new(OIND, (yyvsp[(3) - (3)].node), Z); 2116 (yyval.node)->garb = simpleg((yyvsp[(2) - (3)].lval)); 2117 } 2118 break; 2119 2120 case 16: 2121 #line 168 "cc.y" 2122 { 2123 (yyval.node) = (yyvsp[(2) - (3)].node); 2124 } 2125 break; 2126 2127 case 17: 2128 #line 172 "cc.y" 2129 { 2130 (yyval.node) = new(OFUNC, (yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node)); 2131 } 2132 break; 2133 2134 case 18: 2135 #line 176 "cc.y" 2136 { 2137 (yyval.node) = new(OARRAY, (yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node)); 2138 } 2139 break; 2140 2141 case 19: 2142 #line 185 "cc.y" 2143 { 2144 (yyval.node) = dodecl(adecl, lastclass, lasttype, Z); 2145 } 2146 break; 2147 2148 case 20: 2149 #line 189 "cc.y" 2150 { 2151 (yyval.node) = (yyvsp[(2) - (3)].node); 2152 } 2153 break; 2154 2155 case 21: 2156 #line 195 "cc.y" 2157 { 2158 dodecl(adecl, lastclass, lasttype, (yyvsp[(1) - (1)].node)); 2159 (yyval.node) = Z; 2160 } 2161 break; 2162 2163 case 22: 2164 #line 200 "cc.y" 2165 { 2166 (yyvsp[(1) - (1)].node) = dodecl(adecl, lastclass, lasttype, (yyvsp[(1) - (1)].node)); 2167 } 2168 break; 2169 2170 case 23: 2171 #line 204 "cc.y" 2172 { 2173 int32 w; 2174 2175 w = (yyvsp[(1) - (4)].node)->sym->type->width; 2176 (yyval.node) = doinit((yyvsp[(1) - (4)].node)->sym, (yyvsp[(1) - (4)].node)->type, 0L, (yyvsp[(4) - (4)].node)); 2177 (yyval.node) = contig((yyvsp[(1) - (4)].node)->sym, (yyval.node), w); 2178 } 2179 break; 2180 2181 case 24: 2182 #line 212 "cc.y" 2183 { 2184 (yyval.node) = (yyvsp[(1) - (3)].node); 2185 if((yyvsp[(3) - (3)].node) != Z) { 2186 (yyval.node) = (yyvsp[(3) - (3)].node); 2187 if((yyvsp[(1) - (3)].node) != Z) 2188 (yyval.node) = new(OLIST, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 2189 } 2190 } 2191 break; 2192 2193 case 27: 2194 #line 229 "cc.y" 2195 { 2196 dodecl(pdecl, lastclass, lasttype, (yyvsp[(1) - (1)].node)); 2197 } 2198 break; 2199 2200 case 29: 2201 #line 239 "cc.y" 2202 { 2203 lasttype = (yyvsp[(1) - (1)].type); 2204 } 2205 break; 2206 2207 case 31: 2208 #line 244 "cc.y" 2209 { 2210 lasttype = (yyvsp[(2) - (2)].type); 2211 } 2212 break; 2213 2214 case 33: 2215 #line 250 "cc.y" 2216 { 2217 lastfield = 0; 2218 edecl(CXXX, lasttype, S); 2219 } 2220 break; 2221 2222 case 35: 2223 #line 258 "cc.y" 2224 { 2225 dodecl(edecl, CXXX, lasttype, (yyvsp[(1) - (1)].node)); 2226 } 2227 break; 2228 2229 case 37: 2230 #line 265 "cc.y" 2231 { 2232 lastbit = 0; 2233 firstbit = 1; 2234 } 2235 break; 2236 2237 case 38: 2238 #line 270 "cc.y" 2239 { 2240 (yyval.node) = new(OBIT, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 2241 } 2242 break; 2243 2244 case 39: 2245 #line 274 "cc.y" 2246 { 2247 (yyval.node) = new(OBIT, Z, (yyvsp[(2) - (2)].node)); 2248 } 2249 break; 2250 2251 case 40: 2252 #line 282 "cc.y" 2253 { 2254 (yyval.node) = (Z); 2255 } 2256 break; 2257 2258 case 42: 2259 #line 289 "cc.y" 2260 { 2261 (yyval.node) = new(OIND, (Z), Z); 2262 (yyval.node)->garb = simpleg((yyvsp[(2) - (2)].lval)); 2263 } 2264 break; 2265 2266 case 43: 2267 #line 294 "cc.y" 2268 { 2269 (yyval.node) = new(OIND, (yyvsp[(3) - (3)].node), Z); 2270 (yyval.node)->garb = simpleg((yyvsp[(2) - (3)].lval)); 2271 } 2272 break; 2273 2274 case 46: 2275 #line 303 "cc.y" 2276 { 2277 (yyval.node) = new(OFUNC, (yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node)); 2278 } 2279 break; 2280 2281 case 47: 2282 #line 307 "cc.y" 2283 { 2284 (yyval.node) = new(OARRAY, (yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node)); 2285 } 2286 break; 2287 2288 case 48: 2289 #line 313 "cc.y" 2290 { 2291 (yyval.node) = new(OFUNC, (Z), Z); 2292 } 2293 break; 2294 2295 case 49: 2296 #line 317 "cc.y" 2297 { 2298 (yyval.node) = new(OARRAY, (Z), (yyvsp[(2) - (3)].node)); 2299 } 2300 break; 2301 2302 case 50: 2303 #line 321 "cc.y" 2304 { 2305 (yyval.node) = (yyvsp[(2) - (3)].node); 2306 } 2307 break; 2308 2309 case 52: 2310 #line 328 "cc.y" 2311 { 2312 (yyval.node) = new(OINIT, invert((yyvsp[(2) - (3)].node)), Z); 2313 } 2314 break; 2315 2316 case 53: 2317 #line 334 "cc.y" 2318 { 2319 (yyval.node) = new(OARRAY, (yyvsp[(2) - (3)].node), Z); 2320 } 2321 break; 2322 2323 case 54: 2324 #line 338 "cc.y" 2325 { 2326 (yyval.node) = new(OELEM, Z, Z); 2327 (yyval.node)->sym = (yyvsp[(2) - (2)].sym); 2328 } 2329 break; 2330 2331 case 57: 2332 #line 347 "cc.y" 2333 { 2334 (yyval.node) = new(OLIST, (yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node)); 2335 } 2336 break; 2337 2338 case 59: 2339 #line 352 "cc.y" 2340 { 2341 (yyval.node) = new(OLIST, (yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node)); 2342 } 2343 break; 2344 2345 case 62: 2346 #line 360 "cc.y" 2347 { 2348 (yyval.node) = new(OLIST, (yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node)); 2349 } 2350 break; 2351 2352 case 63: 2353 #line 365 "cc.y" 2354 { 2355 (yyval.node) = Z; 2356 } 2357 break; 2358 2359 case 64: 2360 #line 369 "cc.y" 2361 { 2362 (yyval.node) = invert((yyvsp[(1) - (1)].node)); 2363 } 2364 break; 2365 2366 case 66: 2367 #line 377 "cc.y" 2368 { 2369 (yyval.node) = new(OPROTO, (yyvsp[(2) - (2)].node), Z); 2370 (yyval.node)->type = (yyvsp[(1) - (2)].type); 2371 } 2372 break; 2373 2374 case 67: 2375 #line 382 "cc.y" 2376 { 2377 (yyval.node) = new(OPROTO, (yyvsp[(2) - (2)].node), Z); 2378 (yyval.node)->type = (yyvsp[(1) - (2)].type); 2379 } 2380 break; 2381 2382 case 68: 2383 #line 387 "cc.y" 2384 { 2385 (yyval.node) = new(ODOTDOT, Z, Z); 2386 } 2387 break; 2388 2389 case 69: 2390 #line 391 "cc.y" 2391 { 2392 (yyval.node) = new(OLIST, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 2393 } 2394 break; 2395 2396 case 70: 2397 #line 397 "cc.y" 2398 { 2399 (yyval.node) = invert((yyvsp[(2) - (3)].node)); 2400 // if($2 != Z) 2401 // $$ = new(OLIST, $2, $$); 2402 if((yyval.node) == Z) 2403 (yyval.node) = new(OLIST, Z, Z); 2404 } 2405 break; 2406 2407 case 71: 2408 #line 406 "cc.y" 2409 { 2410 (yyval.node) = Z; 2411 } 2412 break; 2413 2414 case 72: 2415 #line 410 "cc.y" 2416 { 2417 (yyval.node) = new(OLIST, (yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node)); 2418 } 2419 break; 2420 2421 case 73: 2422 #line 414 "cc.y" 2423 { 2424 (yyval.node) = new(OLIST, (yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node)); 2425 } 2426 break; 2427 2428 case 75: 2429 #line 421 "cc.y" 2430 { 2431 (yyval.node) = new(OLIST, (yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node)); 2432 } 2433 break; 2434 2435 case 76: 2436 #line 427 "cc.y" 2437 { 2438 (yyval.node) = new(OCASE, (yyvsp[(2) - (3)].node), Z); 2439 } 2440 break; 2441 2442 case 77: 2443 #line 431 "cc.y" 2444 { 2445 (yyval.node) = new(OCASE, Z, Z); 2446 } 2447 break; 2448 2449 case 78: 2450 #line 435 "cc.y" 2451 { 2452 (yyval.node) = new(OLABEL, dcllabel((yyvsp[(1) - (2)].sym), 1), Z); 2453 } 2454 break; 2455 2456 case 79: 2457 #line 441 "cc.y" 2458 { 2459 (yyval.node) = Z; 2460 } 2461 break; 2462 2463 case 81: 2464 #line 446 "cc.y" 2465 { 2466 (yyval.node) = new(OLIST, (yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node)); 2467 } 2468 break; 2469 2470 case 83: 2471 #line 453 "cc.y" 2472 { 2473 (yyval.node) = (yyvsp[(2) - (2)].node); 2474 } 2475 break; 2476 2477 case 85: 2478 #line 459 "cc.y" 2479 { 2480 markdcl(); 2481 } 2482 break; 2483 2484 case 86: 2485 #line 463 "cc.y" 2486 { 2487 (yyval.node) = revertdcl(); 2488 if((yyval.node)) 2489 (yyval.node) = new(OLIST, (yyval.node), (yyvsp[(2) - (2)].node)); 2490 else 2491 (yyval.node) = (yyvsp[(2) - (2)].node); 2492 } 2493 break; 2494 2495 case 87: 2496 #line 471 "cc.y" 2497 { 2498 (yyval.node) = new(OIF, (yyvsp[(3) - (5)].node), new(OLIST, (yyvsp[(5) - (5)].node), Z)); 2499 if((yyvsp[(5) - (5)].node) == Z) 2500 warn((yyvsp[(3) - (5)].node), "empty if body"); 2501 } 2502 break; 2503 2504 case 88: 2505 #line 477 "cc.y" 2506 { 2507 (yyval.node) = new(OIF, (yyvsp[(3) - (7)].node), new(OLIST, (yyvsp[(5) - (7)].node), (yyvsp[(7) - (7)].node))); 2508 if((yyvsp[(5) - (7)].node) == Z) 2509 warn((yyvsp[(3) - (7)].node), "empty if body"); 2510 if((yyvsp[(7) - (7)].node) == Z) 2511 warn((yyvsp[(3) - (7)].node), "empty else body"); 2512 } 2513 break; 2514 2515 case 89: 2516 #line 484 "cc.y" 2517 { markdcl(); } 2518 break; 2519 2520 case 90: 2521 #line 485 "cc.y" 2522 { 2523 (yyval.node) = revertdcl(); 2524 if((yyval.node)){ 2525 if((yyvsp[(4) - (10)].node)) 2526 (yyvsp[(4) - (10)].node) = new(OLIST, (yyval.node), (yyvsp[(4) - (10)].node)); 2527 else 2528 (yyvsp[(4) - (10)].node) = (yyval.node); 2529 } 2530 (yyval.node) = new(OFOR, new(OLIST, (yyvsp[(6) - (10)].node), new(OLIST, (yyvsp[(4) - (10)].node), (yyvsp[(8) - (10)].node))), (yyvsp[(10) - (10)].node)); 2531 } 2532 break; 2533 2534 case 91: 2535 #line 496 "cc.y" 2536 { 2537 (yyval.node) = new(OWHILE, (yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node)); 2538 } 2539 break; 2540 2541 case 92: 2542 #line 500 "cc.y" 2543 { 2544 (yyval.node) = new(ODWHILE, (yyvsp[(5) - (7)].node), (yyvsp[(2) - (7)].node)); 2545 } 2546 break; 2547 2548 case 93: 2549 #line 504 "cc.y" 2550 { 2551 (yyval.node) = new(ORETURN, (yyvsp[(2) - (3)].node), Z); 2552 (yyval.node)->type = thisfn->link; 2553 } 2554 break; 2555 2556 case 94: 2557 #line 509 "cc.y" 2558 { 2559 (yyval.node) = new(OCONST, Z, Z); 2560 (yyval.node)->vconst = 0; 2561 (yyval.node)->type = types[TINT]; 2562 (yyvsp[(3) - (5)].node) = new(OSUB, (yyval.node), (yyvsp[(3) - (5)].node)); 2563 2564 (yyval.node) = new(OCONST, Z, Z); 2565 (yyval.node)->vconst = 0; 2566 (yyval.node)->type = types[TINT]; 2567 (yyvsp[(3) - (5)].node) = new(OSUB, (yyval.node), (yyvsp[(3) - (5)].node)); 2568 2569 (yyval.node) = new(OSWITCH, (yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node)); 2570 } 2571 break; 2572 2573 case 95: 2574 #line 523 "cc.y" 2575 { 2576 (yyval.node) = new(OBREAK, Z, Z); 2577 } 2578 break; 2579 2580 case 96: 2581 #line 527 "cc.y" 2582 { 2583 (yyval.node) = new(OCONTINUE, Z, Z); 2584 } 2585 break; 2586 2587 case 97: 2588 #line 531 "cc.y" 2589 { 2590 (yyval.node) = new(OGOTO, dcllabel((yyvsp[(2) - (3)].sym), 0), Z); 2591 } 2592 break; 2593 2594 case 98: 2595 #line 535 "cc.y" 2596 { 2597 (yyval.node) = new(OUSED, (yyvsp[(3) - (5)].node), Z); 2598 } 2599 break; 2600 2601 case 99: 2602 #line 539 "cc.y" 2603 { 2604 (yyval.node) = new(OPREFETCH, (yyvsp[(3) - (5)].node), Z); 2605 } 2606 break; 2607 2608 case 100: 2609 #line 543 "cc.y" 2610 { 2611 (yyval.node) = new(OSET, (yyvsp[(3) - (5)].node), Z); 2612 } 2613 break; 2614 2615 case 101: 2616 #line 548 "cc.y" 2617 { 2618 (yyval.node) = Z; 2619 } 2620 break; 2621 2622 case 103: 2623 #line 554 "cc.y" 2624 { 2625 (yyval.node) = Z; 2626 } 2627 break; 2628 2629 case 105: 2630 #line 561 "cc.y" 2631 { 2632 (yyval.node) = new(OCAST, (yyvsp[(1) - (1)].node), Z); 2633 (yyval.node)->type = types[TLONG]; 2634 } 2635 break; 2636 2637 case 107: 2638 #line 569 "cc.y" 2639 { 2640 (yyval.node) = new(OCOMMA, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 2641 } 2642 break; 2643 2644 case 109: 2645 #line 576 "cc.y" 2646 { 2647 (yyval.node) = new(OMUL, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 2648 } 2649 break; 2650 2651 case 110: 2652 #line 580 "cc.y" 2653 { 2654 (yyval.node) = new(ODIV, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 2655 } 2656 break; 2657 2658 case 111: 2659 #line 584 "cc.y" 2660 { 2661 (yyval.node) = new(OMOD, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 2662 } 2663 break; 2664 2665 case 112: 2666 #line 588 "cc.y" 2667 { 2668 (yyval.node) = new(OADD, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 2669 } 2670 break; 2671 2672 case 113: 2673 #line 592 "cc.y" 2674 { 2675 (yyval.node) = new(OSUB, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 2676 } 2677 break; 2678 2679 case 114: 2680 #line 596 "cc.y" 2681 { 2682 (yyval.node) = new(OASHR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 2683 } 2684 break; 2685 2686 case 115: 2687 #line 600 "cc.y" 2688 { 2689 (yyval.node) = new(OASHL, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 2690 } 2691 break; 2692 2693 case 116: 2694 #line 604 "cc.y" 2695 { 2696 (yyval.node) = new(OLT, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 2697 } 2698 break; 2699 2700 case 117: 2701 #line 608 "cc.y" 2702 { 2703 (yyval.node) = new(OGT, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 2704 } 2705 break; 2706 2707 case 118: 2708 #line 612 "cc.y" 2709 { 2710 (yyval.node) = new(OLE, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 2711 } 2712 break; 2713 2714 case 119: 2715 #line 616 "cc.y" 2716 { 2717 (yyval.node) = new(OGE, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 2718 } 2719 break; 2720 2721 case 120: 2722 #line 620 "cc.y" 2723 { 2724 (yyval.node) = new(OEQ, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 2725 } 2726 break; 2727 2728 case 121: 2729 #line 624 "cc.y" 2730 { 2731 (yyval.node) = new(ONE, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 2732 } 2733 break; 2734 2735 case 122: 2736 #line 628 "cc.y" 2737 { 2738 (yyval.node) = new(OAND, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 2739 } 2740 break; 2741 2742 case 123: 2743 #line 632 "cc.y" 2744 { 2745 (yyval.node) = new(OXOR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 2746 } 2747 break; 2748 2749 case 124: 2750 #line 636 "cc.y" 2751 { 2752 (yyval.node) = new(OOR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 2753 } 2754 break; 2755 2756 case 125: 2757 #line 640 "cc.y" 2758 { 2759 (yyval.node) = new(OANDAND, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 2760 } 2761 break; 2762 2763 case 126: 2764 #line 644 "cc.y" 2765 { 2766 (yyval.node) = new(OOROR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 2767 } 2768 break; 2769 2770 case 127: 2771 #line 648 "cc.y" 2772 { 2773 (yyval.node) = new(OCOND, (yyvsp[(1) - (5)].node), new(OLIST, (yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node))); 2774 } 2775 break; 2776 2777 case 128: 2778 #line 652 "cc.y" 2779 { 2780 (yyval.node) = new(OAS, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 2781 } 2782 break; 2783 2784 case 129: 2785 #line 656 "cc.y" 2786 { 2787 (yyval.node) = new(OASADD, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 2788 } 2789 break; 2790 2791 case 130: 2792 #line 660 "cc.y" 2793 { 2794 (yyval.node) = new(OASSUB, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 2795 } 2796 break; 2797 2798 case 131: 2799 #line 664 "cc.y" 2800 { 2801 (yyval.node) = new(OASMUL, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 2802 } 2803 break; 2804 2805 case 132: 2806 #line 668 "cc.y" 2807 { 2808 (yyval.node) = new(OASDIV, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 2809 } 2810 break; 2811 2812 case 133: 2813 #line 672 "cc.y" 2814 { 2815 (yyval.node) = new(OASMOD, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 2816 } 2817 break; 2818 2819 case 134: 2820 #line 676 "cc.y" 2821 { 2822 (yyval.node) = new(OASASHL, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 2823 } 2824 break; 2825 2826 case 135: 2827 #line 680 "cc.y" 2828 { 2829 (yyval.node) = new(OASASHR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 2830 } 2831 break; 2832 2833 case 136: 2834 #line 684 "cc.y" 2835 { 2836 (yyval.node) = new(OASAND, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 2837 } 2838 break; 2839 2840 case 137: 2841 #line 688 "cc.y" 2842 { 2843 (yyval.node) = new(OASXOR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 2844 } 2845 break; 2846 2847 case 138: 2848 #line 692 "cc.y" 2849 { 2850 (yyval.node) = new(OASOR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 2851 } 2852 break; 2853 2854 case 140: 2855 #line 699 "cc.y" 2856 { 2857 (yyval.node) = new(OCAST, (yyvsp[(5) - (5)].node), Z); 2858 dodecl(NODECL, CXXX, (yyvsp[(2) - (5)].type), (yyvsp[(3) - (5)].node)); 2859 (yyval.node)->type = lastdcl; 2860 (yyval.node)->xcast = 1; 2861 } 2862 break; 2863 2864 case 141: 2865 #line 706 "cc.y" 2866 { 2867 (yyval.node) = new(OSTRUCT, (yyvsp[(6) - (7)].node), Z); 2868 dodecl(NODECL, CXXX, (yyvsp[(2) - (7)].type), (yyvsp[(3) - (7)].node)); 2869 (yyval.node)->type = lastdcl; 2870 } 2871 break; 2872 2873 case 143: 2874 #line 715 "cc.y" 2875 { 2876 (yyval.node) = new(OIND, (yyvsp[(2) - (2)].node), Z); 2877 } 2878 break; 2879 2880 case 144: 2881 #line 719 "cc.y" 2882 { 2883 (yyval.node) = new(OADDR, (yyvsp[(2) - (2)].node), Z); 2884 } 2885 break; 2886 2887 case 145: 2888 #line 723 "cc.y" 2889 { 2890 (yyval.node) = new(OPOS, (yyvsp[(2) - (2)].node), Z); 2891 } 2892 break; 2893 2894 case 146: 2895 #line 727 "cc.y" 2896 { 2897 (yyval.node) = new(ONEG, (yyvsp[(2) - (2)].node), Z); 2898 } 2899 break; 2900 2901 case 147: 2902 #line 731 "cc.y" 2903 { 2904 (yyval.node) = new(ONOT, (yyvsp[(2) - (2)].node), Z); 2905 } 2906 break; 2907 2908 case 148: 2909 #line 735 "cc.y" 2910 { 2911 (yyval.node) = new(OCOM, (yyvsp[(2) - (2)].node), Z); 2912 } 2913 break; 2914 2915 case 149: 2916 #line 739 "cc.y" 2917 { 2918 (yyval.node) = new(OPREINC, (yyvsp[(2) - (2)].node), Z); 2919 } 2920 break; 2921 2922 case 150: 2923 #line 743 "cc.y" 2924 { 2925 (yyval.node) = new(OPREDEC, (yyvsp[(2) - (2)].node), Z); 2926 } 2927 break; 2928 2929 case 151: 2930 #line 747 "cc.y" 2931 { 2932 (yyval.node) = new(OSIZE, (yyvsp[(2) - (2)].node), Z); 2933 } 2934 break; 2935 2936 case 152: 2937 #line 751 "cc.y" 2938 { 2939 (yyval.node) = new(OSIGN, (yyvsp[(2) - (2)].node), Z); 2940 } 2941 break; 2942 2943 case 153: 2944 #line 757 "cc.y" 2945 { 2946 (yyval.node) = (yyvsp[(2) - (3)].node); 2947 } 2948 break; 2949 2950 case 154: 2951 #line 761 "cc.y" 2952 { 2953 (yyval.node) = new(OSIZE, Z, Z); 2954 dodecl(NODECL, CXXX, (yyvsp[(3) - (5)].type), (yyvsp[(4) - (5)].node)); 2955 (yyval.node)->type = lastdcl; 2956 } 2957 break; 2958 2959 case 155: 2960 #line 767 "cc.y" 2961 { 2962 (yyval.node) = new(OSIGN, Z, Z); 2963 dodecl(NODECL, CXXX, (yyvsp[(3) - (5)].type), (yyvsp[(4) - (5)].node)); 2964 (yyval.node)->type = lastdcl; 2965 } 2966 break; 2967 2968 case 156: 2969 #line 773 "cc.y" 2970 { 2971 (yyval.node) = new(OFUNC, (yyvsp[(1) - (4)].node), Z); 2972 if((yyvsp[(1) - (4)].node)->op == ONAME) 2973 if((yyvsp[(1) - (4)].node)->type == T) 2974 dodecl(xdecl, CXXX, types[TINT], (yyval.node)); 2975 (yyval.node)->right = invert((yyvsp[(3) - (4)].node)); 2976 } 2977 break; 2978 2979 case 157: 2980 #line 781 "cc.y" 2981 { 2982 (yyval.node) = new(OIND, new(OADD, (yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node)), Z); 2983 } 2984 break; 2985 2986 case 158: 2987 #line 785 "cc.y" 2988 { 2989 (yyval.node) = new(ODOT, new(OIND, (yyvsp[(1) - (3)].node), Z), Z); 2990 (yyval.node)->sym = (yyvsp[(3) - (3)].sym); 2991 } 2992 break; 2993 2994 case 159: 2995 #line 790 "cc.y" 2996 { 2997 (yyval.node) = new(ODOT, (yyvsp[(1) - (3)].node), Z); 2998 (yyval.node)->sym = (yyvsp[(3) - (3)].sym); 2999 } 3000 break; 3001 3002 case 160: 3003 #line 795 "cc.y" 3004 { 3005 (yyval.node) = new(OPOSTINC, (yyvsp[(1) - (2)].node), Z); 3006 } 3007 break; 3008 3009 case 161: 3010 #line 799 "cc.y" 3011 { 3012 (yyval.node) = new(OPOSTDEC, (yyvsp[(1) - (2)].node), Z); 3013 } 3014 break; 3015 3016 case 163: 3017 #line 804 "cc.y" 3018 { 3019 (yyval.node) = new(OCONST, Z, Z); 3020 (yyval.node)->type = types[TINT]; 3021 (yyval.node)->vconst = (yyvsp[(1) - (1)].vval); 3022 (yyval.node)->cstring = strdup(symb); 3023 } 3024 break; 3025 3026 case 164: 3027 #line 811 "cc.y" 3028 { 3029 (yyval.node) = new(OCONST, Z, Z); 3030 (yyval.node)->type = types[TLONG]; 3031 (yyval.node)->vconst = (yyvsp[(1) - (1)].vval); 3032 (yyval.node)->cstring = strdup(symb); 3033 } 3034 break; 3035 3036 case 165: 3037 #line 818 "cc.y" 3038 { 3039 (yyval.node) = new(OCONST, Z, Z); 3040 (yyval.node)->type = types[TUINT]; 3041 (yyval.node)->vconst = (yyvsp[(1) - (1)].vval); 3042 (yyval.node)->cstring = strdup(symb); 3043 } 3044 break; 3045 3046 case 166: 3047 #line 825 "cc.y" 3048 { 3049 (yyval.node) = new(OCONST, Z, Z); 3050 (yyval.node)->type = types[TULONG]; 3051 (yyval.node)->vconst = (yyvsp[(1) - (1)].vval); 3052 (yyval.node)->cstring = strdup(symb); 3053 } 3054 break; 3055 3056 case 167: 3057 #line 832 "cc.y" 3058 { 3059 (yyval.node) = new(OCONST, Z, Z); 3060 (yyval.node)->type = types[TDOUBLE]; 3061 (yyval.node)->fconst = (yyvsp[(1) - (1)].dval); 3062 (yyval.node)->cstring = strdup(symb); 3063 } 3064 break; 3065 3066 case 168: 3067 #line 839 "cc.y" 3068 { 3069 (yyval.node) = new(OCONST, Z, Z); 3070 (yyval.node)->type = types[TFLOAT]; 3071 (yyval.node)->fconst = (yyvsp[(1) - (1)].dval); 3072 (yyval.node)->cstring = strdup(symb); 3073 } 3074 break; 3075 3076 case 169: 3077 #line 846 "cc.y" 3078 { 3079 (yyval.node) = new(OCONST, Z, Z); 3080 (yyval.node)->type = types[TVLONG]; 3081 (yyval.node)->vconst = (yyvsp[(1) - (1)].vval); 3082 (yyval.node)->cstring = strdup(symb); 3083 } 3084 break; 3085 3086 case 170: 3087 #line 853 "cc.y" 3088 { 3089 (yyval.node) = new(OCONST, Z, Z); 3090 (yyval.node)->type = types[TUVLONG]; 3091 (yyval.node)->vconst = (yyvsp[(1) - (1)].vval); 3092 (yyval.node)->cstring = strdup(symb); 3093 } 3094 break; 3095 3096 case 173: 3097 #line 864 "cc.y" 3098 { 3099 (yyval.node) = new(OSTRING, Z, Z); 3100 (yyval.node)->type = typ(TARRAY, types[TCHAR]); 3101 (yyval.node)->type->width = (yyvsp[(1) - (1)].sval).l + 1; 3102 (yyval.node)->cstring = (yyvsp[(1) - (1)].sval).s; 3103 (yyval.node)->sym = symstring; 3104 (yyval.node)->etype = TARRAY; 3105 (yyval.node)->class = CSTATIC; 3106 } 3107 break; 3108 3109 case 174: 3110 #line 874 "cc.y" 3111 { 3112 char *s; 3113 int n; 3114 3115 n = (yyvsp[(1) - (2)].node)->type->width - 1; 3116 s = alloc(n+(yyvsp[(2) - (2)].sval).l+MAXALIGN); 3117 3118 memcpy(s, (yyvsp[(1) - (2)].node)->cstring, n); 3119 memcpy(s+n, (yyvsp[(2) - (2)].sval).s, (yyvsp[(2) - (2)].sval).l); 3120 s[n+(yyvsp[(2) - (2)].sval).l] = 0; 3121 3122 (yyval.node) = (yyvsp[(1) - (2)].node); 3123 (yyval.node)->type->width += (yyvsp[(2) - (2)].sval).l; 3124 (yyval.node)->cstring = s; 3125 } 3126 break; 3127 3128 case 175: 3129 #line 892 "cc.y" 3130 { 3131 (yyval.node) = new(OLSTRING, Z, Z); 3132 (yyval.node)->type = typ(TARRAY, types[TRUNE]); 3133 (yyval.node)->type->width = (yyvsp[(1) - (1)].sval).l + sizeof(TRune); 3134 (yyval.node)->rstring = (TRune*)(yyvsp[(1) - (1)].sval).s; 3135 (yyval.node)->sym = symstring; 3136 (yyval.node)->etype = TARRAY; 3137 (yyval.node)->class = CSTATIC; 3138 } 3139 break; 3140 3141 case 176: 3142 #line 902 "cc.y" 3143 { 3144 char *s; 3145 int n; 3146 3147 n = (yyvsp[(1) - (2)].node)->type->width - sizeof(TRune); 3148 s = alloc(n+(yyvsp[(2) - (2)].sval).l+MAXALIGN); 3149 3150 memcpy(s, (yyvsp[(1) - (2)].node)->rstring, n); 3151 memcpy(s+n, (yyvsp[(2) - (2)].sval).s, (yyvsp[(2) - (2)].sval).l); 3152 *(TRune*)(s+n+(yyvsp[(2) - (2)].sval).l) = 0; 3153 3154 (yyval.node) = (yyvsp[(1) - (2)].node); 3155 (yyval.node)->type->width += (yyvsp[(2) - (2)].sval).l; 3156 (yyval.node)->rstring = (TRune*)s; 3157 } 3158 break; 3159 3160 case 177: 3161 #line 919 "cc.y" 3162 { 3163 (yyval.node) = Z; 3164 } 3165 break; 3166 3167 case 180: 3168 #line 927 "cc.y" 3169 { 3170 (yyval.node) = new(OLIST, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 3171 } 3172 break; 3173 3174 case 181: 3175 #line 933 "cc.y" 3176 { 3177 (yyval.tyty).t1 = strf; 3178 (yyval.tyty).t2 = strl; 3179 (yyval.tyty).t3 = lasttype; 3180 (yyval.tyty).c = lastclass; 3181 strf = T; 3182 strl = T; 3183 lastbit = 0; 3184 firstbit = 1; 3185 lastclass = CXXX; 3186 lasttype = T; 3187 } 3188 break; 3189 3190 case 182: 3191 #line 946 "cc.y" 3192 { 3193 (yyval.type) = strf; 3194 strf = (yyvsp[(2) - (4)].tyty).t1; 3195 strl = (yyvsp[(2) - (4)].tyty).t2; 3196 lasttype = (yyvsp[(2) - (4)].tyty).t3; 3197 lastclass = (yyvsp[(2) - (4)].tyty).c; 3198 } 3199 break; 3200 3201 case 183: 3202 #line 955 "cc.y" 3203 { 3204 lastclass = CXXX; 3205 lasttype = types[TINT]; 3206 } 3207 break; 3208 3209 case 185: 3210 #line 963 "cc.y" 3211 { 3212 (yyval.tycl).t = (yyvsp[(1) - (1)].type); 3213 (yyval.tycl).c = CXXX; 3214 } 3215 break; 3216 3217 case 186: 3218 #line 968 "cc.y" 3219 { 3220 (yyval.tycl).t = simplet((yyvsp[(1) - (1)].lval)); 3221 (yyval.tycl).c = CXXX; 3222 } 3223 break; 3224 3225 case 187: 3226 #line 973 "cc.y" 3227 { 3228 (yyval.tycl).t = simplet((yyvsp[(1) - (1)].lval)); 3229 (yyval.tycl).c = simplec((yyvsp[(1) - (1)].lval)); 3230 (yyval.tycl).t = garbt((yyval.tycl).t, (yyvsp[(1) - (1)].lval)); 3231 } 3232 break; 3233 3234 case 188: 3235 #line 979 "cc.y" 3236 { 3237 (yyval.tycl).t = (yyvsp[(1) - (2)].type); 3238 (yyval.tycl).c = simplec((yyvsp[(2) - (2)].lval)); 3239 (yyval.tycl).t = garbt((yyval.tycl).t, (yyvsp[(2) - (2)].lval)); 3240 if((yyvsp[(2) - (2)].lval) & ~BCLASS & ~BGARB) 3241 diag(Z, "duplicate types given: %T and %Q", (yyvsp[(1) - (2)].type), (yyvsp[(2) - (2)].lval)); 3242 } 3243 break; 3244 3245 case 189: 3246 #line 987 "cc.y" 3247 { 3248 (yyval.tycl).t = simplet(typebitor((yyvsp[(1) - (2)].lval), (yyvsp[(2) - (2)].lval))); 3249 (yyval.tycl).c = simplec((yyvsp[(2) - (2)].lval)); 3250 (yyval.tycl).t = garbt((yyval.tycl).t, (yyvsp[(2) - (2)].lval)); 3251 } 3252 break; 3253 3254 case 190: 3255 #line 993 "cc.y" 3256 { 3257 (yyval.tycl).t = (yyvsp[(2) - (3)].type); 3258 (yyval.tycl).c = simplec((yyvsp[(1) - (3)].lval)); 3259 (yyval.tycl).t = garbt((yyval.tycl).t, (yyvsp[(1) - (3)].lval)|(yyvsp[(3) - (3)].lval)); 3260 } 3261 break; 3262 3263 case 191: 3264 #line 999 "cc.y" 3265 { 3266 (yyval.tycl).t = simplet((yyvsp[(2) - (2)].lval)); 3267 (yyval.tycl).c = simplec((yyvsp[(1) - (2)].lval)); 3268 (yyval.tycl).t = garbt((yyval.tycl).t, (yyvsp[(1) - (2)].lval)); 3269 } 3270 break; 3271 3272 case 192: 3273 #line 1005 "cc.y" 3274 { 3275 (yyval.tycl).t = simplet(typebitor((yyvsp[(2) - (3)].lval), (yyvsp[(3) - (3)].lval))); 3276 (yyval.tycl).c = simplec((yyvsp[(1) - (3)].lval)|(yyvsp[(3) - (3)].lval)); 3277 (yyval.tycl).t = garbt((yyval.tycl).t, (yyvsp[(1) - (3)].lval)|(yyvsp[(3) - (3)].lval)); 3278 } 3279 break; 3280 3281 case 193: 3282 #line 1013 "cc.y" 3283 { 3284 (yyval.type) = (yyvsp[(1) - (1)].tycl).t; 3285 if((yyvsp[(1) - (1)].tycl).c != CXXX) 3286 diag(Z, "illegal combination of class 4: %s", cnames[(yyvsp[(1) - (1)].tycl).c]); 3287 } 3288 break; 3289 3290 case 194: 3291 #line 1021 "cc.y" 3292 { 3293 lasttype = (yyvsp[(1) - (1)].tycl).t; 3294 lastclass = (yyvsp[(1) - (1)].tycl).c; 3295 } 3296 break; 3297 3298 case 195: 3299 #line 1028 "cc.y" 3300 { 3301 dotag((yyvsp[(2) - (2)].sym), TSTRUCT, 0); 3302 (yyval.type) = (yyvsp[(2) - (2)].sym)->suetag; 3303 } 3304 break; 3305 3306 case 196: 3307 #line 1033 "cc.y" 3308 { 3309 dotag((yyvsp[(2) - (2)].sym), TSTRUCT, autobn); 3310 } 3311 break; 3312 3313 case 197: 3314 #line 1037 "cc.y" 3315 { 3316 (yyval.type) = (yyvsp[(2) - (4)].sym)->suetag; 3317 if((yyval.type)->link != T) 3318 diag(Z, "redeclare tag: %s", (yyvsp[(2) - (4)].sym)->name); 3319 (yyval.type)->link = (yyvsp[(4) - (4)].type); 3320 sualign((yyval.type)); 3321 } 3322 break; 3323 3324 case 198: 3325 #line 1045 "cc.y" 3326 { 3327 diag(Z, "struct must have tag"); 3328 taggen++; 3329 sprint(symb, "_%d_", taggen); 3330 (yyval.type) = dotag(lookup(), TSTRUCT, autobn); 3331 (yyval.type)->link = (yyvsp[(2) - (2)].type); 3332 sualign((yyval.type)); 3333 } 3334 break; 3335 3336 case 199: 3337 #line 1054 "cc.y" 3338 { 3339 dotag((yyvsp[(2) - (2)].sym), TUNION, 0); 3340 (yyval.type) = (yyvsp[(2) - (2)].sym)->suetag; 3341 } 3342 break; 3343 3344 case 200: 3345 #line 1059 "cc.y" 3346 { 3347 dotag((yyvsp[(2) - (2)].sym), TUNION, autobn); 3348 } 3349 break; 3350 3351 case 201: 3352 #line 1063 "cc.y" 3353 { 3354 (yyval.type) = (yyvsp[(2) - (4)].sym)->suetag; 3355 if((yyval.type)->link != T) 3356 diag(Z, "redeclare tag: %s", (yyvsp[(2) - (4)].sym)->name); 3357 (yyval.type)->link = (yyvsp[(4) - (4)].type); 3358 sualign((yyval.type)); 3359 } 3360 break; 3361 3362 case 202: 3363 #line 1071 "cc.y" 3364 { 3365 taggen++; 3366 sprint(symb, "_%d_", taggen); 3367 (yyval.type) = dotag(lookup(), TUNION, autobn); 3368 (yyval.type)->link = (yyvsp[(2) - (2)].type); 3369 sualign((yyval.type)); 3370 } 3371 break; 3372 3373 case 203: 3374 #line 1079 "cc.y" 3375 { 3376 dotag((yyvsp[(2) - (2)].sym), TENUM, 0); 3377 (yyval.type) = (yyvsp[(2) - (2)].sym)->suetag; 3378 if((yyval.type)->link == T) 3379 (yyval.type)->link = types[TINT]; 3380 (yyval.type) = (yyval.type)->link; 3381 } 3382 break; 3383 3384 case 204: 3385 #line 1087 "cc.y" 3386 { 3387 dotag((yyvsp[(2) - (2)].sym), TENUM, autobn); 3388 } 3389 break; 3390 3391 case 205: 3392 #line 1091 "cc.y" 3393 { 3394 en.tenum = T; 3395 en.cenum = T; 3396 } 3397 break; 3398 3399 case 206: 3400 #line 1096 "cc.y" 3401 { 3402 (yyval.type) = (yyvsp[(2) - (7)].sym)->suetag; 3403 if((yyval.type)->link != T) 3404 diag(Z, "redeclare tag: %s", (yyvsp[(2) - (7)].sym)->name); 3405 if(en.tenum == T) { 3406 diag(Z, "enum type ambiguous: %s", (yyvsp[(2) - (7)].sym)->name); 3407 en.tenum = types[TINT]; 3408 } 3409 (yyval.type)->link = en.tenum; 3410 (yyval.type) = en.tenum; 3411 } 3412 break; 3413 3414 case 207: 3415 #line 1108 "cc.y" 3416 { 3417 en.tenum = T; 3418 en.cenum = T; 3419 } 3420 break; 3421 3422 case 208: 3423 #line 1113 "cc.y" 3424 { 3425 (yyval.type) = en.tenum; 3426 } 3427 break; 3428 3429 case 209: 3430 #line 1117 "cc.y" 3431 { 3432 (yyval.type) = tcopy((yyvsp[(1) - (1)].sym)->type); 3433 } 3434 break; 3435 3436 case 211: 3437 #line 1124 "cc.y" 3438 { 3439 (yyval.lval) = typebitor((yyvsp[(1) - (2)].lval), (yyvsp[(2) - (2)].lval)); 3440 } 3441 break; 3442 3443 case 212: 3444 #line 1129 "cc.y" 3445 { 3446 (yyval.lval) = 0; 3447 } 3448 break; 3449 3450 case 213: 3451 #line 1133 "cc.y" 3452 { 3453 (yyval.lval) = typebitor((yyvsp[(1) - (2)].lval), (yyvsp[(2) - (2)].lval)); 3454 } 3455 break; 3456 3457 case 218: 3458 #line 1145 "cc.y" 3459 { 3460 (yyval.lval) = typebitor((yyvsp[(1) - (2)].lval), (yyvsp[(2) - (2)].lval)); 3461 } 3462 break; 3463 3464 case 221: 3465 #line 1155 "cc.y" 3466 { 3467 doenum((yyvsp[(1) - (1)].sym), Z); 3468 } 3469 break; 3470 3471 case 222: 3472 #line 1159 "cc.y" 3473 { 3474 doenum((yyvsp[(1) - (3)].sym), (yyvsp[(3) - (3)].node)); 3475 } 3476 break; 3477 3478 case 225: 3479 #line 1166 "cc.y" 3480 { (yyval.lval) = BCHAR; } 3481 break; 3482 3483 case 226: 3484 #line 1167 "cc.y" 3485 { (yyval.lval) = BSHORT; } 3486 break; 3487 3488 case 227: 3489 #line 1168 "cc.y" 3490 { (yyval.lval) = BINT; } 3491 break; 3492 3493 case 228: 3494 #line 1169 "cc.y" 3495 { (yyval.lval) = BLONG; } 3496 break; 3497 3498 case 229: 3499 #line 1170 "cc.y" 3500 { (yyval.lval) = BSIGNED; } 3501 break; 3502 3503 case 230: 3504 #line 1171 "cc.y" 3505 { (yyval.lval) = BUNSIGNED; } 3506 break; 3507 3508 case 231: 3509 #line 1172 "cc.y" 3510 { (yyval.lval) = BFLOAT; } 3511 break; 3512 3513 case 232: 3514 #line 1173 "cc.y" 3515 { (yyval.lval) = BDOUBLE; } 3516 break; 3517 3518 case 233: 3519 #line 1174 "cc.y" 3520 { (yyval.lval) = BVOID; } 3521 break; 3522 3523 case 234: 3524 #line 1177 "cc.y" 3525 { (yyval.lval) = BAUTO; } 3526 break; 3527 3528 case 235: 3529 #line 1178 "cc.y" 3530 { (yyval.lval) = BSTATIC; } 3531 break; 3532 3533 case 236: 3534 #line 1179 "cc.y" 3535 { (yyval.lval) = BEXTERN; } 3536 break; 3537 3538 case 237: 3539 #line 1180 "cc.y" 3540 { (yyval.lval) = BTYPEDEF; } 3541 break; 3542 3543 case 238: 3544 #line 1181 "cc.y" 3545 { (yyval.lval) = BTYPESTR; } 3546 break; 3547 3548 case 239: 3549 #line 1182 "cc.y" 3550 { (yyval.lval) = BREGISTER; } 3551 break; 3552 3553 case 240: 3554 #line 1183 "cc.y" 3555 { (yyval.lval) = 0; } 3556 break; 3557 3558 case 241: 3559 #line 1186 "cc.y" 3560 { (yyval.lval) = BCONSTNT; } 3561 break; 3562 3563 case 242: 3564 #line 1187 "cc.y" 3565 { (yyval.lval) = BVOLATILE; } 3566 break; 3567 3568 case 243: 3569 #line 1188 "cc.y" 3570 { (yyval.lval) = 0; } 3571 break; 3572 3573 case 244: 3574 #line 1192 "cc.y" 3575 { 3576 (yyval.node) = new(ONAME, Z, Z); 3577 if((yyvsp[(1) - (1)].sym)->class == CLOCAL) 3578 (yyvsp[(1) - (1)].sym) = mkstatic((yyvsp[(1) - (1)].sym)); 3579 (yyval.node)->sym = (yyvsp[(1) - (1)].sym); 3580 (yyval.node)->type = (yyvsp[(1) - (1)].sym)->type; 3581 (yyval.node)->etype = TVOID; 3582 if((yyval.node)->type != T) 3583 (yyval.node)->etype = (yyval.node)->type->etype; 3584 (yyval.node)->xoffset = (yyvsp[(1) - (1)].sym)->offset; 3585 (yyval.node)->class = (yyvsp[(1) - (1)].sym)->class; 3586 (yyvsp[(1) - (1)].sym)->aused = 1; 3587 } 3588 break; 3589 3590 case 245: 3591 #line 1207 "cc.y" 3592 { 3593 (yyval.node) = new(ONAME, Z, Z); 3594 (yyval.node)->sym = (yyvsp[(1) - (1)].sym); 3595 (yyval.node)->type = (yyvsp[(1) - (1)].sym)->type; 3596 (yyval.node)->etype = TVOID; 3597 if((yyval.node)->type != T) 3598 (yyval.node)->etype = (yyval.node)->type->etype; 3599 (yyval.node)->xoffset = (yyvsp[(1) - (1)].sym)->offset; 3600 (yyval.node)->class = (yyvsp[(1) - (1)].sym)->class; 3601 } 3602 break; 3603 3604 3605 /* Line 1267 of yacc.c. */ 3606 #line 3607 "y.tab.c" 3607 default: break; 3608 } 3609 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 3610 3611 YYPOPSTACK (yylen); 3612 yylen = 0; 3613 YY_STACK_PRINT (yyss, yyssp); 3614 3615 *++yyvsp = yyval; 3616 3617 3618 /* Now `shift' the result of the reduction. Determine what state 3619 that goes to, based on the state we popped back to and the rule 3620 number reduced by. */ 3621 3622 yyn = yyr1[yyn]; 3623 3624 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 3625 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 3626 yystate = yytable[yystate]; 3627 else 3628 yystate = yydefgoto[yyn - YYNTOKENS]; 3629 3630 goto yynewstate; 3631 3632 3633 /*------------------------------------. 3634 | yyerrlab -- here on detecting error | 3635 `------------------------------------*/ 3636 yyerrlab: 3637 /* If not already recovering from an error, report this error. */ 3638 if (!yyerrstatus) 3639 { 3640 ++yynerrs; 3641 #if ! YYERROR_VERBOSE 3642 yyerror (YY_("syntax error")); 3643 #else 3644 { 3645 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); 3646 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) 3647 { 3648 YYSIZE_T yyalloc = 2 * yysize; 3649 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) 3650 yyalloc = YYSTACK_ALLOC_MAXIMUM; 3651 if (yymsg != yymsgbuf) 3652 YYSTACK_FREE (yymsg); 3653 yymsg = (char *) YYSTACK_ALLOC (yyalloc); 3654 if (yymsg) 3655 yymsg_alloc = yyalloc; 3656 else 3657 { 3658 yymsg = yymsgbuf; 3659 yymsg_alloc = sizeof yymsgbuf; 3660 } 3661 } 3662 3663 if (0 < yysize && yysize <= yymsg_alloc) 3664 { 3665 (void) yysyntax_error (yymsg, yystate, yychar); 3666 yyerror (yymsg); 3667 } 3668 else 3669 { 3670 yyerror (YY_("syntax error")); 3671 if (yysize != 0) 3672 goto yyexhaustedlab; 3673 } 3674 } 3675 #endif 3676 } 3677 3678 3679 3680 if (yyerrstatus == 3) 3681 { 3682 /* If just tried and failed to reuse look-ahead token after an 3683 error, discard it. */ 3684 3685 if (yychar <= YYEOF) 3686 { 3687 /* Return failure if at end of input. */ 3688 if (yychar == YYEOF) 3689 YYABORT; 3690 } 3691 else 3692 { 3693 yydestruct ("Error: discarding", 3694 yytoken, &yylval); 3695 yychar = YYEMPTY; 3696 } 3697 } 3698 3699 /* Else will try to reuse look-ahead token after shifting the error 3700 token. */ 3701 goto yyerrlab1; 3702 3703 3704 /*---------------------------------------------------. 3705 | yyerrorlab -- error raised explicitly by YYERROR. | 3706 `---------------------------------------------------*/ 3707 yyerrorlab: 3708 3709 /* Pacify compilers like GCC when the user code never invokes 3710 YYERROR and the label yyerrorlab therefore never appears in user 3711 code. */ 3712 if (/*CONSTCOND*/ 0) 3713 goto yyerrorlab; 3714 3715 /* Do not reclaim the symbols of the rule which action triggered 3716 this YYERROR. */ 3717 YYPOPSTACK (yylen); 3718 yylen = 0; 3719 YY_STACK_PRINT (yyss, yyssp); 3720 yystate = *yyssp; 3721 goto yyerrlab1; 3722 3723 3724 /*-------------------------------------------------------------. 3725 | yyerrlab1 -- common code for both syntax error and YYERROR. | 3726 `-------------------------------------------------------------*/ 3727 yyerrlab1: 3728 yyerrstatus = 3; /* Each real token shifted decrements this. */ 3729 3730 for (;;) 3731 { 3732 yyn = yypact[yystate]; 3733 if (yyn != YYPACT_NINF) 3734 { 3735 yyn += YYTERROR; 3736 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 3737 { 3738 yyn = yytable[yyn]; 3739 if (0 < yyn) 3740 break; 3741 } 3742 } 3743 3744 /* Pop the current state because it cannot handle the error token. */ 3745 if (yyssp == yyss) 3746 YYABORT; 3747 3748 3749 yydestruct ("Error: popping", 3750 yystos[yystate], yyvsp); 3751 YYPOPSTACK (1); 3752 yystate = *yyssp; 3753 YY_STACK_PRINT (yyss, yyssp); 3754 } 3755 3756 if (yyn == YYFINAL) 3757 YYACCEPT; 3758 3759 *++yyvsp = yylval; 3760 3761 3762 /* Shift the error token. */ 3763 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 3764 3765 yystate = yyn; 3766 goto yynewstate; 3767 3768 3769 /*-------------------------------------. 3770 | yyacceptlab -- YYACCEPT comes here. | 3771 `-------------------------------------*/ 3772 yyacceptlab: 3773 yyresult = 0; 3774 goto yyreturn; 3775 3776 /*-----------------------------------. 3777 | yyabortlab -- YYABORT comes here. | 3778 `-----------------------------------*/ 3779 yyabortlab: 3780 yyresult = 1; 3781 goto yyreturn; 3782 3783 #ifndef yyoverflow 3784 /*-------------------------------------------------. 3785 | yyexhaustedlab -- memory exhaustion comes here. | 3786 `-------------------------------------------------*/ 3787 yyexhaustedlab: 3788 yyerror (YY_("memory exhausted")); 3789 yyresult = 2; 3790 /* Fall through. */ 3791 #endif 3792 3793 yyreturn: 3794 if (yychar != YYEOF && yychar != YYEMPTY) 3795 yydestruct ("Cleanup: discarding lookahead", 3796 yytoken, &yylval); 3797 /* Do not reclaim the symbols of the rule which action triggered 3798 this YYABORT or YYACCEPT. */ 3799 YYPOPSTACK (yylen); 3800 YY_STACK_PRINT (yyss, yyssp); 3801 while (yyssp != yyss) 3802 { 3803 yydestruct ("Cleanup: popping", 3804 yystos[*yyssp], yyvsp); 3805 YYPOPSTACK (1); 3806 } 3807 #ifndef yyoverflow 3808 if (yyss != yyssa) 3809 YYSTACK_FREE (yyss); 3810 #endif 3811 #if YYERROR_VERBOSE 3812 if (yymsg != yymsgbuf) 3813 YYSTACK_FREE (yymsg); 3814 #endif 3815 /* Make sure YYID is used. */ 3816 return YYID (yyresult); 3817 } 3818 3819 3820 #line 1220 "cc.y" 3821 3822