github.com/rohankumardubey/syslog-redirector-golang@v0.0.0-20140320174030-4859f03d829a/src/cmd/5a/y.tab.c (about) 1 /* A Bison parser, made by GNU Bison 2.5. */ 2 3 /* Bison implementation for Yacc-like parsers in C 4 5 Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc. 6 7 This program is free software: you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation, either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 /* As a special exception, you may create a larger work that contains 21 part or all of the Bison parser skeleton and distribute that work 22 under terms of your choice, so long as that work isn't itself a 23 parser generator using the skeleton or a modified version thereof 24 as a parser skeleton. Alternatively, if you modify or redistribute 25 the parser skeleton itself, you may (at your option) remove this 26 special exception, which will cause the skeleton and the resulting 27 Bison output files to be licensed under the GNU General Public 28 License without this special exception. 29 30 This special exception was added by the Free Software Foundation in 31 version 2.2 of Bison. */ 32 33 /* C LALR(1) parser skeleton written by Richard Stallman, by 34 simplifying the original so-called "semantic" parser. */ 35 36 /* All symbols defined below should begin with yy or YY, to avoid 37 infringing on user name space. This should be done even for local 38 variables, as they might otherwise be expanded by user macros. 39 There are some unavoidable exceptions within include files to 40 define necessary library symbols; they are noted "INFRINGES ON 41 USER NAME SPACE" below. */ 42 43 /* Identify Bison output. */ 44 #define YYBISON 1 45 46 /* Bison version. */ 47 #define YYBISON_VERSION "2.5" 48 49 /* Skeleton name. */ 50 #define YYSKELETON_NAME "yacc.c" 51 52 /* Pure parsers. */ 53 #define YYPURE 0 54 55 /* Push parsers. */ 56 #define YYPUSH 0 57 58 /* Pull parsers. */ 59 #define YYPULL 1 60 61 /* Using locations. */ 62 #define YYLSP_NEEDED 0 63 64 65 66 /* Copy the first part of user declarations. */ 67 68 /* Line 268 of yacc.c */ 69 #line 31 "a.y" 70 71 #include <u.h> 72 #include <stdio.h> /* if we don't, bison will, and a.h re-#defines getc */ 73 #include <libc.h> 74 #include "a.h" 75 #include "../../pkg/runtime/funcdata.h" 76 77 78 /* Line 268 of yacc.c */ 79 #line 80 "y.tab.c" 80 81 /* Enabling traces. */ 82 #ifndef YYDEBUG 83 # define YYDEBUG 0 84 #endif 85 86 /* Enabling verbose error messages. */ 87 #ifdef YYERROR_VERBOSE 88 # undef YYERROR_VERBOSE 89 # define YYERROR_VERBOSE 1 90 #else 91 # define YYERROR_VERBOSE 0 92 #endif 93 94 /* Enabling the token table. */ 95 #ifndef YYTOKEN_TABLE 96 # define YYTOKEN_TABLE 0 97 #endif 98 99 100 /* Tokens. */ 101 #ifndef YYTOKENTYPE 102 # define YYTOKENTYPE 103 /* Put the tokens into the symbol table, so that GDB and other debuggers 104 know about them. */ 105 enum yytokentype { 106 LTYPE1 = 258, 107 LTYPE2 = 259, 108 LTYPE3 = 260, 109 LTYPE4 = 261, 110 LTYPE5 = 262, 111 LTYPE6 = 263, 112 LTYPE7 = 264, 113 LTYPE8 = 265, 114 LTYPE9 = 266, 115 LTYPEA = 267, 116 LTYPEB = 268, 117 LTYPEC = 269, 118 LTYPED = 270, 119 LTYPEE = 271, 120 LTYPEG = 272, 121 LTYPEH = 273, 122 LTYPEI = 274, 123 LTYPEJ = 275, 124 LTYPEK = 276, 125 LTYPEL = 277, 126 LTYPEM = 278, 127 LTYPEN = 279, 128 LTYPEBX = 280, 129 LTYPEPLD = 281, 130 LCONST = 282, 131 LSP = 283, 132 LSB = 284, 133 LFP = 285, 134 LPC = 286, 135 LTYPEX = 287, 136 LTYPEPC = 288, 137 LTYPEF = 289, 138 LR = 290, 139 LREG = 291, 140 LF = 292, 141 LFREG = 293, 142 LC = 294, 143 LCREG = 295, 144 LPSR = 296, 145 LFCR = 297, 146 LCOND = 298, 147 LS = 299, 148 LAT = 300, 149 LFCONST = 301, 150 LSCONST = 302, 151 LNAME = 303, 152 LLAB = 304, 153 LVAR = 305 154 }; 155 #endif 156 /* Tokens. */ 157 #define LTYPE1 258 158 #define LTYPE2 259 159 #define LTYPE3 260 160 #define LTYPE4 261 161 #define LTYPE5 262 162 #define LTYPE6 263 163 #define LTYPE7 264 164 #define LTYPE8 265 165 #define LTYPE9 266 166 #define LTYPEA 267 167 #define LTYPEB 268 168 #define LTYPEC 269 169 #define LTYPED 270 170 #define LTYPEE 271 171 #define LTYPEG 272 172 #define LTYPEH 273 173 #define LTYPEI 274 174 #define LTYPEJ 275 175 #define LTYPEK 276 176 #define LTYPEL 277 177 #define LTYPEM 278 178 #define LTYPEN 279 179 #define LTYPEBX 280 180 #define LTYPEPLD 281 181 #define LCONST 282 182 #define LSP 283 183 #define LSB 284 184 #define LFP 285 185 #define LPC 286 186 #define LTYPEX 287 187 #define LTYPEPC 288 188 #define LTYPEF 289 189 #define LR 290 190 #define LREG 291 191 #define LF 292 192 #define LFREG 293 193 #define LC 294 194 #define LCREG 295 195 #define LPSR 296 196 #define LFCR 297 197 #define LCOND 298 198 #define LS 299 199 #define LAT 300 200 #define LFCONST 301 201 #define LSCONST 302 202 #define LNAME 303 203 #define LLAB 304 204 #define LVAR 305 205 206 207 208 209 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 210 typedef union YYSTYPE 211 { 212 213 /* Line 293 of yacc.c */ 214 #line 39 "a.y" 215 216 Sym *sym; 217 int32 lval; 218 double dval; 219 char sval[8]; 220 Gen gen; 221 222 223 224 /* Line 293 of yacc.c */ 225 #line 226 "y.tab.c" 226 } YYSTYPE; 227 # define YYSTYPE_IS_TRIVIAL 1 228 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ 229 # define YYSTYPE_IS_DECLARED 1 230 #endif 231 232 233 /* Copy the second part of user declarations. */ 234 235 236 /* Line 343 of yacc.c */ 237 #line 238 "y.tab.c" 238 239 #ifdef short 240 # undef short 241 #endif 242 243 #ifdef YYTYPE_UINT8 244 typedef YYTYPE_UINT8 yytype_uint8; 245 #else 246 typedef unsigned char yytype_uint8; 247 #endif 248 249 #ifdef YYTYPE_INT8 250 typedef YYTYPE_INT8 yytype_int8; 251 #elif (defined __STDC__ || defined __C99__FUNC__ \ 252 || defined __cplusplus || defined _MSC_VER) 253 typedef signed char yytype_int8; 254 #else 255 typedef short int yytype_int8; 256 #endif 257 258 #ifdef YYTYPE_UINT16 259 typedef YYTYPE_UINT16 yytype_uint16; 260 #else 261 typedef unsigned short int yytype_uint16; 262 #endif 263 264 #ifdef YYTYPE_INT16 265 typedef YYTYPE_INT16 yytype_int16; 266 #else 267 typedef short int yytype_int16; 268 #endif 269 270 #ifndef YYSIZE_T 271 # ifdef __SIZE_TYPE__ 272 # define YYSIZE_T __SIZE_TYPE__ 273 # elif defined size_t 274 # define YYSIZE_T size_t 275 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ 276 || defined __cplusplus || defined _MSC_VER) 277 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 278 # define YYSIZE_T size_t 279 # else 280 # define YYSIZE_T unsigned int 281 # endif 282 #endif 283 284 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 285 286 #ifndef YY_ 287 # if defined YYENABLE_NLS && YYENABLE_NLS 288 # if ENABLE_NLS 289 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 290 # define YY_(msgid) dgettext ("bison-runtime", msgid) 291 # endif 292 # endif 293 # ifndef YY_ 294 # define YY_(msgid) msgid 295 # endif 296 #endif 297 298 /* Suppress unused-variable warnings by "using" E. */ 299 #if ! defined lint || defined __GNUC__ 300 # define YYUSE(e) ((void) (e)) 301 #else 302 # define YYUSE(e) /* empty */ 303 #endif 304 305 /* Identity function, used to suppress warnings about constant conditions. */ 306 #ifndef lint 307 # define YYID(n) (n) 308 #else 309 #if (defined __STDC__ || defined __C99__FUNC__ \ 310 || defined __cplusplus || defined _MSC_VER) 311 static int 312 YYID (int yyi) 313 #else 314 static int 315 YYID (yyi) 316 int yyi; 317 #endif 318 { 319 return yyi; 320 } 321 #endif 322 323 #if ! defined yyoverflow || YYERROR_VERBOSE 324 325 /* The parser invokes alloca or malloc; define the necessary symbols. */ 326 327 # ifdef YYSTACK_USE_ALLOCA 328 # if YYSTACK_USE_ALLOCA 329 # ifdef __GNUC__ 330 # define YYSTACK_ALLOC __builtin_alloca 331 # elif defined __BUILTIN_VA_ARG_INCR 332 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 333 # elif defined _AIX 334 # define YYSTACK_ALLOC __alloca 335 # elif defined _MSC_VER 336 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 337 # define alloca _alloca 338 # else 339 # define YYSTACK_ALLOC alloca 340 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 341 || defined __cplusplus || defined _MSC_VER) 342 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 343 # ifndef EXIT_SUCCESS 344 # define EXIT_SUCCESS 0 345 # endif 346 # endif 347 # endif 348 # endif 349 # endif 350 351 # ifdef YYSTACK_ALLOC 352 /* Pacify GCC's `empty if-body' warning. */ 353 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) 354 # ifndef YYSTACK_ALLOC_MAXIMUM 355 /* The OS might guarantee only one guard page at the bottom of the stack, 356 and a page size can be as small as 4096 bytes. So we cannot safely 357 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 358 to allow for a few compiler-allocated temporary stack slots. */ 359 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 360 # endif 361 # else 362 # define YYSTACK_ALLOC YYMALLOC 363 # define YYSTACK_FREE YYFREE 364 # ifndef YYSTACK_ALLOC_MAXIMUM 365 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 366 # endif 367 # if (defined __cplusplus && ! defined EXIT_SUCCESS \ 368 && ! ((defined YYMALLOC || defined malloc) \ 369 && (defined YYFREE || defined free))) 370 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 371 # ifndef EXIT_SUCCESS 372 # define EXIT_SUCCESS 0 373 # endif 374 # endif 375 # ifndef YYMALLOC 376 # define YYMALLOC malloc 377 # if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 378 || defined __cplusplus || defined _MSC_VER) 379 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 380 # endif 381 # endif 382 # ifndef YYFREE 383 # define YYFREE free 384 # if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 385 || defined __cplusplus || defined _MSC_VER) 386 void free (void *); /* INFRINGES ON USER NAME SPACE */ 387 # endif 388 # endif 389 # endif 390 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */ 391 392 393 #if (! defined yyoverflow \ 394 && (! defined __cplusplus \ 395 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 396 397 /* A type that is properly aligned for any stack member. */ 398 union yyalloc 399 { 400 yytype_int16 yyss_alloc; 401 YYSTYPE yyvs_alloc; 402 }; 403 404 /* The size of the maximum gap between one aligned stack and the next. */ 405 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 406 407 /* The size of an array large to enough to hold all stacks, each with 408 N elements. */ 409 # define YYSTACK_BYTES(N) \ 410 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ 411 + YYSTACK_GAP_MAXIMUM) 412 413 # define YYCOPY_NEEDED 1 414 415 /* Relocate STACK from its old location to the new one. The 416 local variables YYSIZE and YYSTACKSIZE give the old and new number of 417 elements in the stack, and YYPTR gives the new location of the 418 stack. Advance YYPTR to a properly aligned location for the next 419 stack. */ 420 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 421 do \ 422 { \ 423 YYSIZE_T yynewbytes; \ 424 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 425 Stack = &yyptr->Stack_alloc; \ 426 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 427 yyptr += yynewbytes / sizeof (*yyptr); \ 428 } \ 429 while (YYID (0)) 430 431 #endif 432 433 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED 434 /* Copy COUNT objects from FROM to TO. The source and destination do 435 not overlap. */ 436 # ifndef YYCOPY 437 # if defined __GNUC__ && 1 < __GNUC__ 438 # define YYCOPY(To, From, Count) \ 439 __builtin_memcpy (To, From, (Count) * sizeof (*(From))) 440 # else 441 # define YYCOPY(To, From, Count) \ 442 do \ 443 { \ 444 YYSIZE_T yyi; \ 445 for (yyi = 0; yyi < (Count); yyi++) \ 446 (To)[yyi] = (From)[yyi]; \ 447 } \ 448 while (YYID (0)) 449 # endif 450 # endif 451 #endif /* !YYCOPY_NEEDED */ 452 453 /* YYFINAL -- State number of the termination state. */ 454 #define YYFINAL 2 455 /* YYLAST -- Last index in YYTABLE. */ 456 #define YYLAST 609 457 458 /* YYNTOKENS -- Number of terminals. */ 459 #define YYNTOKENS 71 460 /* YYNNTS -- Number of nonterminals. */ 461 #define YYNNTS 35 462 /* YYNRULES -- Number of rules. */ 463 #define YYNRULES 133 464 /* YYNRULES -- Number of states. */ 465 #define YYNSTATES 339 466 467 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 468 #define YYUNDEFTOK 2 469 #define YYMAXUTOK 305 470 471 #define YYTRANSLATE(YYX) \ 472 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 473 474 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ 475 static const yytype_uint8 yytranslate[] = 476 { 477 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 478 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 479 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 480 2, 2, 2, 2, 2, 2, 69, 12, 5, 2, 481 67, 68, 10, 8, 64, 9, 2, 11, 2, 2, 482 2, 2, 2, 2, 2, 2, 2, 2, 61, 63, 483 6, 62, 7, 2, 2, 2, 2, 2, 2, 2, 484 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 485 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 486 2, 65, 2, 66, 4, 2, 2, 2, 2, 2, 487 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 488 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 489 2, 2, 2, 2, 3, 2, 70, 2, 2, 2, 490 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 491 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 492 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 493 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 494 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 495 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 496 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 497 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 498 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 499 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 500 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 501 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 502 2, 2, 2, 2, 2, 2, 1, 2, 13, 14, 503 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 504 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 505 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 506 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 507 55, 56, 57, 58, 59, 60 508 }; 509 510 #if YYDEBUG 511 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 512 YYRHS. */ 513 static const yytype_uint16 yyprhs[] = 514 { 515 0, 0, 3, 4, 5, 9, 10, 15, 16, 21, 516 26, 31, 33, 36, 39, 47, 54, 60, 66, 72, 517 77, 82, 86, 90, 95, 102, 110, 118, 126, 133, 518 140, 144, 149, 156, 165, 172, 177, 181, 187, 193, 519 201, 208, 221, 229, 239, 242, 247, 252, 255, 256, 520 259, 262, 263, 266, 271, 274, 277, 280, 283, 288, 521 291, 293, 296, 300, 302, 306, 310, 312, 314, 316, 522 321, 323, 325, 327, 329, 331, 333, 335, 339, 341, 523 346, 348, 353, 355, 357, 359, 361, 364, 366, 372, 524 377, 382, 387, 392, 394, 396, 398, 400, 405, 407, 525 409, 411, 416, 418, 420, 422, 427, 432, 438, 446, 526 447, 450, 453, 455, 457, 459, 461, 463, 466, 469, 527 472, 476, 477, 480, 482, 486, 490, 494, 498, 502, 528 507, 512, 516, 520 529 }; 530 531 /* YYRHS -- A `-1'-separated list of the rules' RHS. */ 532 static const yytype_int8 yyrhs[] = 533 { 534 72, 0, -1, -1, -1, 72, 73, 74, -1, -1, 535 59, 61, 75, 74, -1, -1, 58, 61, 76, 74, 536 -1, 58, 62, 105, 63, -1, 60, 62, 105, 63, 537 -1, 63, -1, 77, 63, -1, 1, 63, -1, 13, 538 78, 89, 64, 96, 64, 91, -1, 13, 78, 89, 539 64, 96, 64, -1, 13, 78, 89, 64, 91, -1, 540 14, 78, 89, 64, 91, -1, 15, 78, 84, 64, 541 84, -1, 16, 78, 79, 80, -1, 16, 78, 79, 542 85, -1, 35, 79, 86, -1, 17, 79, 80, -1, 543 18, 78, 79, 84, -1, 19, 78, 89, 64, 96, 544 79, -1, 20, 78, 87, 64, 65, 83, 66, -1, 545 20, 78, 65, 83, 66, 64, 87, -1, 21, 78, 546 91, 64, 86, 64, 91, -1, 21, 78, 91, 64, 547 86, 79, -1, 21, 78, 79, 86, 64, 91, -1, 548 22, 78, 79, -1, 23, 100, 64, 90, -1, 23, 549 100, 64, 103, 64, 90, -1, 23, 100, 64, 103, 550 64, 90, 9, 103, -1, 24, 100, 11, 103, 64, 551 81, -1, 25, 78, 91, 79, -1, 28, 79, 81, 552 -1, 29, 78, 99, 64, 99, -1, 31, 78, 98, 553 64, 99, -1, 31, 78, 98, 64, 48, 64, 99, 554 -1, 32, 78, 99, 64, 99, 79, -1, 30, 78, 555 103, 64, 105, 64, 96, 64, 97, 64, 97, 104, 556 -1, 33, 78, 91, 64, 91, 64, 92, -1, 34, 557 78, 91, 64, 91, 64, 91, 64, 96, -1, 36, 558 88, -1, 43, 84, 64, 84, -1, 44, 84, 64, 559 84, -1, 26, 79, -1, -1, 78, 53, -1, 78, 560 54, -1, -1, 64, 79, -1, 103, 67, 41, 68, 561 -1, 58, 101, -1, 59, 101, -1, 69, 103, -1, 562 69, 88, -1, 69, 10, 69, 88, -1, 69, 57, 563 -1, 82, -1, 69, 56, -1, 69, 9, 56, -1, 564 96, -1, 96, 9, 96, -1, 96, 79, 83, -1, 565 91, -1, 81, -1, 93, -1, 93, 67, 96, 68, 566 -1, 51, -1, 52, -1, 103, -1, 88, -1, 99, 567 -1, 86, -1, 100, -1, 67, 96, 68, -1, 86, 568 -1, 103, 67, 95, 68, -1, 100, -1, 100, 67, 569 95, 68, -1, 87, -1, 91, -1, 90, -1, 93, 570 -1, 69, 103, -1, 96, -1, 67, 96, 64, 96, 571 68, -1, 96, 6, 6, 94, -1, 96, 7, 7, 572 94, -1, 96, 9, 7, 94, -1, 96, 55, 7, 573 94, -1, 96, -1, 103, -1, 46, -1, 41, -1, 574 45, 67, 105, 68, -1, 95, -1, 38, -1, 50, 575 -1, 49, 67, 105, 68, -1, 99, -1, 82, -1, 576 48, -1, 47, 67, 103, 68, -1, 103, 67, 102, 577 68, -1, 58, 101, 67, 102, 68, -1, 58, 6, 578 7, 101, 67, 39, 68, -1, -1, 8, 103, -1, 579 9, 103, -1, 39, -1, 38, -1, 40, -1, 37, 580 -1, 60, -1, 9, 103, -1, 8, 103, -1, 70, 581 103, -1, 67, 105, 68, -1, -1, 64, 105, -1, 582 103, -1, 105, 8, 105, -1, 105, 9, 105, -1, 583 105, 10, 105, -1, 105, 11, 105, -1, 105, 12, 584 105, -1, 105, 6, 6, 105, -1, 105, 7, 7, 585 105, -1, 105, 5, 105, -1, 105, 4, 105, -1, 586 105, 3, 105, -1 587 }; 588 589 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ 590 static const yytype_uint16 yyrline[] = 591 { 592 0, 68, 68, 70, 69, 77, 76, 84, 83, 89, 593 94, 100, 101, 102, 108, 112, 116, 123, 130, 137, 594 141, 148, 155, 162, 169, 176, 185, 197, 201, 205, 595 212, 219, 225, 231, 240, 247, 254, 261, 265, 269, 596 273, 280, 302, 310, 319, 326, 335, 346, 352, 355, 597 359, 364, 365, 368, 374, 383, 391, 397, 402, 407, 598 413, 416, 422, 430, 434, 443, 449, 450, 451, 452, 599 457, 463, 469, 475, 476, 479, 480, 488, 497, 498, 600 507, 508, 514, 517, 518, 519, 521, 529, 537, 546, 601 552, 558, 564, 572, 578, 586, 587, 591, 599, 600, 602 606, 607, 615, 616, 619, 625, 633, 641, 649, 659, 603 662, 666, 672, 673, 674, 677, 678, 682, 686, 690, 604 694, 700, 703, 709, 710, 714, 718, 722, 726, 730, 605 734, 738, 742, 746 606 }; 607 #endif 608 609 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE 610 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 611 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 612 static const char *const yytname[] = 613 { 614 "$end", "error", "$undefined", "'|'", "'^'", "'&'", "'<'", "'>'", "'+'", 615 "'-'", "'*'", "'/'", "'%'", "LTYPE1", "LTYPE2", "LTYPE3", "LTYPE4", 616 "LTYPE5", "LTYPE6", "LTYPE7", "LTYPE8", "LTYPE9", "LTYPEA", "LTYPEB", 617 "LTYPEC", "LTYPED", "LTYPEE", "LTYPEG", "LTYPEH", "LTYPEI", "LTYPEJ", 618 "LTYPEK", "LTYPEL", "LTYPEM", "LTYPEN", "LTYPEBX", "LTYPEPLD", "LCONST", 619 "LSP", "LSB", "LFP", "LPC", "LTYPEX", "LTYPEPC", "LTYPEF", "LR", "LREG", 620 "LF", "LFREG", "LC", "LCREG", "LPSR", "LFCR", "LCOND", "LS", "LAT", 621 "LFCONST", "LSCONST", "LNAME", "LLAB", "LVAR", "':'", "'='", "';'", 622 "','", "'['", "']'", "'('", "')'", "'$'", "'~'", "$accept", "prog", 623 "$@1", "line", "$@2", "$@3", "inst", "cond", "comma", "rel", "ximm", 624 "fcon", "reglist", "gen", "nireg", "ireg", "ioreg", "oreg", "imsr", 625 "imm", "reg", "regreg", "shift", "rcon", "sreg", "spreg", "creg", 626 "frcon", "freg", "name", "offset", "pointer", "con", "oexpr", "expr", 0 627 }; 628 #endif 629 630 # ifdef YYPRINT 631 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to 632 token YYLEX-NUM. */ 633 static const yytype_uint16 yytoknum[] = 634 { 635 0, 256, 257, 124, 94, 38, 60, 62, 43, 45, 636 42, 47, 37, 258, 259, 260, 261, 262, 263, 264, 637 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 638 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 639 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 640 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 641 305, 58, 61, 59, 44, 91, 93, 40, 41, 36, 642 126 643 }; 644 # endif 645 646 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 647 static const yytype_uint8 yyr1[] = 648 { 649 0, 71, 72, 73, 72, 75, 74, 76, 74, 74, 650 74, 74, 74, 74, 77, 77, 77, 77, 77, 77, 651 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 652 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 653 77, 77, 77, 77, 77, 77, 77, 77, 78, 78, 654 78, 79, 79, 80, 80, 80, 81, 81, 81, 81, 655 81, 82, 82, 83, 83, 83, 84, 84, 84, 84, 656 84, 84, 84, 84, 84, 85, 85, 86, 87, 87, 657 88, 88, 88, 89, 89, 89, 90, 91, 92, 93, 658 93, 93, 93, 94, 94, 95, 95, 95, 96, 96, 659 97, 97, 98, 98, 99, 99, 100, 100, 100, 101, 660 101, 101, 102, 102, 102, 103, 103, 103, 103, 103, 661 103, 104, 104, 105, 105, 105, 105, 105, 105, 105, 662 105, 105, 105, 105 663 }; 664 665 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 666 static const yytype_uint8 yyr2[] = 667 { 668 0, 2, 0, 0, 3, 0, 4, 0, 4, 4, 669 4, 1, 2, 2, 7, 6, 5, 5, 5, 4, 670 4, 3, 3, 4, 6, 7, 7, 7, 6, 6, 671 3, 4, 6, 8, 6, 4, 3, 5, 5, 7, 672 6, 12, 7, 9, 2, 4, 4, 2, 0, 2, 673 2, 0, 2, 4, 2, 2, 2, 2, 4, 2, 674 1, 2, 3, 1, 3, 3, 1, 1, 1, 4, 675 1, 1, 1, 1, 1, 1, 1, 3, 1, 4, 676 1, 4, 1, 1, 1, 1, 2, 1, 5, 4, 677 4, 4, 4, 1, 1, 1, 1, 4, 1, 1, 678 1, 4, 1, 1, 1, 4, 4, 5, 7, 0, 679 2, 2, 1, 1, 1, 1, 1, 2, 2, 2, 680 3, 0, 2, 1, 3, 3, 3, 3, 3, 4, 681 4, 3, 3, 3 682 }; 683 684 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM. 685 Performed when YYTABLE doesn't specify something else to do. Zero 686 means the default is an error. */ 687 static const yytype_uint8 yydefact[] = 688 { 689 2, 3, 1, 0, 0, 48, 48, 48, 48, 51, 690 48, 48, 48, 48, 48, 0, 0, 48, 51, 51, 691 48, 48, 48, 48, 48, 48, 51, 0, 0, 0, 692 0, 0, 0, 11, 4, 0, 13, 0, 0, 0, 693 51, 51, 0, 51, 0, 0, 51, 51, 0, 0, 694 115, 109, 116, 0, 0, 0, 0, 0, 0, 47, 695 0, 0, 0, 0, 0, 0, 0, 0, 0, 78, 696 82, 44, 80, 0, 99, 96, 0, 95, 0, 104, 697 70, 71, 0, 67, 60, 0, 73, 66, 68, 98, 698 87, 74, 72, 0, 7, 0, 5, 0, 12, 49, 699 50, 0, 0, 84, 83, 85, 0, 0, 0, 52, 700 109, 109, 22, 0, 0, 0, 0, 0, 0, 0, 701 0, 87, 30, 118, 117, 0, 0, 0, 0, 123, 702 0, 119, 0, 0, 0, 51, 36, 0, 0, 0, 703 103, 0, 102, 0, 0, 0, 0, 21, 0, 0, 704 0, 0, 0, 0, 0, 61, 59, 57, 56, 0, 705 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 706 86, 0, 0, 0, 109, 19, 20, 75, 76, 0, 707 54, 55, 0, 23, 0, 0, 51, 0, 0, 0, 708 0, 109, 110, 111, 0, 0, 0, 0, 0, 0, 709 0, 0, 0, 0, 0, 120, 31, 0, 113, 112, 710 114, 0, 0, 35, 0, 0, 0, 0, 0, 0, 711 0, 77, 0, 0, 0, 0, 62, 0, 45, 0, 712 0, 0, 0, 0, 46, 8, 9, 6, 10, 16, 713 87, 17, 18, 54, 0, 0, 51, 0, 0, 0, 714 0, 0, 51, 0, 0, 133, 132, 131, 0, 0, 715 124, 125, 126, 127, 128, 0, 106, 0, 37, 0, 716 104, 38, 51, 0, 0, 81, 79, 97, 105, 58, 717 69, 89, 93, 94, 90, 91, 92, 15, 53, 24, 718 0, 64, 65, 0, 29, 51, 28, 0, 107, 129, 719 130, 32, 34, 0, 0, 40, 0, 0, 14, 26, 720 25, 27, 0, 0, 0, 39, 0, 42, 0, 108, 721 33, 0, 0, 0, 0, 100, 0, 0, 43, 0, 722 0, 0, 0, 121, 88, 101, 0, 41, 122 723 }; 724 725 /* YYDEFGOTO[NTERM-NUM]. */ 726 static const yytype_int16 yydefgoto[] = 727 { 728 -1, 1, 3, 34, 168, 166, 35, 37, 109, 112, 729 83, 84, 185, 85, 176, 69, 70, 86, 102, 103, 730 87, 317, 88, 281, 89, 121, 326, 141, 91, 72, 731 128, 211, 129, 337, 130 732 }; 733 734 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 735 STATE-NUM. */ 736 #define YYPACT_NINF -128 737 static const yytype_int16 yypact[] = 738 { 739 -128, 4, -128, 315, -35, -128, -128, -128, -128, -10, 740 -128, -128, -128, -128, -128, 44, 44, -128, -10, -10, 741 -128, -128, -128, -128, -128, -128, -10, 416, 371, 371, 742 -49, 9, 32, -128, -128, 38, -128, 487, 487, 344, 743 69, -10, 391, 69, 487, 209, 489, 69, 317, 317, 744 -128, 49, -128, 317, 317, 42, 48, 106, 67, -128, 745 61, 191, 25, 93, 191, 67, 67, 68, 170, -128, 746 -128, -128, 72, 84, -128, -128, 86, -128, 109, -128, 747 -128, -128, 233, -128, -128, 80, -128, -128, 115, -128, 748 426, -128, 84, 120, -128, 317, -128, 317, -128, -128, 749 -128, 317, 137, -128, -128, -128, 148, 155, 397, -128, 750 74, 74, -128, 164, 371, 204, 240, 207, 206, 68, 751 223, -128, -128, -128, -128, 270, 317, 317, 227, -128, 752 183, -128, 90, 160, 317, -10, -128, 234, 237, 16, 753 -128, 254, -128, 255, 256, 257, 240, -128, 212, 168, 754 548, 317, 317, 428, 258, -128, -128, -128, 84, 371, 755 240, 318, 316, 335, 348, 371, 315, 502, 315, 512, 756 -128, 240, 240, 371, 49, -128, -128, -128, -128, 289, 757 -128, -128, 330, -128, 240, 291, 11, 307, 168, 312, 758 68, 74, -128, -128, 160, 317, 317, 317, 377, 379, 759 317, 317, 317, 317, 317, -128, -128, 324, -128, -128, 760 -128, 325, 337, -128, 77, 317, 338, 126, 77, 240, 761 240, -128, 339, 342, 249, 347, -128, 416, -128, 352, 762 170, 170, 170, 170, -128, -128, -128, -128, -128, -128, 763 362, -128, -128, 227, -2, 359, -10, 366, 240, 240, 764 240, 240, 375, 336, 384, 562, 590, 597, 317, 317, 765 213, 213, -128, -128, -128, 385, -128, 61, -128, 357, 766 395, -128, -10, 396, 398, -128, -128, -128, -128, -128, 767 -128, -128, -128, -128, -128, -128, -128, 240, -128, -128, 768 434, -128, -128, 400, -128, 432, -128, 424, -128, 436, 769 436, 459, -128, 240, 77, -128, 402, 240, -128, -128, 770 -128, -128, 404, 317, 411, -128, 240, -128, 415, -128, 771 -128, 216, 418, 240, 413, -128, 421, 240, -128, 317, 772 216, 419, 302, 425, -128, -128, 317, -128, 573 773 }; 774 775 /* YYPGOTO[NTERM-NUM]. */ 776 static const yytype_int16 yypgoto[] = 777 { 778 -128, -128, -128, -77, -128, -128, -128, 538, 50, 382, 779 -57, 429, 33, -7, -128, -48, -43, -21, 36, -127, 780 -23, -128, 29, 17, -101, -28, 161, -128, -37, -8, 781 -65, 299, 2, -128, -32 782 }; 783 784 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 785 positive, shift that token. If negative, reduce the rule which 786 number is the opposite. If YYTABLE_NINF, syntax error. */ 787 #define YYTABLE_NINF -64 788 static const yytype_int16 yytable[] = 789 { 790 90, 90, 117, 136, 2, 206, 71, 55, 57, 90, 791 90, 90, 94, 95, 104, 104, 90, 56, 56, 147, 792 248, 104, 93, 120, 137, 216, 142, 143, 36, 73, 793 92, 92, 107, 48, 49, 135, 208, 209, 210, 245, 794 148, 92, 144, 145, 113, 180, 181, 118, 222, 223, 795 123, 124, 48, 49, 41, 125, 131, 126, 127, 42, 796 177, 157, 50, 167, 138, 169, 105, 105, 59, 60, 797 96, 189, 155, 105, 106, 41, 67, -63, 99, 100, 798 115, 50, 126, 127, 158, 52, 90, 223, 186, 235, 799 108, 237, 53, 114, 97, 54, 119, 122, 48, 49, 800 178, 98, 51, 170, 52, 74, 132, 183, 75, 243, 801 179, 53, 76, 77, 54, 133, 92, 134, 148, 224, 802 99, 100, 99, 100, 78, 79, 253, 50, 192, 193, 803 82, 90, 229, 41, 207, 146, 212, 90, 301, 149, 804 78, 79, 252, 240, 159, 90, 99, 100, 239, 241, 805 52, 150, 228, 151, 225, 124, 246, 53, 234, 101, 806 54, 92, 139, 255, 256, 257, 242, 92, 260, 261, 807 262, 263, 264, 78, 270, 92, 152, 268, 48, 49, 808 271, 272, 160, 269, 165, 213, 195, 196, 197, 198, 809 199, 200, 201, 202, 203, 204, 273, 274, 208, 209, 810 210, 171, 282, 282, 282, 282, 279, 50, 74, 75, 811 302, 75, 172, 76, 77, 76, 77, 48, 49, 173, 812 291, 186, 186, 202, 203, 204, 299, 300, 294, 73, 813 52, 182, 283, 283, 283, 283, 249, 53, 78, 79, 814 54, 48, 153, 154, 99, 100, 50, 309, 284, 285, 815 286, 205, 195, 196, 197, 198, 199, 200, 201, 202, 816 203, 204, 99, 100, 308, 324, 325, 315, 184, 52, 817 50, 187, 311, 188, 116, 314, 68, 191, 74, 54, 818 221, 75, 292, 293, 318, 76, 77, 190, 322, 155, 819 156, 51, 118, 52, 194, 328, 289, 332, 214, 331, 820 68, 215, 296, 54, 338, 195, 196, 197, 198, 199, 821 200, 201, 202, 203, 204, 320, 4, 277, 217, 218, 822 219, 220, 305, 231, 230, 48, 49, 227, 5, 6, 823 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 824 17, 18, 232, 19, 20, 21, 22, 23, 24, 25, 825 26, 27, 48, 49, 50, 233, 244, 247, 28, 29, 826 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 827 335, 245, 250, 30, 31, 32, 251, 52, 33, 48, 828 49, 50, 74, 258, 53, 75, 259, 54, 265, 76, 829 77, 78, 79, 266, 226, 80, 81, 99, 100, 48, 830 49, 267, 51, 297, 52, 48, 49, 275, 50, 74, 831 276, 68, 75, 82, 54, 278, 76, 77, 78, 79, 832 280, 303, 80, 81, 48, 49, 287, 288, 50, 51, 833 290, 52, 161, 162, 50, 163, 48, 49, 68, 295, 834 82, 54, 48, 49, 200, 201, 202, 203, 204, 110, 835 111, 52, 298, 50, 101, 174, 111, 52, 53, 304, 836 306, 54, 307, 312, 68, 50, 310, 54, 313, 316, 837 74, 50, 319, 75, 51, 321, 52, 76, 77, 323, 838 329, 164, 327, 68, 226, 330, 54, 334, 52, 336, 839 175, 333, 140, 254, 52, 53, 41, 0, 54, 0, 840 0, 68, 0, 0, 54, 195, 196, 197, 198, 199, 841 200, 201, 202, 203, 204, 195, 196, 197, 198, 199, 842 200, 201, 202, 203, 204, 74, 0, 74, 75, 0, 843 75, 0, 76, 77, 76, 77, 0, 0, 0, 0, 844 99, 100, 99, 100, 38, 39, 40, 0, 43, 44, 845 45, 46, 47, 41, 0, 58, 101, 0, 61, 62, 846 63, 64, 65, 66, 0, 236, 196, 197, 198, 199, 847 200, 201, 202, 203, 204, 238, 195, 196, 197, 198, 848 199, 200, 201, 202, 203, 204, 208, 209, 210, 75, 849 0, 0, 0, 76, 77, 197, 198, 199, 200, 201, 850 202, 203, 204, 198, 199, 200, 201, 202, 203, 204 851 }; 852 853 #define yypact_value_is_default(yystate) \ 854 ((yystate) == (-128)) 855 856 #define yytable_value_is_error(yytable_value) \ 857 YYID (0) 858 859 static const yytype_int16 yycheck[] = 860 { 861 28, 29, 45, 60, 0, 132, 27, 15, 16, 37, 862 38, 39, 61, 62, 37, 38, 44, 15, 16, 67, 863 9, 44, 29, 46, 61, 9, 63, 64, 63, 27, 864 28, 29, 39, 8, 9, 58, 38, 39, 40, 41, 865 68, 39, 65, 66, 42, 110, 111, 45, 149, 150, 866 48, 49, 8, 9, 64, 6, 54, 8, 9, 9, 867 108, 82, 37, 95, 62, 97, 37, 38, 18, 19, 868 61, 119, 56, 44, 38, 64, 26, 66, 53, 54, 869 44, 37, 8, 9, 82, 60, 114, 188, 116, 166, 870 40, 168, 67, 43, 62, 70, 46, 47, 8, 9, 871 108, 63, 58, 101, 60, 38, 64, 114, 41, 174, 872 108, 67, 45, 46, 70, 67, 114, 11, 146, 151, 873 53, 54, 53, 54, 47, 48, 191, 37, 126, 127, 874 69, 159, 160, 64, 132, 67, 134, 165, 265, 67, 875 47, 48, 190, 171, 64, 173, 53, 54, 171, 172, 876 60, 67, 159, 67, 152, 153, 184, 67, 165, 69, 877 70, 159, 69, 195, 196, 197, 173, 165, 200, 201, 878 202, 203, 204, 47, 48, 173, 67, 214, 8, 9, 879 217, 218, 67, 215, 64, 135, 3, 4, 5, 6, 880 7, 8, 9, 10, 11, 12, 219, 220, 38, 39, 881 40, 64, 230, 231, 232, 233, 227, 37, 38, 41, 882 267, 41, 64, 45, 46, 45, 46, 8, 9, 64, 883 248, 249, 250, 10, 11, 12, 258, 259, 251, 227, 884 60, 67, 230, 231, 232, 233, 186, 67, 47, 48, 885 70, 8, 9, 10, 53, 54, 37, 290, 231, 232, 886 233, 68, 3, 4, 5, 6, 7, 8, 9, 10, 887 11, 12, 53, 54, 287, 49, 50, 304, 64, 60, 888 37, 64, 295, 67, 65, 303, 67, 7, 38, 70, 889 68, 41, 249, 250, 307, 45, 46, 64, 316, 56, 890 57, 58, 290, 60, 67, 323, 246, 329, 64, 327, 891 67, 64, 252, 70, 336, 3, 4, 5, 6, 7, 892 8, 9, 10, 11, 12, 313, 1, 68, 64, 64, 893 64, 64, 272, 7, 6, 8, 9, 69, 13, 14, 894 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 895 25, 26, 7, 28, 29, 30, 31, 32, 33, 34, 896 35, 36, 8, 9, 37, 7, 67, 66, 43, 44, 897 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 898 68, 41, 65, 58, 59, 60, 64, 60, 63, 8, 899 9, 37, 38, 6, 67, 41, 7, 70, 64, 45, 900 46, 47, 48, 68, 56, 51, 52, 53, 54, 8, 901 9, 64, 58, 67, 60, 8, 9, 68, 37, 38, 902 68, 67, 41, 69, 70, 68, 45, 46, 47, 48, 903 68, 64, 51, 52, 8, 9, 64, 68, 37, 58, 904 64, 60, 6, 7, 37, 9, 8, 9, 67, 64, 905 69, 70, 8, 9, 8, 9, 10, 11, 12, 58, 906 59, 60, 68, 37, 69, 58, 59, 60, 67, 64, 907 64, 70, 64, 39, 67, 37, 66, 70, 9, 67, 908 38, 37, 68, 41, 58, 64, 60, 45, 46, 64, 909 67, 55, 64, 67, 56, 64, 70, 68, 60, 64, 910 108, 330, 63, 194, 60, 67, 64, -1, 70, -1, 911 -1, 67, -1, -1, 70, 3, 4, 5, 6, 7, 912 8, 9, 10, 11, 12, 3, 4, 5, 6, 7, 913 8, 9, 10, 11, 12, 38, -1, 38, 41, -1, 914 41, -1, 45, 46, 45, 46, -1, -1, -1, -1, 915 53, 54, 53, 54, 6, 7, 8, -1, 10, 11, 916 12, 13, 14, 64, -1, 17, 69, -1, 20, 21, 917 22, 23, 24, 25, -1, 63, 4, 5, 6, 7, 918 8, 9, 10, 11, 12, 63, 3, 4, 5, 6, 919 7, 8, 9, 10, 11, 12, 38, 39, 40, 41, 920 -1, -1, -1, 45, 46, 5, 6, 7, 8, 9, 921 10, 11, 12, 6, 7, 8, 9, 10, 11, 12 922 }; 923 924 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 925 symbol of state STATE-NUM. */ 926 static const yytype_uint8 yystos[] = 927 { 928 0, 72, 0, 73, 1, 13, 14, 15, 16, 17, 929 18, 19, 20, 21, 22, 23, 24, 25, 26, 28, 930 29, 30, 31, 32, 33, 34, 35, 36, 43, 44, 931 58, 59, 60, 63, 74, 77, 63, 78, 78, 78, 932 78, 64, 79, 78, 78, 78, 78, 78, 8, 9, 933 37, 58, 60, 67, 70, 100, 103, 100, 78, 79, 934 79, 78, 78, 78, 78, 78, 78, 79, 67, 86, 935 87, 88, 100, 103, 38, 41, 45, 46, 47, 48, 936 51, 52, 69, 81, 82, 84, 88, 91, 93, 95, 937 96, 99, 103, 84, 61, 62, 61, 62, 63, 53, 938 54, 69, 89, 90, 91, 93, 89, 84, 79, 79, 939 58, 59, 80, 103, 79, 89, 65, 87, 103, 79, 940 91, 96, 79, 103, 103, 6, 8, 9, 101, 103, 941 105, 103, 64, 67, 11, 91, 81, 99, 103, 69, 942 82, 98, 99, 99, 91, 91, 67, 86, 96, 67, 943 67, 67, 67, 9, 10, 56, 57, 88, 103, 64, 944 67, 6, 7, 9, 55, 64, 76, 105, 75, 105, 945 103, 64, 64, 64, 58, 80, 85, 86, 100, 103, 946 101, 101, 67, 84, 64, 83, 96, 64, 67, 86, 947 64, 7, 103, 103, 67, 3, 4, 5, 6, 7, 948 8, 9, 10, 11, 12, 68, 90, 103, 38, 39, 949 40, 102, 103, 79, 64, 64, 9, 64, 64, 64, 950 64, 68, 95, 95, 105, 103, 56, 69, 84, 96, 951 6, 7, 7, 7, 84, 74, 63, 74, 63, 91, 952 96, 91, 84, 101, 67, 41, 96, 66, 9, 79, 953 65, 64, 86, 101, 102, 105, 105, 105, 6, 7, 954 105, 105, 105, 105, 105, 64, 68, 64, 99, 105, 955 48, 99, 99, 91, 91, 68, 68, 68, 68, 88, 956 68, 94, 96, 103, 94, 94, 94, 64, 68, 79, 957 64, 96, 83, 83, 91, 64, 79, 67, 68, 105, 958 105, 90, 81, 64, 64, 79, 64, 64, 91, 87, 959 66, 91, 39, 9, 96, 99, 67, 92, 91, 68, 960 103, 64, 96, 64, 49, 50, 97, 64, 96, 67, 961 64, 96, 105, 97, 68, 68, 64, 104, 105 962 }; 963 964 #define yyerrok (yyerrstatus = 0) 965 #define yyclearin (yychar = YYEMPTY) 966 #define YYEMPTY (-2) 967 #define YYEOF 0 968 969 #define YYACCEPT goto yyacceptlab 970 #define YYABORT goto yyabortlab 971 #define YYERROR goto yyerrorlab 972 973 974 /* Like YYERROR except do call yyerror. This remains here temporarily 975 to ease the transition to the new meaning of YYERROR, for GCC. 976 Once GCC version 2 has supplanted version 1, this can go. However, 977 YYFAIL appears to be in use. Nevertheless, it is formally deprecated 978 in Bison 2.4.2's NEWS entry, where a plan to phase it out is 979 discussed. */ 980 981 #define YYFAIL goto yyerrlab 982 #if defined YYFAIL 983 /* This is here to suppress warnings from the GCC cpp's 984 -Wunused-macros. Normally we don't worry about that warning, but 985 some users do, and we want to make it easy for users to remove 986 YYFAIL uses, which will produce warnings from Bison 2.5. */ 987 #endif 988 989 #define YYRECOVERING() (!!yyerrstatus) 990 991 #define YYBACKUP(Token, Value) \ 992 do \ 993 if (yychar == YYEMPTY && yylen == 1) \ 994 { \ 995 yychar = (Token); \ 996 yylval = (Value); \ 997 YYPOPSTACK (1); \ 998 goto yybackup; \ 999 } \ 1000 else \ 1001 { \ 1002 yyerror (YY_("syntax error: cannot back up")); \ 1003 YYERROR; \ 1004 } \ 1005 while (YYID (0)) 1006 1007 1008 #define YYTERROR 1 1009 #define YYERRCODE 256 1010 1011 1012 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. 1013 If N is 0, then set CURRENT to the empty location which ends 1014 the previous symbol: RHS[0] (always defined). */ 1015 1016 #define YYRHSLOC(Rhs, K) ((Rhs)[K]) 1017 #ifndef YYLLOC_DEFAULT 1018 # define YYLLOC_DEFAULT(Current, Rhs, N) \ 1019 do \ 1020 if (YYID (N)) \ 1021 { \ 1022 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ 1023 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ 1024 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ 1025 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ 1026 } \ 1027 else \ 1028 { \ 1029 (Current).first_line = (Current).last_line = \ 1030 YYRHSLOC (Rhs, 0).last_line; \ 1031 (Current).first_column = (Current).last_column = \ 1032 YYRHSLOC (Rhs, 0).last_column; \ 1033 } \ 1034 while (YYID (0)) 1035 #endif 1036 1037 1038 /* This macro is provided for backward compatibility. */ 1039 1040 #ifndef YY_LOCATION_PRINT 1041 # define YY_LOCATION_PRINT(File, Loc) ((void) 0) 1042 #endif 1043 1044 1045 /* YYLEX -- calling `yylex' with the right arguments. */ 1046 1047 #ifdef YYLEX_PARAM 1048 # define YYLEX yylex (YYLEX_PARAM) 1049 #else 1050 # define YYLEX yylex () 1051 #endif 1052 1053 /* Enable debugging if requested. */ 1054 #if YYDEBUG 1055 1056 # ifndef YYFPRINTF 1057 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 1058 # define YYFPRINTF fprintf 1059 # endif 1060 1061 # define YYDPRINTF(Args) \ 1062 do { \ 1063 if (yydebug) \ 1064 YYFPRINTF Args; \ 1065 } while (YYID (0)) 1066 1067 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 1068 do { \ 1069 if (yydebug) \ 1070 { \ 1071 YYFPRINTF (stderr, "%s ", Title); \ 1072 yy_symbol_print (stderr, \ 1073 Type, Value); \ 1074 YYFPRINTF (stderr, "\n"); \ 1075 } \ 1076 } while (YYID (0)) 1077 1078 1079 /*--------------------------------. 1080 | Print this symbol on YYOUTPUT. | 1081 `--------------------------------*/ 1082 1083 /*ARGSUSED*/ 1084 #if (defined __STDC__ || defined __C99__FUNC__ \ 1085 || defined __cplusplus || defined _MSC_VER) 1086 static void 1087 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 1088 #else 1089 static void 1090 yy_symbol_value_print (yyoutput, yytype, yyvaluep) 1091 FILE *yyoutput; 1092 int yytype; 1093 YYSTYPE const * const yyvaluep; 1094 #endif 1095 { 1096 if (!yyvaluep) 1097 return; 1098 # ifdef YYPRINT 1099 if (yytype < YYNTOKENS) 1100 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 1101 # else 1102 YYUSE (yyoutput); 1103 # endif 1104 switch (yytype) 1105 { 1106 default: 1107 break; 1108 } 1109 } 1110 1111 1112 /*--------------------------------. 1113 | Print this symbol on YYOUTPUT. | 1114 `--------------------------------*/ 1115 1116 #if (defined __STDC__ || defined __C99__FUNC__ \ 1117 || defined __cplusplus || defined _MSC_VER) 1118 static void 1119 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 1120 #else 1121 static void 1122 yy_symbol_print (yyoutput, yytype, yyvaluep) 1123 FILE *yyoutput; 1124 int yytype; 1125 YYSTYPE const * const yyvaluep; 1126 #endif 1127 { 1128 if (yytype < YYNTOKENS) 1129 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); 1130 else 1131 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); 1132 1133 yy_symbol_value_print (yyoutput, yytype, yyvaluep); 1134 YYFPRINTF (yyoutput, ")"); 1135 } 1136 1137 /*------------------------------------------------------------------. 1138 | yy_stack_print -- Print the state stack from its BOTTOM up to its | 1139 | TOP (included). | 1140 `------------------------------------------------------------------*/ 1141 1142 #if (defined __STDC__ || defined __C99__FUNC__ \ 1143 || defined __cplusplus || defined _MSC_VER) 1144 static void 1145 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) 1146 #else 1147 static void 1148 yy_stack_print (yybottom, yytop) 1149 yytype_int16 *yybottom; 1150 yytype_int16 *yytop; 1151 #endif 1152 { 1153 YYFPRINTF (stderr, "Stack now"); 1154 for (; yybottom <= yytop; yybottom++) 1155 { 1156 int yybot = *yybottom; 1157 YYFPRINTF (stderr, " %d", yybot); 1158 } 1159 YYFPRINTF (stderr, "\n"); 1160 } 1161 1162 # define YY_STACK_PRINT(Bottom, Top) \ 1163 do { \ 1164 if (yydebug) \ 1165 yy_stack_print ((Bottom), (Top)); \ 1166 } while (YYID (0)) 1167 1168 1169 /*------------------------------------------------. 1170 | Report that the YYRULE is going to be reduced. | 1171 `------------------------------------------------*/ 1172 1173 #if (defined __STDC__ || defined __C99__FUNC__ \ 1174 || defined __cplusplus || defined _MSC_VER) 1175 static void 1176 yy_reduce_print (YYSTYPE *yyvsp, int yyrule) 1177 #else 1178 static void 1179 yy_reduce_print (yyvsp, yyrule) 1180 YYSTYPE *yyvsp; 1181 int yyrule; 1182 #endif 1183 { 1184 int yynrhs = yyr2[yyrule]; 1185 int yyi; 1186 unsigned long int yylno = yyrline[yyrule]; 1187 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", 1188 yyrule - 1, yylno); 1189 /* The symbols being reduced. */ 1190 for (yyi = 0; yyi < yynrhs; yyi++) 1191 { 1192 YYFPRINTF (stderr, " $%d = ", yyi + 1); 1193 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], 1194 &(yyvsp[(yyi + 1) - (yynrhs)]) 1195 ); 1196 YYFPRINTF (stderr, "\n"); 1197 } 1198 } 1199 1200 # define YY_REDUCE_PRINT(Rule) \ 1201 do { \ 1202 if (yydebug) \ 1203 yy_reduce_print (yyvsp, Rule); \ 1204 } while (YYID (0)) 1205 1206 /* Nonzero means print parse trace. It is left uninitialized so that 1207 multiple parsers can coexist. */ 1208 int yydebug; 1209 #else /* !YYDEBUG */ 1210 # define YYDPRINTF(Args) 1211 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) 1212 # define YY_STACK_PRINT(Bottom, Top) 1213 # define YY_REDUCE_PRINT(Rule) 1214 #endif /* !YYDEBUG */ 1215 1216 1217 /* YYINITDEPTH -- initial size of the parser's stacks. */ 1218 #ifndef YYINITDEPTH 1219 # define YYINITDEPTH 200 1220 #endif 1221 1222 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 1223 if the built-in stack extension method is used). 1224 1225 Do not make this value too large; the results are undefined if 1226 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 1227 evaluated with infinite-precision integer arithmetic. */ 1228 1229 #ifndef YYMAXDEPTH 1230 # define YYMAXDEPTH 10000 1231 #endif 1232 1233 1234 #if YYERROR_VERBOSE 1235 1236 # ifndef yystrlen 1237 # if defined __GLIBC__ && defined _STRING_H 1238 # define yystrlen strlen 1239 # else 1240 /* Return the length of YYSTR. */ 1241 #if (defined __STDC__ || defined __C99__FUNC__ \ 1242 || defined __cplusplus || defined _MSC_VER) 1243 static YYSIZE_T 1244 yystrlen (const char *yystr) 1245 #else 1246 static YYSIZE_T 1247 yystrlen (yystr) 1248 const char *yystr; 1249 #endif 1250 { 1251 YYSIZE_T yylen; 1252 for (yylen = 0; yystr[yylen]; yylen++) 1253 continue; 1254 return yylen; 1255 } 1256 # endif 1257 # endif 1258 1259 # ifndef yystpcpy 1260 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 1261 # define yystpcpy stpcpy 1262 # else 1263 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 1264 YYDEST. */ 1265 #if (defined __STDC__ || defined __C99__FUNC__ \ 1266 || defined __cplusplus || defined _MSC_VER) 1267 static char * 1268 yystpcpy (char *yydest, const char *yysrc) 1269 #else 1270 static char * 1271 yystpcpy (yydest, yysrc) 1272 char *yydest; 1273 const char *yysrc; 1274 #endif 1275 { 1276 char *yyd = yydest; 1277 const char *yys = yysrc; 1278 1279 while ((*yyd++ = *yys++) != '\0') 1280 continue; 1281 1282 return yyd - 1; 1283 } 1284 # endif 1285 # endif 1286 1287 # ifndef yytnamerr 1288 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary 1289 quotes and backslashes, so that it's suitable for yyerror. The 1290 heuristic is that double-quoting is unnecessary unless the string 1291 contains an apostrophe, a comma, or backslash (other than 1292 backslash-backslash). YYSTR is taken from yytname. If YYRES is 1293 null, do not copy; instead, return the length of what the result 1294 would have been. */ 1295 static YYSIZE_T 1296 yytnamerr (char *yyres, const char *yystr) 1297 { 1298 if (*yystr == '"') 1299 { 1300 YYSIZE_T yyn = 0; 1301 char const *yyp = yystr; 1302 1303 for (;;) 1304 switch (*++yyp) 1305 { 1306 case '\'': 1307 case ',': 1308 goto do_not_strip_quotes; 1309 1310 case '\\': 1311 if (*++yyp != '\\') 1312 goto do_not_strip_quotes; 1313 /* Fall through. */ 1314 default: 1315 if (yyres) 1316 yyres[yyn] = *yyp; 1317 yyn++; 1318 break; 1319 1320 case '"': 1321 if (yyres) 1322 yyres[yyn] = '\0'; 1323 return yyn; 1324 } 1325 do_not_strip_quotes: ; 1326 } 1327 1328 if (! yyres) 1329 return yystrlen (yystr); 1330 1331 return yystpcpy (yyres, yystr) - yyres; 1332 } 1333 # endif 1334 1335 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message 1336 about the unexpected token YYTOKEN for the state stack whose top is 1337 YYSSP. 1338 1339 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is 1340 not large enough to hold the message. In that case, also set 1341 *YYMSG_ALLOC to the required number of bytes. Return 2 if the 1342 required number of bytes is too large to store. */ 1343 static int 1344 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, 1345 yytype_int16 *yyssp, int yytoken) 1346 { 1347 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]); 1348 YYSIZE_T yysize = yysize0; 1349 YYSIZE_T yysize1; 1350 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 1351 /* Internationalized format string. */ 1352 const char *yyformat = 0; 1353 /* Arguments of yyformat. */ 1354 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 1355 /* Number of reported tokens (one for the "unexpected", one per 1356 "expected"). */ 1357 int yycount = 0; 1358 1359 /* There are many possibilities here to consider: 1360 - Assume YYFAIL is not used. It's too flawed to consider. See 1361 <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html> 1362 for details. YYERROR is fine as it does not invoke this 1363 function. 1364 - If this state is a consistent state with a default action, then 1365 the only way this function was invoked is if the default action 1366 is an error action. In that case, don't check for expected 1367 tokens because there are none. 1368 - The only way there can be no lookahead present (in yychar) is if 1369 this state is a consistent state with a default action. Thus, 1370 detecting the absence of a lookahead is sufficient to determine 1371 that there is no unexpected or expected token to report. In that 1372 case, just report a simple "syntax error". 1373 - Don't assume there isn't a lookahead just because this state is a 1374 consistent state with a default action. There might have been a 1375 previous inconsistent state, consistent state with a non-default 1376 action, or user semantic action that manipulated yychar. 1377 - Of course, the expected token list depends on states to have 1378 correct lookahead information, and it depends on the parser not 1379 to perform extra reductions after fetching a lookahead from the 1380 scanner and before detecting a syntax error. Thus, state merging 1381 (from LALR or IELR) and default reductions corrupt the expected 1382 token list. However, the list is correct for canonical LR with 1383 one exception: it will still contain any token that will not be 1384 accepted due to an error action in a later state. 1385 */ 1386 if (yytoken != YYEMPTY) 1387 { 1388 int yyn = yypact[*yyssp]; 1389 yyarg[yycount++] = yytname[yytoken]; 1390 if (!yypact_value_is_default (yyn)) 1391 { 1392 /* Start YYX at -YYN if negative to avoid negative indexes in 1393 YYCHECK. In other words, skip the first -YYN actions for 1394 this state because they are default actions. */ 1395 int yyxbegin = yyn < 0 ? -yyn : 0; 1396 /* Stay within bounds of both yycheck and yytname. */ 1397 int yychecklim = YYLAST - yyn + 1; 1398 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 1399 int yyx; 1400 1401 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 1402 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR 1403 && !yytable_value_is_error (yytable[yyx + yyn])) 1404 { 1405 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 1406 { 1407 yycount = 1; 1408 yysize = yysize0; 1409 break; 1410 } 1411 yyarg[yycount++] = yytname[yyx]; 1412 yysize1 = yysize + yytnamerr (0, yytname[yyx]); 1413 if (! (yysize <= yysize1 1414 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 1415 return 2; 1416 yysize = yysize1; 1417 } 1418 } 1419 } 1420 1421 switch (yycount) 1422 { 1423 # define YYCASE_(N, S) \ 1424 case N: \ 1425 yyformat = S; \ 1426 break 1427 YYCASE_(0, YY_("syntax error")); 1428 YYCASE_(1, YY_("syntax error, unexpected %s")); 1429 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); 1430 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); 1431 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); 1432 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); 1433 # undef YYCASE_ 1434 } 1435 1436 yysize1 = yysize + yystrlen (yyformat); 1437 if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 1438 return 2; 1439 yysize = yysize1; 1440 1441 if (*yymsg_alloc < yysize) 1442 { 1443 *yymsg_alloc = 2 * yysize; 1444 if (! (yysize <= *yymsg_alloc 1445 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) 1446 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; 1447 return 1; 1448 } 1449 1450 /* Avoid sprintf, as that infringes on the user's name space. 1451 Don't have undefined behavior even if the translation 1452 produced a string with the wrong number of "%s"s. */ 1453 { 1454 char *yyp = *yymsg; 1455 int yyi = 0; 1456 while ((*yyp = *yyformat) != '\0') 1457 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) 1458 { 1459 yyp += yytnamerr (yyp, yyarg[yyi++]); 1460 yyformat += 2; 1461 } 1462 else 1463 { 1464 yyp++; 1465 yyformat++; 1466 } 1467 } 1468 return 0; 1469 } 1470 #endif /* YYERROR_VERBOSE */ 1471 1472 /*-----------------------------------------------. 1473 | Release the memory associated to this symbol. | 1474 `-----------------------------------------------*/ 1475 1476 /*ARGSUSED*/ 1477 #if (defined __STDC__ || defined __C99__FUNC__ \ 1478 || defined __cplusplus || defined _MSC_VER) 1479 static void 1480 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) 1481 #else 1482 static void 1483 yydestruct (yymsg, yytype, yyvaluep) 1484 const char *yymsg; 1485 int yytype; 1486 YYSTYPE *yyvaluep; 1487 #endif 1488 { 1489 YYUSE (yyvaluep); 1490 1491 if (!yymsg) 1492 yymsg = "Deleting"; 1493 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1494 1495 switch (yytype) 1496 { 1497 1498 default: 1499 break; 1500 } 1501 } 1502 1503 1504 /* Prevent warnings from -Wmissing-prototypes. */ 1505 #ifdef YYPARSE_PARAM 1506 #if defined __STDC__ || defined __cplusplus 1507 int yyparse (void *YYPARSE_PARAM); 1508 #else 1509 int yyparse (); 1510 #endif 1511 #else /* ! YYPARSE_PARAM */ 1512 #if defined __STDC__ || defined __cplusplus 1513 int yyparse (void); 1514 #else 1515 int yyparse (); 1516 #endif 1517 #endif /* ! YYPARSE_PARAM */ 1518 1519 1520 /* The lookahead symbol. */ 1521 int yychar; 1522 1523 /* The semantic value of the lookahead symbol. */ 1524 YYSTYPE yylval; 1525 1526 /* Number of syntax errors so far. */ 1527 int yynerrs; 1528 1529 1530 /*----------. 1531 | yyparse. | 1532 `----------*/ 1533 1534 #ifdef YYPARSE_PARAM 1535 #if (defined __STDC__ || defined __C99__FUNC__ \ 1536 || defined __cplusplus || defined _MSC_VER) 1537 int 1538 yyparse (void *YYPARSE_PARAM) 1539 #else 1540 int 1541 yyparse (YYPARSE_PARAM) 1542 void *YYPARSE_PARAM; 1543 #endif 1544 #else /* ! YYPARSE_PARAM */ 1545 #if (defined __STDC__ || defined __C99__FUNC__ \ 1546 || defined __cplusplus || defined _MSC_VER) 1547 int 1548 yyparse (void) 1549 #else 1550 int 1551 yyparse () 1552 1553 #endif 1554 #endif 1555 { 1556 int yystate; 1557 /* Number of tokens to shift before error messages enabled. */ 1558 int yyerrstatus; 1559 1560 /* The stacks and their tools: 1561 `yyss': related to states. 1562 `yyvs': related to semantic values. 1563 1564 Refer to the stacks thru separate pointers, to allow yyoverflow 1565 to reallocate them elsewhere. */ 1566 1567 /* The state stack. */ 1568 yytype_int16 yyssa[YYINITDEPTH]; 1569 yytype_int16 *yyss; 1570 yytype_int16 *yyssp; 1571 1572 /* The semantic value stack. */ 1573 YYSTYPE yyvsa[YYINITDEPTH]; 1574 YYSTYPE *yyvs; 1575 YYSTYPE *yyvsp; 1576 1577 YYSIZE_T yystacksize; 1578 1579 int yyn; 1580 int yyresult; 1581 /* Lookahead token as an internal (translated) token number. */ 1582 int yytoken; 1583 /* The variables used to return semantic value and location from the 1584 action routines. */ 1585 YYSTYPE yyval; 1586 1587 #if YYERROR_VERBOSE 1588 /* Buffer for error messages, and its allocated size. */ 1589 char yymsgbuf[128]; 1590 char *yymsg = yymsgbuf; 1591 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 1592 #endif 1593 1594 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 1595 1596 /* The number of symbols on the RHS of the reduced rule. 1597 Keep to zero when no symbol should be popped. */ 1598 int yylen = 0; 1599 1600 yytoken = 0; 1601 yyss = yyssa; 1602 yyvs = yyvsa; 1603 yystacksize = YYINITDEPTH; 1604 1605 YYDPRINTF ((stderr, "Starting parse\n")); 1606 1607 yystate = 0; 1608 yyerrstatus = 0; 1609 yynerrs = 0; 1610 yychar = YYEMPTY; /* Cause a token to be read. */ 1611 1612 /* Initialize stack pointers. 1613 Waste one element of value and location stack 1614 so that they stay on the same level as the state stack. 1615 The wasted elements are never initialized. */ 1616 yyssp = yyss; 1617 yyvsp = yyvs; 1618 1619 goto yysetstate; 1620 1621 /*------------------------------------------------------------. 1622 | yynewstate -- Push a new state, which is found in yystate. | 1623 `------------------------------------------------------------*/ 1624 yynewstate: 1625 /* In all cases, when you get here, the value and location stacks 1626 have just been pushed. So pushing a state here evens the stacks. */ 1627 yyssp++; 1628 1629 yysetstate: 1630 *yyssp = yystate; 1631 1632 if (yyss + yystacksize - 1 <= yyssp) 1633 { 1634 /* Get the current used size of the three stacks, in elements. */ 1635 YYSIZE_T yysize = yyssp - yyss + 1; 1636 1637 #ifdef yyoverflow 1638 { 1639 /* Give user a chance to reallocate the stack. Use copies of 1640 these so that the &'s don't force the real ones into 1641 memory. */ 1642 YYSTYPE *yyvs1 = yyvs; 1643 yytype_int16 *yyss1 = yyss; 1644 1645 /* Each stack pointer address is followed by the size of the 1646 data in use in that stack, in bytes. This used to be a 1647 conditional around just the two extra args, but that might 1648 be undefined if yyoverflow is a macro. */ 1649 yyoverflow (YY_("memory exhausted"), 1650 &yyss1, yysize * sizeof (*yyssp), 1651 &yyvs1, yysize * sizeof (*yyvsp), 1652 &yystacksize); 1653 1654 yyss = yyss1; 1655 yyvs = yyvs1; 1656 } 1657 #else /* no yyoverflow */ 1658 # ifndef YYSTACK_RELOCATE 1659 goto yyexhaustedlab; 1660 # else 1661 /* Extend the stack our own way. */ 1662 if (YYMAXDEPTH <= yystacksize) 1663 goto yyexhaustedlab; 1664 yystacksize *= 2; 1665 if (YYMAXDEPTH < yystacksize) 1666 yystacksize = YYMAXDEPTH; 1667 1668 { 1669 yytype_int16 *yyss1 = yyss; 1670 union yyalloc *yyptr = 1671 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 1672 if (! yyptr) 1673 goto yyexhaustedlab; 1674 YYSTACK_RELOCATE (yyss_alloc, yyss); 1675 YYSTACK_RELOCATE (yyvs_alloc, yyvs); 1676 # undef YYSTACK_RELOCATE 1677 if (yyss1 != yyssa) 1678 YYSTACK_FREE (yyss1); 1679 } 1680 # endif 1681 #endif /* no yyoverflow */ 1682 1683 yyssp = yyss + yysize - 1; 1684 yyvsp = yyvs + yysize - 1; 1685 1686 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 1687 (unsigned long int) yystacksize)); 1688 1689 if (yyss + yystacksize - 1 <= yyssp) 1690 YYABORT; 1691 } 1692 1693 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1694 1695 if (yystate == YYFINAL) 1696 YYACCEPT; 1697 1698 goto yybackup; 1699 1700 /*-----------. 1701 | yybackup. | 1702 `-----------*/ 1703 yybackup: 1704 1705 /* Do appropriate processing given the current state. Read a 1706 lookahead token if we need one and don't already have one. */ 1707 1708 /* First try to decide what to do without reference to lookahead token. */ 1709 yyn = yypact[yystate]; 1710 if (yypact_value_is_default (yyn)) 1711 goto yydefault; 1712 1713 /* Not known => get a lookahead token if don't already have one. */ 1714 1715 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 1716 if (yychar == YYEMPTY) 1717 { 1718 YYDPRINTF ((stderr, "Reading a token: ")); 1719 yychar = YYLEX; 1720 } 1721 1722 if (yychar <= YYEOF) 1723 { 1724 yychar = yytoken = YYEOF; 1725 YYDPRINTF ((stderr, "Now at end of input.\n")); 1726 } 1727 else 1728 { 1729 yytoken = YYTRANSLATE (yychar); 1730 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1731 } 1732 1733 /* If the proper action on seeing token YYTOKEN is to reduce or to 1734 detect an error, take that action. */ 1735 yyn += yytoken; 1736 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 1737 goto yydefault; 1738 yyn = yytable[yyn]; 1739 if (yyn <= 0) 1740 { 1741 if (yytable_value_is_error (yyn)) 1742 goto yyerrlab; 1743 yyn = -yyn; 1744 goto yyreduce; 1745 } 1746 1747 /* Count tokens shifted since error; after three, turn off error 1748 status. */ 1749 if (yyerrstatus) 1750 yyerrstatus--; 1751 1752 /* Shift the lookahead token. */ 1753 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1754 1755 /* Discard the shifted token. */ 1756 yychar = YYEMPTY; 1757 1758 yystate = yyn; 1759 *++yyvsp = yylval; 1760 1761 goto yynewstate; 1762 1763 1764 /*-----------------------------------------------------------. 1765 | yydefault -- do the default action for the current state. | 1766 `-----------------------------------------------------------*/ 1767 yydefault: 1768 yyn = yydefact[yystate]; 1769 if (yyn == 0) 1770 goto yyerrlab; 1771 goto yyreduce; 1772 1773 1774 /*-----------------------------. 1775 | yyreduce -- Do a reduction. | 1776 `-----------------------------*/ 1777 yyreduce: 1778 /* yyn is the number of a rule to reduce with. */ 1779 yylen = yyr2[yyn]; 1780 1781 /* If YYLEN is nonzero, implement the default value of the action: 1782 `$$ = $1'. 1783 1784 Otherwise, the following line sets YYVAL to garbage. 1785 This behavior is undocumented and Bison 1786 users should not rely upon it. Assigning to YYVAL 1787 unconditionally makes the parser a bit smaller, and it avoids a 1788 GCC warning that YYVAL may be used uninitialized. */ 1789 yyval = yyvsp[1-yylen]; 1790 1791 1792 YY_REDUCE_PRINT (yyn); 1793 switch (yyn) 1794 { 1795 case 3: 1796 1797 /* Line 1806 of yacc.c */ 1798 #line 70 "a.y" 1799 { 1800 stmtline = lineno; 1801 } 1802 break; 1803 1804 case 5: 1805 1806 /* Line 1806 of yacc.c */ 1807 #line 77 "a.y" 1808 { 1809 if((yyvsp[(1) - (2)].sym)->value != pc) 1810 yyerror("redeclaration of %s", (yyvsp[(1) - (2)].sym)->name); 1811 (yyvsp[(1) - (2)].sym)->value = pc; 1812 } 1813 break; 1814 1815 case 7: 1816 1817 /* Line 1806 of yacc.c */ 1818 #line 84 "a.y" 1819 { 1820 (yyvsp[(1) - (2)].sym)->type = LLAB; 1821 (yyvsp[(1) - (2)].sym)->value = pc; 1822 } 1823 break; 1824 1825 case 9: 1826 1827 /* Line 1806 of yacc.c */ 1828 #line 90 "a.y" 1829 { 1830 (yyvsp[(1) - (4)].sym)->type = LVAR; 1831 (yyvsp[(1) - (4)].sym)->value = (yyvsp[(3) - (4)].lval); 1832 } 1833 break; 1834 1835 case 10: 1836 1837 /* Line 1806 of yacc.c */ 1838 #line 95 "a.y" 1839 { 1840 if((yyvsp[(1) - (4)].sym)->value != (yyvsp[(3) - (4)].lval)) 1841 yyerror("redeclaration of %s", (yyvsp[(1) - (4)].sym)->name); 1842 (yyvsp[(1) - (4)].sym)->value = (yyvsp[(3) - (4)].lval); 1843 } 1844 break; 1845 1846 case 14: 1847 1848 /* Line 1806 of yacc.c */ 1849 #line 109 "a.y" 1850 { 1851 outcode((yyvsp[(1) - (7)].lval), (yyvsp[(2) - (7)].lval), &(yyvsp[(3) - (7)].gen), (yyvsp[(5) - (7)].lval), &(yyvsp[(7) - (7)].gen)); 1852 } 1853 break; 1854 1855 case 15: 1856 1857 /* Line 1806 of yacc.c */ 1858 #line 113 "a.y" 1859 { 1860 outcode((yyvsp[(1) - (6)].lval), (yyvsp[(2) - (6)].lval), &(yyvsp[(3) - (6)].gen), (yyvsp[(5) - (6)].lval), &nullgen); 1861 } 1862 break; 1863 1864 case 16: 1865 1866 /* Line 1806 of yacc.c */ 1867 #line 117 "a.y" 1868 { 1869 outcode((yyvsp[(1) - (5)].lval), (yyvsp[(2) - (5)].lval), &(yyvsp[(3) - (5)].gen), NREG, &(yyvsp[(5) - (5)].gen)); 1870 } 1871 break; 1872 1873 case 17: 1874 1875 /* Line 1806 of yacc.c */ 1876 #line 124 "a.y" 1877 { 1878 outcode((yyvsp[(1) - (5)].lval), (yyvsp[(2) - (5)].lval), &(yyvsp[(3) - (5)].gen), NREG, &(yyvsp[(5) - (5)].gen)); 1879 } 1880 break; 1881 1882 case 18: 1883 1884 /* Line 1806 of yacc.c */ 1885 #line 131 "a.y" 1886 { 1887 outcode((yyvsp[(1) - (5)].lval), (yyvsp[(2) - (5)].lval), &(yyvsp[(3) - (5)].gen), NREG, &(yyvsp[(5) - (5)].gen)); 1888 } 1889 break; 1890 1891 case 19: 1892 1893 /* Line 1806 of yacc.c */ 1894 #line 138 "a.y" 1895 { 1896 outcode((yyvsp[(1) - (4)].lval), (yyvsp[(2) - (4)].lval), &nullgen, NREG, &(yyvsp[(4) - (4)].gen)); 1897 } 1898 break; 1899 1900 case 20: 1901 1902 /* Line 1806 of yacc.c */ 1903 #line 142 "a.y" 1904 { 1905 outcode((yyvsp[(1) - (4)].lval), (yyvsp[(2) - (4)].lval), &nullgen, NREG, &(yyvsp[(4) - (4)].gen)); 1906 } 1907 break; 1908 1909 case 21: 1910 1911 /* Line 1806 of yacc.c */ 1912 #line 149 "a.y" 1913 { 1914 outcode((yyvsp[(1) - (3)].lval), Always, &nullgen, NREG, &(yyvsp[(3) - (3)].gen)); 1915 } 1916 break; 1917 1918 case 22: 1919 1920 /* Line 1806 of yacc.c */ 1921 #line 156 "a.y" 1922 { 1923 outcode((yyvsp[(1) - (3)].lval), Always, &nullgen, NREG, &(yyvsp[(3) - (3)].gen)); 1924 } 1925 break; 1926 1927 case 23: 1928 1929 /* Line 1806 of yacc.c */ 1930 #line 163 "a.y" 1931 { 1932 outcode((yyvsp[(1) - (4)].lval), (yyvsp[(2) - (4)].lval), &nullgen, NREG, &(yyvsp[(4) - (4)].gen)); 1933 } 1934 break; 1935 1936 case 24: 1937 1938 /* Line 1806 of yacc.c */ 1939 #line 170 "a.y" 1940 { 1941 outcode((yyvsp[(1) - (6)].lval), (yyvsp[(2) - (6)].lval), &(yyvsp[(3) - (6)].gen), (yyvsp[(5) - (6)].lval), &nullgen); 1942 } 1943 break; 1944 1945 case 25: 1946 1947 /* Line 1806 of yacc.c */ 1948 #line 177 "a.y" 1949 { 1950 Gen g; 1951 1952 g = nullgen; 1953 g.type = D_CONST; 1954 g.offset = (yyvsp[(6) - (7)].lval); 1955 outcode((yyvsp[(1) - (7)].lval), (yyvsp[(2) - (7)].lval), &(yyvsp[(3) - (7)].gen), NREG, &g); 1956 } 1957 break; 1958 1959 case 26: 1960 1961 /* Line 1806 of yacc.c */ 1962 #line 186 "a.y" 1963 { 1964 Gen g; 1965 1966 g = nullgen; 1967 g.type = D_CONST; 1968 g.offset = (yyvsp[(4) - (7)].lval); 1969 outcode((yyvsp[(1) - (7)].lval), (yyvsp[(2) - (7)].lval), &g, NREG, &(yyvsp[(7) - (7)].gen)); 1970 } 1971 break; 1972 1973 case 27: 1974 1975 /* Line 1806 of yacc.c */ 1976 #line 198 "a.y" 1977 { 1978 outcode((yyvsp[(1) - (7)].lval), (yyvsp[(2) - (7)].lval), &(yyvsp[(5) - (7)].gen), (yyvsp[(3) - (7)].gen).reg, &(yyvsp[(7) - (7)].gen)); 1979 } 1980 break; 1981 1982 case 28: 1983 1984 /* Line 1806 of yacc.c */ 1985 #line 202 "a.y" 1986 { 1987 outcode((yyvsp[(1) - (6)].lval), (yyvsp[(2) - (6)].lval), &(yyvsp[(5) - (6)].gen), (yyvsp[(3) - (6)].gen).reg, &(yyvsp[(3) - (6)].gen)); 1988 } 1989 break; 1990 1991 case 29: 1992 1993 /* Line 1806 of yacc.c */ 1994 #line 206 "a.y" 1995 { 1996 outcode((yyvsp[(1) - (6)].lval), (yyvsp[(2) - (6)].lval), &(yyvsp[(4) - (6)].gen), (yyvsp[(6) - (6)].gen).reg, &(yyvsp[(6) - (6)].gen)); 1997 } 1998 break; 1999 2000 case 30: 2001 2002 /* Line 1806 of yacc.c */ 2003 #line 213 "a.y" 2004 { 2005 outcode((yyvsp[(1) - (3)].lval), (yyvsp[(2) - (3)].lval), &nullgen, NREG, &nullgen); 2006 } 2007 break; 2008 2009 case 31: 2010 2011 /* Line 1806 of yacc.c */ 2012 #line 220 "a.y" 2013 { 2014 (yyvsp[(4) - (4)].gen).type = D_CONST2; 2015 (yyvsp[(4) - (4)].gen).offset2 = ArgsSizeUnknown; 2016 outcode((yyvsp[(1) - (4)].lval), Always, &(yyvsp[(2) - (4)].gen), 0, &(yyvsp[(4) - (4)].gen)); 2017 } 2018 break; 2019 2020 case 32: 2021 2022 /* Line 1806 of yacc.c */ 2023 #line 226 "a.y" 2024 { 2025 (yyvsp[(6) - (6)].gen).type = D_CONST2; 2026 (yyvsp[(6) - (6)].gen).offset2 = ArgsSizeUnknown; 2027 outcode((yyvsp[(1) - (6)].lval), Always, &(yyvsp[(2) - (6)].gen), (yyvsp[(4) - (6)].lval), &(yyvsp[(6) - (6)].gen)); 2028 } 2029 break; 2030 2031 case 33: 2032 2033 /* Line 1806 of yacc.c */ 2034 #line 232 "a.y" 2035 { 2036 (yyvsp[(6) - (8)].gen).type = D_CONST2; 2037 (yyvsp[(6) - (8)].gen).offset2 = (yyvsp[(8) - (8)].lval); 2038 outcode((yyvsp[(1) - (8)].lval), Always, &(yyvsp[(2) - (8)].gen), (yyvsp[(4) - (8)].lval), &(yyvsp[(6) - (8)].gen)); 2039 } 2040 break; 2041 2042 case 34: 2043 2044 /* Line 1806 of yacc.c */ 2045 #line 241 "a.y" 2046 { 2047 outcode((yyvsp[(1) - (6)].lval), Always, &(yyvsp[(2) - (6)].gen), (yyvsp[(4) - (6)].lval), &(yyvsp[(6) - (6)].gen)); 2048 } 2049 break; 2050 2051 case 35: 2052 2053 /* Line 1806 of yacc.c */ 2054 #line 248 "a.y" 2055 { 2056 outcode((yyvsp[(1) - (4)].lval), (yyvsp[(2) - (4)].lval), &(yyvsp[(3) - (4)].gen), NREG, &nullgen); 2057 } 2058 break; 2059 2060 case 36: 2061 2062 /* Line 1806 of yacc.c */ 2063 #line 255 "a.y" 2064 { 2065 outcode((yyvsp[(1) - (3)].lval), Always, &nullgen, NREG, &(yyvsp[(3) - (3)].gen)); 2066 } 2067 break; 2068 2069 case 37: 2070 2071 /* Line 1806 of yacc.c */ 2072 #line 262 "a.y" 2073 { 2074 outcode((yyvsp[(1) - (5)].lval), (yyvsp[(2) - (5)].lval), &(yyvsp[(3) - (5)].gen), NREG, &(yyvsp[(5) - (5)].gen)); 2075 } 2076 break; 2077 2078 case 38: 2079 2080 /* Line 1806 of yacc.c */ 2081 #line 266 "a.y" 2082 { 2083 outcode((yyvsp[(1) - (5)].lval), (yyvsp[(2) - (5)].lval), &(yyvsp[(3) - (5)].gen), NREG, &(yyvsp[(5) - (5)].gen)); 2084 } 2085 break; 2086 2087 case 39: 2088 2089 /* Line 1806 of yacc.c */ 2090 #line 270 "a.y" 2091 { 2092 outcode((yyvsp[(1) - (7)].lval), (yyvsp[(2) - (7)].lval), &(yyvsp[(3) - (7)].gen), (yyvsp[(5) - (7)].lval), &(yyvsp[(7) - (7)].gen)); 2093 } 2094 break; 2095 2096 case 40: 2097 2098 /* Line 1806 of yacc.c */ 2099 #line 274 "a.y" 2100 { 2101 outcode((yyvsp[(1) - (6)].lval), (yyvsp[(2) - (6)].lval), &(yyvsp[(3) - (6)].gen), (yyvsp[(5) - (6)].gen).reg, &nullgen); 2102 } 2103 break; 2104 2105 case 41: 2106 2107 /* Line 1806 of yacc.c */ 2108 #line 281 "a.y" 2109 { 2110 Gen g; 2111 2112 g = nullgen; 2113 g.type = D_CONST; 2114 g.offset = 2115 (0xe << 24) | /* opcode */ 2116 ((yyvsp[(1) - (12)].lval) << 20) | /* MCR/MRC */ 2117 ((yyvsp[(2) - (12)].lval) << 28) | /* scond */ 2118 (((yyvsp[(3) - (12)].lval) & 15) << 8) | /* coprocessor number */ 2119 (((yyvsp[(5) - (12)].lval) & 7) << 21) | /* coprocessor operation */ 2120 (((yyvsp[(7) - (12)].lval) & 15) << 12) | /* arm register */ 2121 (((yyvsp[(9) - (12)].lval) & 15) << 16) | /* Crn */ 2122 (((yyvsp[(11) - (12)].lval) & 15) << 0) | /* Crm */ 2123 (((yyvsp[(12) - (12)].lval) & 7) << 5) | /* coprocessor information */ 2124 (1<<4); /* must be set */ 2125 outcode(AWORD, Always, &nullgen, NREG, &g); 2126 } 2127 break; 2128 2129 case 42: 2130 2131 /* Line 1806 of yacc.c */ 2132 #line 303 "a.y" 2133 { 2134 outcode((yyvsp[(1) - (7)].lval), (yyvsp[(2) - (7)].lval), &(yyvsp[(3) - (7)].gen), (yyvsp[(5) - (7)].gen).reg, &(yyvsp[(7) - (7)].gen)); 2135 } 2136 break; 2137 2138 case 43: 2139 2140 /* Line 1806 of yacc.c */ 2141 #line 311 "a.y" 2142 { 2143 (yyvsp[(7) - (9)].gen).type = D_REGREG2; 2144 (yyvsp[(7) - (9)].gen).offset = (yyvsp[(9) - (9)].lval); 2145 outcode((yyvsp[(1) - (9)].lval), (yyvsp[(2) - (9)].lval), &(yyvsp[(3) - (9)].gen), (yyvsp[(5) - (9)].gen).reg, &(yyvsp[(7) - (9)].gen)); 2146 } 2147 break; 2148 2149 case 44: 2150 2151 /* Line 1806 of yacc.c */ 2152 #line 320 "a.y" 2153 { 2154 outcode((yyvsp[(1) - (2)].lval), Always, &(yyvsp[(2) - (2)].gen), NREG, &nullgen); 2155 } 2156 break; 2157 2158 case 45: 2159 2160 /* Line 1806 of yacc.c */ 2161 #line 327 "a.y" 2162 { 2163 if((yyvsp[(2) - (4)].gen).type != D_CONST || (yyvsp[(4) - (4)].gen).type != D_CONST) 2164 yyerror("arguments to PCDATA must be integer constants"); 2165 outcode((yyvsp[(1) - (4)].lval), Always, &(yyvsp[(2) - (4)].gen), NREG, &(yyvsp[(4) - (4)].gen)); 2166 } 2167 break; 2168 2169 case 46: 2170 2171 /* Line 1806 of yacc.c */ 2172 #line 336 "a.y" 2173 { 2174 if((yyvsp[(2) - (4)].gen).type != D_CONST) 2175 yyerror("index for FUNCDATA must be integer constant"); 2176 if((yyvsp[(4) - (4)].gen).type != D_EXTERN && (yyvsp[(4) - (4)].gen).type != D_STATIC) 2177 yyerror("value for FUNCDATA must be symbol reference"); 2178 outcode((yyvsp[(1) - (4)].lval), Always, &(yyvsp[(2) - (4)].gen), NREG, &(yyvsp[(4) - (4)].gen)); 2179 } 2180 break; 2181 2182 case 47: 2183 2184 /* Line 1806 of yacc.c */ 2185 #line 347 "a.y" 2186 { 2187 outcode((yyvsp[(1) - (2)].lval), Always, &nullgen, NREG, &nullgen); 2188 } 2189 break; 2190 2191 case 48: 2192 2193 /* Line 1806 of yacc.c */ 2194 #line 352 "a.y" 2195 { 2196 (yyval.lval) = Always; 2197 } 2198 break; 2199 2200 case 49: 2201 2202 /* Line 1806 of yacc.c */ 2203 #line 356 "a.y" 2204 { 2205 (yyval.lval) = ((yyvsp[(1) - (2)].lval) & ~C_SCOND) | (yyvsp[(2) - (2)].lval); 2206 } 2207 break; 2208 2209 case 50: 2210 2211 /* Line 1806 of yacc.c */ 2212 #line 360 "a.y" 2213 { 2214 (yyval.lval) = (yyvsp[(1) - (2)].lval) | (yyvsp[(2) - (2)].lval); 2215 } 2216 break; 2217 2218 case 53: 2219 2220 /* Line 1806 of yacc.c */ 2221 #line 369 "a.y" 2222 { 2223 (yyval.gen) = nullgen; 2224 (yyval.gen).type = D_BRANCH; 2225 (yyval.gen).offset = (yyvsp[(1) - (4)].lval) + pc; 2226 } 2227 break; 2228 2229 case 54: 2230 2231 /* Line 1806 of yacc.c */ 2232 #line 375 "a.y" 2233 { 2234 (yyval.gen) = nullgen; 2235 if(pass == 2) 2236 yyerror("undefined label: %s", (yyvsp[(1) - (2)].sym)->name); 2237 (yyval.gen).type = D_BRANCH; 2238 (yyval.gen).sym = (yyvsp[(1) - (2)].sym); 2239 (yyval.gen).offset = (yyvsp[(2) - (2)].lval); 2240 } 2241 break; 2242 2243 case 55: 2244 2245 /* Line 1806 of yacc.c */ 2246 #line 384 "a.y" 2247 { 2248 (yyval.gen) = nullgen; 2249 (yyval.gen).type = D_BRANCH; 2250 (yyval.gen).sym = (yyvsp[(1) - (2)].sym); 2251 (yyval.gen).offset = (yyvsp[(1) - (2)].sym)->value + (yyvsp[(2) - (2)].lval); 2252 } 2253 break; 2254 2255 case 56: 2256 2257 /* Line 1806 of yacc.c */ 2258 #line 392 "a.y" 2259 { 2260 (yyval.gen) = nullgen; 2261 (yyval.gen).type = D_CONST; 2262 (yyval.gen).offset = (yyvsp[(2) - (2)].lval); 2263 } 2264 break; 2265 2266 case 57: 2267 2268 /* Line 1806 of yacc.c */ 2269 #line 398 "a.y" 2270 { 2271 (yyval.gen) = (yyvsp[(2) - (2)].gen); 2272 (yyval.gen).type = D_CONST; 2273 } 2274 break; 2275 2276 case 58: 2277 2278 /* Line 1806 of yacc.c */ 2279 #line 403 "a.y" 2280 { 2281 (yyval.gen) = (yyvsp[(4) - (4)].gen); 2282 (yyval.gen).type = D_OCONST; 2283 } 2284 break; 2285 2286 case 59: 2287 2288 /* Line 1806 of yacc.c */ 2289 #line 408 "a.y" 2290 { 2291 (yyval.gen) = nullgen; 2292 (yyval.gen).type = D_SCONST; 2293 memcpy((yyval.gen).sval, (yyvsp[(2) - (2)].sval), sizeof((yyval.gen).sval)); 2294 } 2295 break; 2296 2297 case 61: 2298 2299 /* Line 1806 of yacc.c */ 2300 #line 417 "a.y" 2301 { 2302 (yyval.gen) = nullgen; 2303 (yyval.gen).type = D_FCONST; 2304 (yyval.gen).dval = (yyvsp[(2) - (2)].dval); 2305 } 2306 break; 2307 2308 case 62: 2309 2310 /* Line 1806 of yacc.c */ 2311 #line 423 "a.y" 2312 { 2313 (yyval.gen) = nullgen; 2314 (yyval.gen).type = D_FCONST; 2315 (yyval.gen).dval = -(yyvsp[(3) - (3)].dval); 2316 } 2317 break; 2318 2319 case 63: 2320 2321 /* Line 1806 of yacc.c */ 2322 #line 431 "a.y" 2323 { 2324 (yyval.lval) = 1 << (yyvsp[(1) - (1)].lval); 2325 } 2326 break; 2327 2328 case 64: 2329 2330 /* Line 1806 of yacc.c */ 2331 #line 435 "a.y" 2332 { 2333 int i; 2334 (yyval.lval)=0; 2335 for(i=(yyvsp[(1) - (3)].lval); i<=(yyvsp[(3) - (3)].lval); i++) 2336 (yyval.lval) |= 1<<i; 2337 for(i=(yyvsp[(3) - (3)].lval); i<=(yyvsp[(1) - (3)].lval); i++) 2338 (yyval.lval) |= 1<<i; 2339 } 2340 break; 2341 2342 case 65: 2343 2344 /* Line 1806 of yacc.c */ 2345 #line 444 "a.y" 2346 { 2347 (yyval.lval) = (1<<(yyvsp[(1) - (3)].lval)) | (yyvsp[(3) - (3)].lval); 2348 } 2349 break; 2350 2351 case 69: 2352 2353 /* Line 1806 of yacc.c */ 2354 #line 453 "a.y" 2355 { 2356 (yyval.gen) = (yyvsp[(1) - (4)].gen); 2357 (yyval.gen).reg = (yyvsp[(3) - (4)].lval); 2358 } 2359 break; 2360 2361 case 70: 2362 2363 /* Line 1806 of yacc.c */ 2364 #line 458 "a.y" 2365 { 2366 (yyval.gen) = nullgen; 2367 (yyval.gen).type = D_PSR; 2368 (yyval.gen).reg = (yyvsp[(1) - (1)].lval); 2369 } 2370 break; 2371 2372 case 71: 2373 2374 /* Line 1806 of yacc.c */ 2375 #line 464 "a.y" 2376 { 2377 (yyval.gen) = nullgen; 2378 (yyval.gen).type = D_FPCR; 2379 (yyval.gen).reg = (yyvsp[(1) - (1)].lval); 2380 } 2381 break; 2382 2383 case 72: 2384 2385 /* Line 1806 of yacc.c */ 2386 #line 470 "a.y" 2387 { 2388 (yyval.gen) = nullgen; 2389 (yyval.gen).type = D_OREG; 2390 (yyval.gen).offset = (yyvsp[(1) - (1)].lval); 2391 } 2392 break; 2393 2394 case 76: 2395 2396 /* Line 1806 of yacc.c */ 2397 #line 481 "a.y" 2398 { 2399 (yyval.gen) = (yyvsp[(1) - (1)].gen); 2400 if((yyvsp[(1) - (1)].gen).name != D_EXTERN && (yyvsp[(1) - (1)].gen).name != D_STATIC) { 2401 } 2402 } 2403 break; 2404 2405 case 77: 2406 2407 /* Line 1806 of yacc.c */ 2408 #line 489 "a.y" 2409 { 2410 (yyval.gen) = nullgen; 2411 (yyval.gen).type = D_OREG; 2412 (yyval.gen).reg = (yyvsp[(2) - (3)].lval); 2413 (yyval.gen).offset = 0; 2414 } 2415 break; 2416 2417 case 79: 2418 2419 /* Line 1806 of yacc.c */ 2420 #line 499 "a.y" 2421 { 2422 (yyval.gen) = nullgen; 2423 (yyval.gen).type = D_OREG; 2424 (yyval.gen).reg = (yyvsp[(3) - (4)].lval); 2425 (yyval.gen).offset = (yyvsp[(1) - (4)].lval); 2426 } 2427 break; 2428 2429 case 81: 2430 2431 /* Line 1806 of yacc.c */ 2432 #line 509 "a.y" 2433 { 2434 (yyval.gen) = (yyvsp[(1) - (4)].gen); 2435 (yyval.gen).type = D_OREG; 2436 (yyval.gen).reg = (yyvsp[(3) - (4)].lval); 2437 } 2438 break; 2439 2440 case 86: 2441 2442 /* Line 1806 of yacc.c */ 2443 #line 522 "a.y" 2444 { 2445 (yyval.gen) = nullgen; 2446 (yyval.gen).type = D_CONST; 2447 (yyval.gen).offset = (yyvsp[(2) - (2)].lval); 2448 } 2449 break; 2450 2451 case 87: 2452 2453 /* Line 1806 of yacc.c */ 2454 #line 530 "a.y" 2455 { 2456 (yyval.gen) = nullgen; 2457 (yyval.gen).type = D_REG; 2458 (yyval.gen).reg = (yyvsp[(1) - (1)].lval); 2459 } 2460 break; 2461 2462 case 88: 2463 2464 /* Line 1806 of yacc.c */ 2465 #line 538 "a.y" 2466 { 2467 (yyval.gen) = nullgen; 2468 (yyval.gen).type = D_REGREG; 2469 (yyval.gen).reg = (yyvsp[(2) - (5)].lval); 2470 (yyval.gen).offset = (yyvsp[(4) - (5)].lval); 2471 } 2472 break; 2473 2474 case 89: 2475 2476 /* Line 1806 of yacc.c */ 2477 #line 547 "a.y" 2478 { 2479 (yyval.gen) = nullgen; 2480 (yyval.gen).type = D_SHIFT; 2481 (yyval.gen).offset = (yyvsp[(1) - (4)].lval) | (yyvsp[(4) - (4)].lval) | (0 << 5); 2482 } 2483 break; 2484 2485 case 90: 2486 2487 /* Line 1806 of yacc.c */ 2488 #line 553 "a.y" 2489 { 2490 (yyval.gen) = nullgen; 2491 (yyval.gen).type = D_SHIFT; 2492 (yyval.gen).offset = (yyvsp[(1) - (4)].lval) | (yyvsp[(4) - (4)].lval) | (1 << 5); 2493 } 2494 break; 2495 2496 case 91: 2497 2498 /* Line 1806 of yacc.c */ 2499 #line 559 "a.y" 2500 { 2501 (yyval.gen) = nullgen; 2502 (yyval.gen).type = D_SHIFT; 2503 (yyval.gen).offset = (yyvsp[(1) - (4)].lval) | (yyvsp[(4) - (4)].lval) | (2 << 5); 2504 } 2505 break; 2506 2507 case 92: 2508 2509 /* Line 1806 of yacc.c */ 2510 #line 565 "a.y" 2511 { 2512 (yyval.gen) = nullgen; 2513 (yyval.gen).type = D_SHIFT; 2514 (yyval.gen).offset = (yyvsp[(1) - (4)].lval) | (yyvsp[(4) - (4)].lval) | (3 << 5); 2515 } 2516 break; 2517 2518 case 93: 2519 2520 /* Line 1806 of yacc.c */ 2521 #line 573 "a.y" 2522 { 2523 if((yyval.lval) < 0 || (yyval.lval) >= 16) 2524 print("register value out of range\n"); 2525 (yyval.lval) = (((yyvsp[(1) - (1)].lval)&15) << 8) | (1 << 4); 2526 } 2527 break; 2528 2529 case 94: 2530 2531 /* Line 1806 of yacc.c */ 2532 #line 579 "a.y" 2533 { 2534 if((yyval.lval) < 0 || (yyval.lval) >= 32) 2535 print("shift value out of range\n"); 2536 (yyval.lval) = ((yyvsp[(1) - (1)].lval)&31) << 7; 2537 } 2538 break; 2539 2540 case 96: 2541 2542 /* Line 1806 of yacc.c */ 2543 #line 588 "a.y" 2544 { 2545 (yyval.lval) = REGPC; 2546 } 2547 break; 2548 2549 case 97: 2550 2551 /* Line 1806 of yacc.c */ 2552 #line 592 "a.y" 2553 { 2554 if((yyvsp[(3) - (4)].lval) < 0 || (yyvsp[(3) - (4)].lval) >= NREG) 2555 print("register value out of range\n"); 2556 (yyval.lval) = (yyvsp[(3) - (4)].lval); 2557 } 2558 break; 2559 2560 case 99: 2561 2562 /* Line 1806 of yacc.c */ 2563 #line 601 "a.y" 2564 { 2565 (yyval.lval) = REGSP; 2566 } 2567 break; 2568 2569 case 101: 2570 2571 /* Line 1806 of yacc.c */ 2572 #line 608 "a.y" 2573 { 2574 if((yyvsp[(3) - (4)].lval) < 0 || (yyvsp[(3) - (4)].lval) >= NREG) 2575 print("register value out of range\n"); 2576 (yyval.lval) = (yyvsp[(3) - (4)].lval); 2577 } 2578 break; 2579 2580 case 104: 2581 2582 /* Line 1806 of yacc.c */ 2583 #line 620 "a.y" 2584 { 2585 (yyval.gen) = nullgen; 2586 (yyval.gen).type = D_FREG; 2587 (yyval.gen).reg = (yyvsp[(1) - (1)].lval); 2588 } 2589 break; 2590 2591 case 105: 2592 2593 /* Line 1806 of yacc.c */ 2594 #line 626 "a.y" 2595 { 2596 (yyval.gen) = nullgen; 2597 (yyval.gen).type = D_FREG; 2598 (yyval.gen).reg = (yyvsp[(3) - (4)].lval); 2599 } 2600 break; 2601 2602 case 106: 2603 2604 /* Line 1806 of yacc.c */ 2605 #line 634 "a.y" 2606 { 2607 (yyval.gen) = nullgen; 2608 (yyval.gen).type = D_OREG; 2609 (yyval.gen).name = (yyvsp[(3) - (4)].lval); 2610 (yyval.gen).sym = S; 2611 (yyval.gen).offset = (yyvsp[(1) - (4)].lval); 2612 } 2613 break; 2614 2615 case 107: 2616 2617 /* Line 1806 of yacc.c */ 2618 #line 642 "a.y" 2619 { 2620 (yyval.gen) = nullgen; 2621 (yyval.gen).type = D_OREG; 2622 (yyval.gen).name = (yyvsp[(4) - (5)].lval); 2623 (yyval.gen).sym = (yyvsp[(1) - (5)].sym); 2624 (yyval.gen).offset = (yyvsp[(2) - (5)].lval); 2625 } 2626 break; 2627 2628 case 108: 2629 2630 /* Line 1806 of yacc.c */ 2631 #line 650 "a.y" 2632 { 2633 (yyval.gen) = nullgen; 2634 (yyval.gen).type = D_OREG; 2635 (yyval.gen).name = D_STATIC; 2636 (yyval.gen).sym = (yyvsp[(1) - (7)].sym); 2637 (yyval.gen).offset = (yyvsp[(4) - (7)].lval); 2638 } 2639 break; 2640 2641 case 109: 2642 2643 /* Line 1806 of yacc.c */ 2644 #line 659 "a.y" 2645 { 2646 (yyval.lval) = 0; 2647 } 2648 break; 2649 2650 case 110: 2651 2652 /* Line 1806 of yacc.c */ 2653 #line 663 "a.y" 2654 { 2655 (yyval.lval) = (yyvsp[(2) - (2)].lval); 2656 } 2657 break; 2658 2659 case 111: 2660 2661 /* Line 1806 of yacc.c */ 2662 #line 667 "a.y" 2663 { 2664 (yyval.lval) = -(yyvsp[(2) - (2)].lval); 2665 } 2666 break; 2667 2668 case 116: 2669 2670 /* Line 1806 of yacc.c */ 2671 #line 679 "a.y" 2672 { 2673 (yyval.lval) = (yyvsp[(1) - (1)].sym)->value; 2674 } 2675 break; 2676 2677 case 117: 2678 2679 /* Line 1806 of yacc.c */ 2680 #line 683 "a.y" 2681 { 2682 (yyval.lval) = -(yyvsp[(2) - (2)].lval); 2683 } 2684 break; 2685 2686 case 118: 2687 2688 /* Line 1806 of yacc.c */ 2689 #line 687 "a.y" 2690 { 2691 (yyval.lval) = (yyvsp[(2) - (2)].lval); 2692 } 2693 break; 2694 2695 case 119: 2696 2697 /* Line 1806 of yacc.c */ 2698 #line 691 "a.y" 2699 { 2700 (yyval.lval) = ~(yyvsp[(2) - (2)].lval); 2701 } 2702 break; 2703 2704 case 120: 2705 2706 /* Line 1806 of yacc.c */ 2707 #line 695 "a.y" 2708 { 2709 (yyval.lval) = (yyvsp[(2) - (3)].lval); 2710 } 2711 break; 2712 2713 case 121: 2714 2715 /* Line 1806 of yacc.c */ 2716 #line 700 "a.y" 2717 { 2718 (yyval.lval) = 0; 2719 } 2720 break; 2721 2722 case 122: 2723 2724 /* Line 1806 of yacc.c */ 2725 #line 704 "a.y" 2726 { 2727 (yyval.lval) = (yyvsp[(2) - (2)].lval); 2728 } 2729 break; 2730 2731 case 124: 2732 2733 /* Line 1806 of yacc.c */ 2734 #line 711 "a.y" 2735 { 2736 (yyval.lval) = (yyvsp[(1) - (3)].lval) + (yyvsp[(3) - (3)].lval); 2737 } 2738 break; 2739 2740 case 125: 2741 2742 /* Line 1806 of yacc.c */ 2743 #line 715 "a.y" 2744 { 2745 (yyval.lval) = (yyvsp[(1) - (3)].lval) - (yyvsp[(3) - (3)].lval); 2746 } 2747 break; 2748 2749 case 126: 2750 2751 /* Line 1806 of yacc.c */ 2752 #line 719 "a.y" 2753 { 2754 (yyval.lval) = (yyvsp[(1) - (3)].lval) * (yyvsp[(3) - (3)].lval); 2755 } 2756 break; 2757 2758 case 127: 2759 2760 /* Line 1806 of yacc.c */ 2761 #line 723 "a.y" 2762 { 2763 (yyval.lval) = (yyvsp[(1) - (3)].lval) / (yyvsp[(3) - (3)].lval); 2764 } 2765 break; 2766 2767 case 128: 2768 2769 /* Line 1806 of yacc.c */ 2770 #line 727 "a.y" 2771 { 2772 (yyval.lval) = (yyvsp[(1) - (3)].lval) % (yyvsp[(3) - (3)].lval); 2773 } 2774 break; 2775 2776 case 129: 2777 2778 /* Line 1806 of yacc.c */ 2779 #line 731 "a.y" 2780 { 2781 (yyval.lval) = (yyvsp[(1) - (4)].lval) << (yyvsp[(4) - (4)].lval); 2782 } 2783 break; 2784 2785 case 130: 2786 2787 /* Line 1806 of yacc.c */ 2788 #line 735 "a.y" 2789 { 2790 (yyval.lval) = (yyvsp[(1) - (4)].lval) >> (yyvsp[(4) - (4)].lval); 2791 } 2792 break; 2793 2794 case 131: 2795 2796 /* Line 1806 of yacc.c */ 2797 #line 739 "a.y" 2798 { 2799 (yyval.lval) = (yyvsp[(1) - (3)].lval) & (yyvsp[(3) - (3)].lval); 2800 } 2801 break; 2802 2803 case 132: 2804 2805 /* Line 1806 of yacc.c */ 2806 #line 743 "a.y" 2807 { 2808 (yyval.lval) = (yyvsp[(1) - (3)].lval) ^ (yyvsp[(3) - (3)].lval); 2809 } 2810 break; 2811 2812 case 133: 2813 2814 /* Line 1806 of yacc.c */ 2815 #line 747 "a.y" 2816 { 2817 (yyval.lval) = (yyvsp[(1) - (3)].lval) | (yyvsp[(3) - (3)].lval); 2818 } 2819 break; 2820 2821 2822 2823 /* Line 1806 of yacc.c */ 2824 #line 2825 "y.tab.c" 2825 default: break; 2826 } 2827 /* User semantic actions sometimes alter yychar, and that requires 2828 that yytoken be updated with the new translation. We take the 2829 approach of translating immediately before every use of yytoken. 2830 One alternative is translating here after every semantic action, 2831 but that translation would be missed if the semantic action invokes 2832 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 2833 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 2834 incorrect destructor might then be invoked immediately. In the 2835 case of YYERROR or YYBACKUP, subsequent parser actions might lead 2836 to an incorrect destructor call or verbose syntax error message 2837 before the lookahead is translated. */ 2838 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 2839 2840 YYPOPSTACK (yylen); 2841 yylen = 0; 2842 YY_STACK_PRINT (yyss, yyssp); 2843 2844 *++yyvsp = yyval; 2845 2846 /* Now `shift' the result of the reduction. Determine what state 2847 that goes to, based on the state we popped back to and the rule 2848 number reduced by. */ 2849 2850 yyn = yyr1[yyn]; 2851 2852 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 2853 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 2854 yystate = yytable[yystate]; 2855 else 2856 yystate = yydefgoto[yyn - YYNTOKENS]; 2857 2858 goto yynewstate; 2859 2860 2861 /*------------------------------------. 2862 | yyerrlab -- here on detecting error | 2863 `------------------------------------*/ 2864 yyerrlab: 2865 /* Make sure we have latest lookahead translation. See comments at 2866 user semantic actions for why this is necessary. */ 2867 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); 2868 2869 /* If not already recovering from an error, report this error. */ 2870 if (!yyerrstatus) 2871 { 2872 ++yynerrs; 2873 #if ! YYERROR_VERBOSE 2874 yyerror (YY_("syntax error")); 2875 #else 2876 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ 2877 yyssp, yytoken) 2878 { 2879 char const *yymsgp = YY_("syntax error"); 2880 int yysyntax_error_status; 2881 yysyntax_error_status = YYSYNTAX_ERROR; 2882 if (yysyntax_error_status == 0) 2883 yymsgp = yymsg; 2884 else if (yysyntax_error_status == 1) 2885 { 2886 if (yymsg != yymsgbuf) 2887 YYSTACK_FREE (yymsg); 2888 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); 2889 if (!yymsg) 2890 { 2891 yymsg = yymsgbuf; 2892 yymsg_alloc = sizeof yymsgbuf; 2893 yysyntax_error_status = 2; 2894 } 2895 else 2896 { 2897 yysyntax_error_status = YYSYNTAX_ERROR; 2898 yymsgp = yymsg; 2899 } 2900 } 2901 yyerror (yymsgp); 2902 if (yysyntax_error_status == 2) 2903 goto yyexhaustedlab; 2904 } 2905 # undef YYSYNTAX_ERROR 2906 #endif 2907 } 2908 2909 2910 2911 if (yyerrstatus == 3) 2912 { 2913 /* If just tried and failed to reuse lookahead token after an 2914 error, discard it. */ 2915 2916 if (yychar <= YYEOF) 2917 { 2918 /* Return failure if at end of input. */ 2919 if (yychar == YYEOF) 2920 YYABORT; 2921 } 2922 else 2923 { 2924 yydestruct ("Error: discarding", 2925 yytoken, &yylval); 2926 yychar = YYEMPTY; 2927 } 2928 } 2929 2930 /* Else will try to reuse lookahead token after shifting the error 2931 token. */ 2932 goto yyerrlab1; 2933 2934 2935 /*---------------------------------------------------. 2936 | yyerrorlab -- error raised explicitly by YYERROR. | 2937 `---------------------------------------------------*/ 2938 yyerrorlab: 2939 2940 /* Pacify compilers like GCC when the user code never invokes 2941 YYERROR and the label yyerrorlab therefore never appears in user 2942 code. */ 2943 if (/*CONSTCOND*/ 0) 2944 goto yyerrorlab; 2945 2946 /* Do not reclaim the symbols of the rule which action triggered 2947 this YYERROR. */ 2948 YYPOPSTACK (yylen); 2949 yylen = 0; 2950 YY_STACK_PRINT (yyss, yyssp); 2951 yystate = *yyssp; 2952 goto yyerrlab1; 2953 2954 2955 /*-------------------------------------------------------------. 2956 | yyerrlab1 -- common code for both syntax error and YYERROR. | 2957 `-------------------------------------------------------------*/ 2958 yyerrlab1: 2959 yyerrstatus = 3; /* Each real token shifted decrements this. */ 2960 2961 for (;;) 2962 { 2963 yyn = yypact[yystate]; 2964 if (!yypact_value_is_default (yyn)) 2965 { 2966 yyn += YYTERROR; 2967 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 2968 { 2969 yyn = yytable[yyn]; 2970 if (0 < yyn) 2971 break; 2972 } 2973 } 2974 2975 /* Pop the current state because it cannot handle the error token. */ 2976 if (yyssp == yyss) 2977 YYABORT; 2978 2979 2980 yydestruct ("Error: popping", 2981 yystos[yystate], yyvsp); 2982 YYPOPSTACK (1); 2983 yystate = *yyssp; 2984 YY_STACK_PRINT (yyss, yyssp); 2985 } 2986 2987 *++yyvsp = yylval; 2988 2989 2990 /* Shift the error token. */ 2991 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 2992 2993 yystate = yyn; 2994 goto yynewstate; 2995 2996 2997 /*-------------------------------------. 2998 | yyacceptlab -- YYACCEPT comes here. | 2999 `-------------------------------------*/ 3000 yyacceptlab: 3001 yyresult = 0; 3002 goto yyreturn; 3003 3004 /*-----------------------------------. 3005 | yyabortlab -- YYABORT comes here. | 3006 `-----------------------------------*/ 3007 yyabortlab: 3008 yyresult = 1; 3009 goto yyreturn; 3010 3011 #if !defined(yyoverflow) || YYERROR_VERBOSE 3012 /*-------------------------------------------------. 3013 | yyexhaustedlab -- memory exhaustion comes here. | 3014 `-------------------------------------------------*/ 3015 yyexhaustedlab: 3016 yyerror (YY_("memory exhausted")); 3017 yyresult = 2; 3018 /* Fall through. */ 3019 #endif 3020 3021 yyreturn: 3022 if (yychar != YYEMPTY) 3023 { 3024 /* Make sure we have latest lookahead translation. See comments at 3025 user semantic actions for why this is necessary. */ 3026 yytoken = YYTRANSLATE (yychar); 3027 yydestruct ("Cleanup: discarding lookahead", 3028 yytoken, &yylval); 3029 } 3030 /* Do not reclaim the symbols of the rule which action triggered 3031 this YYABORT or YYACCEPT. */ 3032 YYPOPSTACK (yylen); 3033 YY_STACK_PRINT (yyss, yyssp); 3034 while (yyssp != yyss) 3035 { 3036 yydestruct ("Cleanup: popping", 3037 yystos[*yyssp], yyvsp); 3038 YYPOPSTACK (1); 3039 } 3040 #ifndef yyoverflow 3041 if (yyss != yyssa) 3042 YYSTACK_FREE (yyss); 3043 #endif 3044 #if YYERROR_VERBOSE 3045 if (yymsg != yymsgbuf) 3046 YYSTACK_FREE (yymsg); 3047 #endif 3048 /* Make sure YYID is used. */ 3049 return YYID (yyresult); 3050 } 3051 3052 3053