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