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