m68k-parse.c revision 1.1.1.2
1 /* A Bison parser, made by GNU Bison 3.8.2. */ 2 3 /* Bison implementation for Yacc-like parsers in C 4 5 Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation, 6 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 3 of the License, or 11 (at your option) 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, see <https://www.gnu.org/licenses/>. */ 20 21 /* As a special exception, you may create a larger work that contains 22 part or all of the Bison parser skeleton and distribute that work 23 under terms of your choice, so long as that work isn't itself a 24 parser generator using the skeleton or a modified version thereof 25 as a parser skeleton. Alternatively, if you modify or redistribute 26 the parser skeleton itself, you may (at your option) remove this 27 special exception, which will cause the skeleton and the resulting 28 Bison output files to be licensed under the GNU General Public 29 License without this special exception. 30 31 This special exception was added by the Free Software Foundation in 32 version 2.2 of Bison. */ 33 34 /* C LALR(1) parser skeleton written by Richard Stallman, by 35 simplifying the original so-called "semantic" parser. */ 36 37 /* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual, 38 especially those whose name start with YY_ or yy_. They are 39 private implementation details that can be changed or removed. */ 40 41 /* All symbols defined below should begin with yy or YY, to avoid 42 infringing on user name space. This should be done even for local 43 variables, as they might otherwise be expanded by user macros. 44 There are some unavoidable exceptions within include files to 45 define necessary library symbols; they are noted "INFRINGES ON 46 USER NAME SPACE" below. */ 47 48 /* Identify Bison output, and Bison version. */ 49 #define YYBISON 30802 50 51 /* Bison version string. */ 52 #define YYBISON_VERSION "3.8.2" 53 54 /* Skeleton name. */ 55 #define YYSKELETON_NAME "yacc.c" 56 57 /* Pure parsers. */ 58 #define YYPURE 0 59 60 /* Push parsers. */ 61 #define YYPUSH 0 62 63 /* Pull parsers. */ 64 #define YYPULL 1 65 66 67 68 69 /* First part of user prologue. */ 70 #line 27 "./config/m68k-parse.y" 71 72 73 #include "as.h" 74 #include "tc-m68k.h" 75 #include "m68k-parse.h" 76 #include "safe-ctype.h" 77 78 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, 79 etc), as well as gratuitously global symbol names If other parser 80 generators (bison, byacc, etc) produce additional global names that 81 conflict at link time, then those parser generators need to be 82 fixed instead of adding those names to this list. */ 83 84 #define yymaxdepth m68k_maxdepth 85 #define yyparse m68k_parse 86 #define yylex m68k_lex 87 #define yyerror m68k_error 88 #define yylval m68k_lval 89 #define yychar m68k_char 90 #define yydebug m68k_debug 91 #define yypact m68k_pact 92 #define yyr1 m68k_r1 93 #define yyr2 m68k_r2 94 #define yydef m68k_def 95 #define yychk m68k_chk 96 #define yypgo m68k_pgo 97 #define yyact m68k_act 98 #define yyexca m68k_exca 99 #define yyerrflag m68k_errflag 100 #define yynerrs m68k_nerrs 101 #define yyps m68k_ps 102 #define yypv m68k_pv 103 #define yys m68k_s 104 #define yy_yys m68k_yys 105 #define yystate m68k_state 106 #define yytmp m68k_tmp 107 #define yyv m68k_v 108 #define yy_yyv m68k_yyv 109 #define yyval m68k_val 110 #define yylloc m68k_lloc 111 #define yyreds m68k_reds /* With YYDEBUG defined */ 112 #define yytoks m68k_toks /* With YYDEBUG defined */ 113 #define yylhs m68k_yylhs 114 #define yylen m68k_yylen 115 #define yydefred m68k_yydefred 116 #define yydgoto m68k_yydgoto 117 #define yysindex m68k_yysindex 118 #define yyrindex m68k_yyrindex 119 #define yygindex m68k_yygindex 120 #define yytable m68k_yytable 121 #define yycheck m68k_yycheck 122 123 #ifndef YYDEBUG 124 #define YYDEBUG 1 125 #endif 126 127 /* Internal functions. */ 128 129 static enum m68k_register m68k_reg_parse (char **); 130 static int yylex (void); 131 static void yyerror (const char *); 132 133 /* The parser sets fields pointed to by this global variable. */ 134 static struct m68k_op *op; 135 136 137 #line 138 "config/m68k-parse.c" 138 139 # ifndef YY_CAST 140 # ifdef __cplusplus 141 # define YY_CAST(Type, Val) static_cast<Type> (Val) 142 # define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val) 143 # else 144 # define YY_CAST(Type, Val) ((Type) (Val)) 145 # define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val)) 146 # endif 147 # endif 148 # ifndef YY_NULLPTR 149 # if defined __cplusplus 150 # if 201103L <= __cplusplus 151 # define YY_NULLPTR nullptr 152 # else 153 # define YY_NULLPTR 0 154 # endif 155 # else 156 # define YY_NULLPTR ((void*)0) 157 # endif 158 # endif 159 160 161 /* Debug traces. */ 162 #ifndef YYDEBUG 163 # define YYDEBUG 0 164 #endif 165 #if YYDEBUG 166 extern int yydebug; 167 #endif 168 169 /* Token kinds. */ 170 #ifndef YYTOKENTYPE 171 # define YYTOKENTYPE 172 enum yytokentype 173 { 174 YYEMPTY = -2, 175 YYEOF = 0, /* "end of file" */ 176 YYerror = 256, /* error */ 177 YYUNDEF = 257, /* "invalid token" */ 178 DR = 258, /* DR */ 179 AR = 259, /* AR */ 180 FPR = 260, /* FPR */ 181 FPCR = 261, /* FPCR */ 182 LPC = 262, /* LPC */ 183 ZAR = 263, /* ZAR */ 184 ZDR = 264, /* ZDR */ 185 LZPC = 265, /* LZPC */ 186 CREG = 266, /* CREG */ 187 INDEXREG = 267, /* INDEXREG */ 188 EXPR = 268 /* EXPR */ 189 }; 190 typedef enum yytokentype yytoken_kind_t; 191 #endif 192 /* Token kinds. */ 193 #define YYEMPTY -2 194 #define YYEOF 0 195 #define YYerror 256 196 #define YYUNDEF 257 197 #define DR 258 198 #define AR 259 199 #define FPR 260 200 #define FPCR 261 201 #define LPC 262 202 #define ZAR 263 203 #define ZDR 264 204 #define LZPC 265 205 #define CREG 266 206 #define INDEXREG 267 207 #define EXPR 268 208 209 /* Value type. */ 210 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 211 union YYSTYPE 212 { 213 #line 95 "./config/m68k-parse.y" 214 215 struct m68k_indexreg indexreg; 216 enum m68k_register reg; 217 struct m68k_exp exp; 218 unsigned long mask; 219 int onereg; 220 int trailing_ampersand; 221 222 #line 223 "config/m68k-parse.c" 223 224 }; 225 typedef union YYSTYPE YYSTYPE; 226 # define YYSTYPE_IS_TRIVIAL 1 227 # define YYSTYPE_IS_DECLARED 1 228 #endif 229 230 231 extern YYSTYPE yylval; 232 233 234 int yyparse (void); 235 236 237 238 /* Symbol kind. */ 239 enum yysymbol_kind_t 240 { 241 YYSYMBOL_YYEMPTY = -2, 242 YYSYMBOL_YYEOF = 0, /* "end of file" */ 243 YYSYMBOL_YYerror = 1, /* error */ 244 YYSYMBOL_YYUNDEF = 2, /* "invalid token" */ 245 YYSYMBOL_DR = 3, /* DR */ 246 YYSYMBOL_AR = 4, /* AR */ 247 YYSYMBOL_FPR = 5, /* FPR */ 248 YYSYMBOL_FPCR = 6, /* FPCR */ 249 YYSYMBOL_LPC = 7, /* LPC */ 250 YYSYMBOL_ZAR = 8, /* ZAR */ 251 YYSYMBOL_ZDR = 9, /* ZDR */ 252 YYSYMBOL_LZPC = 10, /* LZPC */ 253 YYSYMBOL_CREG = 11, /* CREG */ 254 YYSYMBOL_INDEXREG = 12, /* INDEXREG */ 255 YYSYMBOL_EXPR = 13, /* EXPR */ 256 YYSYMBOL_14_ = 14, /* '&' */ 257 YYSYMBOL_15_ = 15, /* '<' */ 258 YYSYMBOL_16_ = 16, /* '>' */ 259 YYSYMBOL_17_ = 17, /* '#' */ 260 YYSYMBOL_18_ = 18, /* '(' */ 261 YYSYMBOL_19_ = 19, /* ')' */ 262 YYSYMBOL_20_ = 20, /* '+' */ 263 YYSYMBOL_21_ = 21, /* '-' */ 264 YYSYMBOL_22_ = 22, /* ',' */ 265 YYSYMBOL_23_ = 23, /* '[' */ 266 YYSYMBOL_24_ = 24, /* ']' */ 267 YYSYMBOL_25_ = 25, /* '@' */ 268 YYSYMBOL_26_ = 26, /* '/' */ 269 YYSYMBOL_YYACCEPT = 27, /* $accept */ 270 YYSYMBOL_operand = 28, /* operand */ 271 YYSYMBOL_optional_ampersand = 29, /* optional_ampersand */ 272 YYSYMBOL_generic_operand = 30, /* generic_operand */ 273 YYSYMBOL_motorola_operand = 31, /* motorola_operand */ 274 YYSYMBOL_mit_operand = 32, /* mit_operand */ 275 YYSYMBOL_zireg = 33, /* zireg */ 276 YYSYMBOL_zdireg = 34, /* zdireg */ 277 YYSYMBOL_zadr = 35, /* zadr */ 278 YYSYMBOL_zdr = 36, /* zdr */ 279 YYSYMBOL_apc = 37, /* apc */ 280 YYSYMBOL_zapc = 38, /* zapc */ 281 YYSYMBOL_optzapc = 39, /* optzapc */ 282 YYSYMBOL_zpc = 40, /* zpc */ 283 YYSYMBOL_optczapc = 41, /* optczapc */ 284 YYSYMBOL_optcexpr = 42, /* optcexpr */ 285 YYSYMBOL_optexprc = 43, /* optexprc */ 286 YYSYMBOL_reglist = 44, /* reglist */ 287 YYSYMBOL_ireglist = 45, /* ireglist */ 288 YYSYMBOL_reglistpair = 46, /* reglistpair */ 289 YYSYMBOL_reglistreg = 47 /* reglistreg */ 290 }; 291 typedef enum yysymbol_kind_t yysymbol_kind_t; 292 293 294 295 296 #ifdef short 297 # undef short 298 #endif 299 300 /* On compilers that do not define __PTRDIFF_MAX__ etc., make sure 301 <limits.h> and (if available) <stdint.h> are included 302 so that the code can choose integer types of a good width. */ 303 304 #ifndef __PTRDIFF_MAX__ 305 # include <limits.h> /* INFRINGES ON USER NAME SPACE */ 306 # if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__ 307 # include <stdint.h> /* INFRINGES ON USER NAME SPACE */ 308 # define YY_STDINT_H 309 # endif 310 #endif 311 312 /* Narrow types that promote to a signed type and that can represent a 313 signed or unsigned integer of at least N bits. In tables they can 314 save space and decrease cache pressure. Promoting to a signed type 315 helps avoid bugs in integer arithmetic. */ 316 317 #ifdef __INT_LEAST8_MAX__ 318 typedef __INT_LEAST8_TYPE__ yytype_int8; 319 #elif defined YY_STDINT_H 320 typedef int_least8_t yytype_int8; 321 #else 322 typedef signed char yytype_int8; 323 #endif 324 325 #ifdef __INT_LEAST16_MAX__ 326 typedef __INT_LEAST16_TYPE__ yytype_int16; 327 #elif defined YY_STDINT_H 328 typedef int_least16_t yytype_int16; 329 #else 330 typedef short yytype_int16; 331 #endif 332 333 /* Work around bug in HP-UX 11.23, which defines these macros 334 incorrectly for preprocessor constants. This workaround can likely 335 be removed in 2023, as HPE has promised support for HP-UX 11.23 336 (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of 337 <https://h20195.www2.hpe.com/V2/getpdf.aspx/4AA4-7673ENW.pdf>. */ 338 #ifdef __hpux 339 # undef UINT_LEAST8_MAX 340 # undef UINT_LEAST16_MAX 341 # define UINT_LEAST8_MAX 255 342 # define UINT_LEAST16_MAX 65535 343 #endif 344 345 #if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__ 346 typedef __UINT_LEAST8_TYPE__ yytype_uint8; 347 #elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \ 348 && UINT_LEAST8_MAX <= INT_MAX) 349 typedef uint_least8_t yytype_uint8; 350 #elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX 351 typedef unsigned char yytype_uint8; 352 #else 353 typedef short yytype_uint8; 354 #endif 355 356 #if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__ 357 typedef __UINT_LEAST16_TYPE__ yytype_uint16; 358 #elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \ 359 && UINT_LEAST16_MAX <= INT_MAX) 360 typedef uint_least16_t yytype_uint16; 361 #elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX 362 typedef unsigned short yytype_uint16; 363 #else 364 typedef int yytype_uint16; 365 #endif 366 367 #ifndef YYPTRDIFF_T 368 # if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__ 369 # define YYPTRDIFF_T __PTRDIFF_TYPE__ 370 # define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__ 371 # elif defined PTRDIFF_MAX 372 # ifndef ptrdiff_t 373 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 374 # endif 375 # define YYPTRDIFF_T ptrdiff_t 376 # define YYPTRDIFF_MAXIMUM PTRDIFF_MAX 377 # else 378 # define YYPTRDIFF_T long 379 # define YYPTRDIFF_MAXIMUM LONG_MAX 380 # endif 381 #endif 382 383 #ifndef YYSIZE_T 384 # ifdef __SIZE_TYPE__ 385 # define YYSIZE_T __SIZE_TYPE__ 386 # elif defined size_t 387 # define YYSIZE_T size_t 388 # elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__ 389 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 390 # define YYSIZE_T size_t 391 # else 392 # define YYSIZE_T unsigned 393 # endif 394 #endif 395 396 #define YYSIZE_MAXIMUM \ 397 YY_CAST (YYPTRDIFF_T, \ 398 (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \ 399 ? YYPTRDIFF_MAXIMUM \ 400 : YY_CAST (YYSIZE_T, -1))) 401 402 #define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) 403 404 405 /* Stored state numbers (used for stacks). */ 406 typedef yytype_uint8 yy_state_t; 407 408 /* State numbers in computations. */ 409 typedef int yy_state_fast_t; 410 411 #ifndef YY_ 412 # if defined YYENABLE_NLS && YYENABLE_NLS 413 # if ENABLE_NLS 414 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 415 # define YY_(Msgid) dgettext ("bison-runtime", Msgid) 416 # endif 417 # endif 418 # ifndef YY_ 419 # define YY_(Msgid) Msgid 420 # endif 421 #endif 422 423 424 #ifndef YY_ATTRIBUTE_PURE 425 # if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__) 426 # define YY_ATTRIBUTE_PURE __attribute__ ((__pure__)) 427 # else 428 # define YY_ATTRIBUTE_PURE 429 # endif 430 #endif 431 432 #ifndef YY_ATTRIBUTE_UNUSED 433 # if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__) 434 # define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__)) 435 # else 436 # define YY_ATTRIBUTE_UNUSED 437 # endif 438 #endif 439 440 /* Suppress unused-variable warnings by "using" E. */ 441 #if ! defined lint || defined __GNUC__ 442 # define YY_USE(E) ((void) (E)) 443 #else 444 # define YY_USE(E) /* empty */ 445 #endif 446 447 /* Suppress an incorrect diagnostic about yylval being uninitialized. */ 448 #if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__ 449 # if __GNUC__ * 100 + __GNUC_MINOR__ < 407 450 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ 451 _Pragma ("GCC diagnostic push") \ 452 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") 453 # else 454 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ 455 _Pragma ("GCC diagnostic push") \ 456 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \ 457 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") 458 # endif 459 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \ 460 _Pragma ("GCC diagnostic pop") 461 #else 462 # define YY_INITIAL_VALUE(Value) Value 463 #endif 464 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 465 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 466 # define YY_IGNORE_MAYBE_UNINITIALIZED_END 467 #endif 468 #ifndef YY_INITIAL_VALUE 469 # define YY_INITIAL_VALUE(Value) /* Nothing. */ 470 #endif 471 472 #if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__ 473 # define YY_IGNORE_USELESS_CAST_BEGIN \ 474 _Pragma ("GCC diagnostic push") \ 475 _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"") 476 # define YY_IGNORE_USELESS_CAST_END \ 477 _Pragma ("GCC diagnostic pop") 478 #endif 479 #ifndef YY_IGNORE_USELESS_CAST_BEGIN 480 # define YY_IGNORE_USELESS_CAST_BEGIN 481 # define YY_IGNORE_USELESS_CAST_END 482 #endif 483 484 485 #define YY_ASSERT(E) ((void) (0 && (E))) 486 487 #if !defined yyoverflow 488 489 /* The parser invokes alloca or malloc; define the necessary symbols. */ 490 491 # ifdef YYSTACK_USE_ALLOCA 492 # if YYSTACK_USE_ALLOCA 493 # ifdef __GNUC__ 494 # define YYSTACK_ALLOC __builtin_alloca 495 # elif defined __BUILTIN_VA_ARG_INCR 496 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 497 # elif defined _AIX 498 # define YYSTACK_ALLOC __alloca 499 # elif defined _MSC_VER 500 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 501 # define alloca _alloca 502 # else 503 # define YYSTACK_ALLOC alloca 504 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS 505 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 506 /* Use EXIT_SUCCESS as a witness for stdlib.h. */ 507 # ifndef EXIT_SUCCESS 508 # define EXIT_SUCCESS 0 509 # endif 510 # endif 511 # endif 512 # endif 513 # endif 514 515 # ifdef YYSTACK_ALLOC 516 /* Pacify GCC's 'empty if-body' warning. */ 517 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) 518 # ifndef YYSTACK_ALLOC_MAXIMUM 519 /* The OS might guarantee only one guard page at the bottom of the stack, 520 and a page size can be as small as 4096 bytes. So we cannot safely 521 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 522 to allow for a few compiler-allocated temporary stack slots. */ 523 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 524 # endif 525 # else 526 # define YYSTACK_ALLOC YYMALLOC 527 # define YYSTACK_FREE YYFREE 528 # ifndef YYSTACK_ALLOC_MAXIMUM 529 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 530 # endif 531 # if (defined __cplusplus && ! defined EXIT_SUCCESS \ 532 && ! ((defined YYMALLOC || defined malloc) \ 533 && (defined YYFREE || defined free))) 534 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 535 # ifndef EXIT_SUCCESS 536 # define EXIT_SUCCESS 0 537 # endif 538 # endif 539 # ifndef YYMALLOC 540 # define YYMALLOC malloc 541 # if ! defined malloc && ! defined EXIT_SUCCESS 542 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 543 # endif 544 # endif 545 # ifndef YYFREE 546 # define YYFREE free 547 # if ! defined free && ! defined EXIT_SUCCESS 548 void free (void *); /* INFRINGES ON USER NAME SPACE */ 549 # endif 550 # endif 551 # endif 552 #endif /* !defined yyoverflow */ 553 554 #if (! defined yyoverflow \ 555 && (! defined __cplusplus \ 556 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 557 558 /* A type that is properly aligned for any stack member. */ 559 union yyalloc 560 { 561 yy_state_t yyss_alloc; 562 YYSTYPE yyvs_alloc; 563 }; 564 565 /* The size of the maximum gap between one aligned stack and the next. */ 566 # define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) 567 568 /* The size of an array large to enough to hold all stacks, each with 569 N elements. */ 570 # define YYSTACK_BYTES(N) \ 571 ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \ 572 + YYSTACK_GAP_MAXIMUM) 573 574 # define YYCOPY_NEEDED 1 575 576 /* Relocate STACK from its old location to the new one. The 577 local variables YYSIZE and YYSTACKSIZE give the old and new number of 578 elements in the stack, and YYPTR gives the new location of the 579 stack. Advance YYPTR to a properly aligned location for the next 580 stack. */ 581 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 582 do \ 583 { \ 584 YYPTRDIFF_T yynewbytes; \ 585 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 586 Stack = &yyptr->Stack_alloc; \ 587 yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ 588 yyptr += yynewbytes / YYSIZEOF (*yyptr); \ 589 } \ 590 while (0) 591 592 #endif 593 594 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED 595 /* Copy COUNT objects from SRC to DST. The source and destination do 596 not overlap. */ 597 # ifndef YYCOPY 598 # if defined __GNUC__ && 1 < __GNUC__ 599 # define YYCOPY(Dst, Src, Count) \ 600 __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) 601 # else 602 # define YYCOPY(Dst, Src, Count) \ 603 do \ 604 { \ 605 YYPTRDIFF_T yyi; \ 606 for (yyi = 0; yyi < (Count); yyi++) \ 607 (Dst)[yyi] = (Src)[yyi]; \ 608 } \ 609 while (0) 610 # endif 611 # endif 612 #endif /* !YYCOPY_NEEDED */ 613 614 /* YYFINAL -- State number of the termination state. */ 615 #define YYFINAL 44 616 /* YYLAST -- Last index in YYTABLE. */ 617 #define YYLAST 215 618 619 /* YYNTOKENS -- Number of terminals. */ 620 #define YYNTOKENS 27 621 /* YYNNTS -- Number of nonterminals. */ 622 #define YYNNTS 21 623 /* YYNRULES -- Number of rules. */ 624 #define YYNRULES 89 625 /* YYNSTATES -- Number of states. */ 626 #define YYNSTATES 180 627 628 /* YYMAXUTOK -- Last valid token kind. */ 629 #define YYMAXUTOK 268 630 631 632 /* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM 633 as returned by yylex, with out-of-bounds checking. */ 634 #define YYTRANSLATE(YYX) \ 635 (0 <= (YYX) && (YYX) <= YYMAXUTOK \ 636 ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ 637 : YYSYMBOL_YYUNDEF) 638 639 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM 640 as returned by yylex. */ 641 static const yytype_int8 yytranslate[] = 642 { 643 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 644 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 645 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 646 2, 2, 2, 2, 2, 17, 2, 2, 14, 2, 647 18, 19, 2, 20, 22, 21, 2, 26, 2, 2, 648 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 649 15, 2, 16, 2, 25, 2, 2, 2, 2, 2, 650 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 651 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 652 2, 23, 2, 24, 2, 2, 2, 2, 2, 2, 653 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 654 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 655 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 656 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 657 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 658 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 659 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 660 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 661 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 662 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 663 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 664 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 665 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 666 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 667 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 668 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 669 5, 6, 7, 8, 9, 10, 11, 12, 13 670 }; 671 672 #if YYDEBUG 673 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ 674 static const yytype_int16 yyrline[] = 675 { 676 0, 120, 120, 121, 125, 134, 135, 142, 147, 152, 677 157, 162, 167, 172, 177, 182, 187, 192, 205, 210, 678 215, 220, 230, 240, 250, 255, 260, 265, 272, 283, 679 290, 296, 303, 309, 320, 330, 337, 343, 351, 358, 680 365, 371, 379, 386, 398, 409, 422, 430, 438, 446, 681 456, 463, 471, 478, 492, 493, 506, 507, 519, 520, 682 521, 527, 528, 534, 535, 542, 543, 544, 551, 554, 683 560, 561, 568, 571, 581, 585, 595, 599, 608, 609, 684 613, 625, 629, 630, 634, 641, 651, 655, 659, 663 685 }; 686 #endif 687 688 /** Accessing symbol of state STATE. */ 689 #define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) 690 691 #if YYDEBUG || 0 692 /* The user-facing name of the symbol whose (internal) number is 693 YYSYMBOL. No bounds checking. */ 694 static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED; 695 696 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 697 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 698 static const char *const yytname[] = 699 { 700 "\"end of file\"", "error", "\"invalid token\"", "DR", "AR", "FPR", 701 "FPCR", "LPC", "ZAR", "ZDR", "LZPC", "CREG", "INDEXREG", "EXPR", "'&'", 702 "'<'", "'>'", "'#'", "'('", "')'", "'+'", "'-'", "','", "'['", "']'", 703 "'@'", "'/'", "$accept", "operand", "optional_ampersand", 704 "generic_operand", "motorola_operand", "mit_operand", "zireg", "zdireg", 705 "zadr", "zdr", "apc", "zapc", "optzapc", "zpc", "optczapc", "optcexpr", 706 "optexprc", "reglist", "ireglist", "reglistpair", "reglistreg", YY_NULLPTR 707 }; 708 709 static const char * 710 yysymbol_name (yysymbol_kind_t yysymbol) 711 { 712 return yytname[yysymbol]; 713 } 714 #endif 715 716 #define YYPACT_NINF (-98) 717 718 #define yypact_value_is_default(Yyn) \ 719 ((Yyn) == YYPACT_NINF) 720 721 #define YYTABLE_NINF (-64) 722 723 #define yytable_value_is_error(Yyn) \ 724 0 725 726 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 727 STATE-NUM. */ 728 static const yytype_int16 yypact[] = 729 { 730 89, 14, 9, 31, 35, -98, -98, -98, -98, 0, 731 36, 42, 28, 56, 63, 67, 90, -98, 75, 75, 732 -98, -98, 86, -98, 96, -15, 123, -98, -98, -98, 733 -98, -98, 97, 115, 119, -98, 120, -98, 122, 16, 734 126, -98, 127, 157, -98, -98, -98, -98, 19, 154, 735 154, 154, -98, 140, 29, 144, -98, -98, -98, 123, 736 141, 99, 18, 70, 147, 105, 148, 152, -98, -98, 737 -98, -98, -98, -98, -98, 142, -13, -98, -98, 146, 738 150, -98, 133, -98, 140, 60, 146, 149, 133, 153, 739 140, 151, -98, -98, -98, -98, -98, -98, -98, 155, 740 158, -98, -98, 159, -98, 62, 143, 154, 154, -98, 741 160, 161, 162, -98, 133, 163, 164, 165, 166, 116, 742 168, 167, -98, -98, -98, -98, 169, -98, 173, -98, 743 -98, -98, -98, -98, 174, 176, 133, 116, 177, 175, 744 175, -98, 175, -98, 175, 170, 178, -98, -98, 180, 745 181, 175, -98, 171, 179, 182, 183, 187, 186, 189, 746 175, 175, 190, -98, -98, -98, -98, 79, 143, 195, 747 191, 192, -98, -98, 193, 194, -98, -98, -98, -98 748 }; 749 750 /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. 751 Performed when YYTABLE does not specify something else to do. Zero 752 means the default is an error. */ 753 static const yytype_int8 yydefact[] = 754 { 755 68, 86, 87, 88, 89, 64, 67, 66, 13, 14, 756 0, 0, 0, 0, 0, 0, 0, 2, 5, 5, 757 65, 69, 0, 17, 78, 0, 0, 16, 7, 8, 758 15, 61, 63, 64, 67, 62, 66, 56, 0, 76, 759 72, 57, 0, 0, 1, 6, 3, 4, 46, 0, 760 0, 0, 63, 72, 0, 18, 24, 25, 26, 0, 761 72, 0, 0, 0, 0, 0, 0, 76, 47, 48, 762 86, 87, 88, 89, 79, 82, 81, 85, 80, 0, 763 0, 23, 0, 19, 72, 0, 77, 0, 0, 74, 764 72, 0, 73, 36, 59, 70, 60, 71, 54, 0, 765 0, 55, 58, 0, 20, 0, 0, 0, 0, 35, 766 0, 0, 0, 21, 0, 73, 74, 0, 0, 0, 767 0, 0, 30, 22, 32, 34, 49, 77, 0, 83, 768 84, 31, 33, 29, 0, 0, 0, 0, 0, 74, 769 74, 75, 74, 40, 74, 0, 50, 27, 28, 0, 770 0, 74, 38, 0, 0, 0, 0, 0, 76, 0, 771 74, 74, 0, 42, 44, 39, 45, 0, 0, 0, 772 0, 0, 37, 52, 0, 0, 41, 43, 51, 53 773 }; 774 775 /* YYPGOTO[NTERM-NUM]. */ 776 static const yytype_int16 yypgoto[] = 777 { 778 -98, -98, 196, -98, -98, -98, -81, 6, -98, -9, 779 -98, 2, -98, -78, -38, -97, -67, -98, -48, 172, 780 12 781 }; 782 783 /* YYDEFGOTO[NTERM-NUM]. */ 784 static const yytype_int8 yydefgoto[] = 785 { 786 0, 16, 46, 17, 18, 19, 100, 40, 101, 102, 787 20, 92, 22, 103, 64, 120, 62, 23, 74, 75, 788 76 789 }; 790 791 /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If 792 positive, shift that token. If negative, reduce the rule whose 793 number is the opposite. If YYTABLE_NINF, syntax error. */ 794 static const yytype_int16 yytable[] = 795 { 796 106, 110, 21, 78, 111, 41, 50, 117, 50, -10, 797 118, 51, 25, 108, -9, 80, 42, 41, 26, 138, 798 52, 31, 87, 5, 6, 128, 7, 35, 54, 60, 799 37, -11, 53, 134, -63, -12, 135, 67, 142, 68, 800 69, 61, 154, 155, 29, 156, 112, 157, 81, 27, 801 41, 82, 121, 41, 162, 149, 151, 28, 150, 129, 802 130, 85, 77, 170, 171, 84, 31, 32, 90, 30, 803 33, 34, 35, 36, 52, 37, 38, 5, 6, 113, 804 7, 126, 114, 91, 127, 43, 39, 174, 115, 45, 805 44, 168, 1, 2, 3, 4, 5, 6, 173, 7, 806 8, 127, 9, 10, 11, 12, 13, 14, 31, 94, 807 15, 48, 95, 96, 35, 97, 55, 98, 99, 31, 808 94, 88, 49, 89, 96, 35, 31, 52, 98, 141, 809 5, 6, 35, 7, 56, 37, 31, 94, 57, 58, 810 95, 96, 35, 97, 59, 98, 31, 94, 63, 65, 811 52, 96, 35, 5, 6, 98, 7, 70, 71, 72, 812 73, 66, 79, 86, 83, 105, 93, 104, 107, 109, 813 122, 0, 24, 116, 123, 119, 0, 124, 125, 131, 814 132, 133, 0, 0, 141, 136, 137, 143, 158, 139, 815 140, 144, 146, 147, 145, 148, 152, 153, 163, 167, 816 0, 164, 165, 159, 160, 161, 166, 169, 175, 172, 817 176, 177, 178, 179, 0, 47 818 }; 819 820 static const yytype_int16 yycheck[] = 821 { 822 67, 82, 0, 51, 82, 14, 21, 88, 21, 0, 823 88, 26, 0, 26, 0, 53, 14, 26, 18, 116, 824 4, 3, 60, 7, 8, 106, 10, 9, 26, 13, 825 12, 0, 26, 114, 25, 0, 114, 18, 119, 20, 826 21, 39, 139, 140, 16, 142, 84, 144, 19, 13, 827 59, 22, 90, 62, 151, 136, 137, 15, 136, 107, 828 108, 59, 50, 160, 161, 59, 3, 4, 62, 13, 829 7, 8, 9, 10, 4, 12, 13, 7, 8, 19, 830 10, 19, 22, 13, 22, 18, 23, 168, 86, 14, 831 0, 158, 3, 4, 5, 6, 7, 8, 19, 10, 832 11, 22, 13, 14, 15, 16, 17, 18, 3, 4, 833 21, 25, 7, 8, 9, 10, 19, 12, 13, 3, 834 4, 22, 26, 24, 8, 9, 3, 4, 12, 13, 835 7, 8, 9, 10, 19, 12, 3, 4, 19, 19, 836 7, 8, 9, 10, 22, 12, 3, 4, 22, 22, 837 4, 8, 9, 7, 8, 12, 10, 3, 4, 5, 838 6, 4, 22, 22, 20, 13, 19, 19, 26, 19, 839 19, -1, 0, 24, 19, 22, -1, 19, 19, 19, 840 19, 19, -1, -1, 13, 22, 22, 19, 18, 24, 841 24, 24, 19, 19, 25, 19, 19, 22, 19, 13, 842 -1, 19, 19, 25, 24, 24, 19, 18, 13, 19, 843 19, 19, 19, 19, -1, 19 844 }; 845 846 /* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of 847 state STATE-NUM. */ 848 static const yytype_int8 yystos[] = 849 { 850 0, 3, 4, 5, 6, 7, 8, 10, 11, 13, 851 14, 15, 16, 17, 18, 21, 28, 30, 31, 32, 852 37, 38, 39, 44, 46, 47, 18, 13, 15, 16, 853 13, 3, 4, 7, 8, 9, 10, 12, 13, 23, 854 34, 36, 38, 18, 0, 14, 29, 29, 25, 26, 855 21, 26, 4, 34, 38, 19, 19, 19, 19, 22, 856 13, 38, 43, 22, 41, 22, 4, 18, 20, 21, 857 3, 4, 5, 6, 45, 46, 47, 47, 45, 22, 858 41, 19, 22, 20, 34, 38, 22, 41, 22, 24, 859 34, 13, 38, 19, 4, 7, 8, 10, 12, 13, 860 33, 35, 36, 40, 19, 13, 43, 26, 26, 19, 861 33, 40, 41, 19, 22, 38, 24, 33, 40, 22, 862 42, 41, 19, 19, 19, 19, 19, 22, 33, 45, 863 45, 19, 19, 19, 33, 40, 22, 22, 42, 24, 864 24, 13, 33, 19, 24, 25, 19, 19, 19, 33, 865 40, 33, 19, 22, 42, 42, 42, 42, 18, 25, 866 24, 24, 42, 19, 19, 19, 19, 13, 43, 18, 867 42, 42, 19, 19, 33, 13, 19, 19, 19, 19 868 }; 869 870 /* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM. */ 871 static const yytype_int8 yyr1[] = 872 { 873 0, 27, 28, 28, 28, 29, 29, 30, 30, 30, 874 30, 30, 30, 30, 30, 30, 30, 30, 31, 31, 875 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 876 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 877 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 878 32, 32, 32, 32, 33, 33, 34, 34, 35, 35, 879 35, 36, 36, 37, 37, 38, 38, 38, 39, 39, 880 40, 40, 41, 41, 42, 42, 43, 43, 44, 44, 881 44, 45, 45, 45, 45, 46, 47, 47, 47, 47 882 }; 883 884 /* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM. */ 885 static const yytype_int8 yyr2[] = 886 { 887 0, 2, 1, 2, 2, 0, 1, 2, 2, 1, 888 1, 1, 1, 1, 1, 2, 2, 1, 3, 4, 889 4, 5, 5, 4, 3, 3, 3, 7, 7, 6, 890 5, 6, 5, 6, 5, 5, 4, 9, 7, 8, 891 6, 10, 8, 10, 8, 8, 2, 3, 3, 5, 892 6, 10, 9, 10, 1, 1, 1, 1, 1, 1, 893 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 894 1, 1, 0, 2, 0, 2, 0, 2, 1, 3, 895 3, 1, 1, 3, 3, 3, 1, 1, 1, 1 896 }; 897 898 899 enum { YYENOMEM = -2 }; 900 901 #define yyerrok (yyerrstatus = 0) 902 #define yyclearin (yychar = YYEMPTY) 903 904 #define YYACCEPT goto yyacceptlab 905 #define YYABORT goto yyabortlab 906 #define YYERROR goto yyerrorlab 907 #define YYNOMEM goto yyexhaustedlab 908 909 910 #define YYRECOVERING() (!!yyerrstatus) 911 912 #define YYBACKUP(Token, Value) \ 913 do \ 914 if (yychar == YYEMPTY) \ 915 { \ 916 yychar = (Token); \ 917 yylval = (Value); \ 918 YYPOPSTACK (yylen); \ 919 yystate = *yyssp; \ 920 goto yybackup; \ 921 } \ 922 else \ 923 { \ 924 yyerror (YY_("syntax error: cannot back up")); \ 925 YYERROR; \ 926 } \ 927 while (0) 928 929 /* Backward compatibility with an undocumented macro. 930 Use YYerror or YYUNDEF. */ 931 #define YYERRCODE YYUNDEF 932 933 934 /* Enable debugging if requested. */ 935 #if YYDEBUG 936 937 # ifndef YYFPRINTF 938 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 939 # define YYFPRINTF fprintf 940 # endif 941 942 # define YYDPRINTF(Args) \ 943 do { \ 944 if (yydebug) \ 945 YYFPRINTF Args; \ 946 } while (0) 947 948 949 950 951 # define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \ 952 do { \ 953 if (yydebug) \ 954 { \ 955 YYFPRINTF (stderr, "%s ", Title); \ 956 yy_symbol_print (stderr, \ 957 Kind, Value); \ 958 YYFPRINTF (stderr, "\n"); \ 959 } \ 960 } while (0) 961 962 963 /*-----------------------------------. 964 | Print this symbol's value on YYO. | 965 `-----------------------------------*/ 966 967 static void 968 yy_symbol_value_print (FILE *yyo, 969 yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep) 970 { 971 FILE *yyoutput = yyo; 972 YY_USE (yyoutput); 973 if (!yyvaluep) 974 return; 975 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 976 YY_USE (yykind); 977 YY_IGNORE_MAYBE_UNINITIALIZED_END 978 } 979 980 981 /*---------------------------. 982 | Print this symbol on YYO. | 983 `---------------------------*/ 984 985 static void 986 yy_symbol_print (FILE *yyo, 987 yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep) 988 { 989 YYFPRINTF (yyo, "%s %s (", 990 yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind)); 991 992 yy_symbol_value_print (yyo, yykind, yyvaluep); 993 YYFPRINTF (yyo, ")"); 994 } 995 996 /*------------------------------------------------------------------. 997 | yy_stack_print -- Print the state stack from its BOTTOM up to its | 998 | TOP (included). | 999 `------------------------------------------------------------------*/ 1000 1001 static void 1002 yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop) 1003 { 1004 YYFPRINTF (stderr, "Stack now"); 1005 for (; yybottom <= yytop; yybottom++) 1006 { 1007 int yybot = *yybottom; 1008 YYFPRINTF (stderr, " %d", yybot); 1009 } 1010 YYFPRINTF (stderr, "\n"); 1011 } 1012 1013 # define YY_STACK_PRINT(Bottom, Top) \ 1014 do { \ 1015 if (yydebug) \ 1016 yy_stack_print ((Bottom), (Top)); \ 1017 } while (0) 1018 1019 1020 /*------------------------------------------------. 1021 | Report that the YYRULE is going to be reduced. | 1022 `------------------------------------------------*/ 1023 1024 static void 1025 yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, 1026 int yyrule) 1027 { 1028 int yylno = yyrline[yyrule]; 1029 int yynrhs = yyr2[yyrule]; 1030 int yyi; 1031 YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n", 1032 yyrule - 1, yylno); 1033 /* The symbols being reduced. */ 1034 for (yyi = 0; yyi < yynrhs; yyi++) 1035 { 1036 YYFPRINTF (stderr, " $%d = ", yyi + 1); 1037 yy_symbol_print (stderr, 1038 YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]), 1039 &yyvsp[(yyi + 1) - (yynrhs)]); 1040 YYFPRINTF (stderr, "\n"); 1041 } 1042 } 1043 1044 # define YY_REDUCE_PRINT(Rule) \ 1045 do { \ 1046 if (yydebug) \ 1047 yy_reduce_print (yyssp, yyvsp, Rule); \ 1048 } while (0) 1049 1050 /* Nonzero means print parse trace. It is left uninitialized so that 1051 multiple parsers can coexist. */ 1052 int yydebug; 1053 #else /* !YYDEBUG */ 1054 # define YYDPRINTF(Args) ((void) 0) 1055 # define YY_SYMBOL_PRINT(Title, Kind, Value, Location) 1056 # define YY_STACK_PRINT(Bottom, Top) 1057 # define YY_REDUCE_PRINT(Rule) 1058 #endif /* !YYDEBUG */ 1059 1060 1061 /* YYINITDEPTH -- initial size of the parser's stacks. */ 1062 #ifndef YYINITDEPTH 1063 # define YYINITDEPTH 200 1064 #endif 1065 1066 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 1067 if the built-in stack extension method is used). 1068 1069 Do not make this value too large; the results are undefined if 1070 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 1071 evaluated with infinite-precision integer arithmetic. */ 1072 1073 #ifndef YYMAXDEPTH 1074 # define YYMAXDEPTH 10000 1075 #endif 1076 1077 1078 1079 1080 1081 1082 /*-----------------------------------------------. 1083 | Release the memory associated to this symbol. | 1084 `-----------------------------------------------*/ 1085 1086 static void 1087 yydestruct (const char *yymsg, 1088 yysymbol_kind_t yykind, YYSTYPE *yyvaluep) 1089 { 1090 YY_USE (yyvaluep); 1091 if (!yymsg) 1092 yymsg = "Deleting"; 1093 YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp); 1094 1095 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1096 YY_USE (yykind); 1097 YY_IGNORE_MAYBE_UNINITIALIZED_END 1098 } 1099 1100 1101 /* Lookahead token kind. */ 1102 int yychar; 1103 1104 /* The semantic value of the lookahead symbol. */ 1105 YYSTYPE yylval; 1106 /* Number of syntax errors so far. */ 1107 int yynerrs; 1108 1109 1110 1111 1112 /*----------. 1113 | yyparse. | 1114 `----------*/ 1115 1116 int 1117 yyparse (void) 1118 { 1119 yy_state_fast_t yystate = 0; 1120 /* Number of tokens to shift before error messages enabled. */ 1121 int yyerrstatus = 0; 1122 1123 /* Refer to the stacks through separate pointers, to allow yyoverflow 1124 to reallocate them elsewhere. */ 1125 1126 /* Their size. */ 1127 YYPTRDIFF_T yystacksize = YYINITDEPTH; 1128 1129 /* The state stack: array, bottom, top. */ 1130 yy_state_t yyssa[YYINITDEPTH]; 1131 yy_state_t *yyss = yyssa; 1132 yy_state_t *yyssp = yyss; 1133 1134 /* The semantic value stack: array, bottom, top. */ 1135 YYSTYPE yyvsa[YYINITDEPTH]; 1136 YYSTYPE *yyvs = yyvsa; 1137 YYSTYPE *yyvsp = yyvs; 1138 1139 int yyn; 1140 /* The return value of yyparse. */ 1141 int yyresult; 1142 /* Lookahead symbol kind. */ 1143 yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY; 1144 /* The variables used to return semantic value and location from the 1145 action routines. */ 1146 YYSTYPE yyval; 1147 1148 1149 1150 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 1151 1152 /* The number of symbols on the RHS of the reduced rule. 1153 Keep to zero when no symbol should be popped. */ 1154 int yylen = 0; 1155 1156 YYDPRINTF ((stderr, "Starting parse\n")); 1157 1158 yychar = YYEMPTY; /* Cause a token to be read. */ 1159 1160 goto yysetstate; 1161 1162 1163 /*------------------------------------------------------------. 1164 | yynewstate -- push a new state, which is found in yystate. | 1165 `------------------------------------------------------------*/ 1166 yynewstate: 1167 /* In all cases, when you get here, the value and location stacks 1168 have just been pushed. So pushing a state here evens the stacks. */ 1169 yyssp++; 1170 1171 1172 /*--------------------------------------------------------------------. 1173 | yysetstate -- set current state (the top of the stack) to yystate. | 1174 `--------------------------------------------------------------------*/ 1175 yysetstate: 1176 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1177 YY_ASSERT (0 <= yystate && yystate < YYNSTATES); 1178 YY_IGNORE_USELESS_CAST_BEGIN 1179 *yyssp = YY_CAST (yy_state_t, yystate); 1180 YY_IGNORE_USELESS_CAST_END 1181 YY_STACK_PRINT (yyss, yyssp); 1182 1183 if (yyss + yystacksize - 1 <= yyssp) 1184 #if !defined yyoverflow && !defined YYSTACK_RELOCATE 1185 YYNOMEM; 1186 #else 1187 { 1188 /* Get the current used size of the three stacks, in elements. */ 1189 YYPTRDIFF_T yysize = yyssp - yyss + 1; 1190 1191 # if defined yyoverflow 1192 { 1193 /* Give user a chance to reallocate the stack. Use copies of 1194 these so that the &'s don't force the real ones into 1195 memory. */ 1196 yy_state_t *yyss1 = yyss; 1197 YYSTYPE *yyvs1 = yyvs; 1198 1199 /* Each stack pointer address is followed by the size of the 1200 data in use in that stack, in bytes. This used to be a 1201 conditional around just the two extra args, but that might 1202 be undefined if yyoverflow is a macro. */ 1203 yyoverflow (YY_("memory exhausted"), 1204 &yyss1, yysize * YYSIZEOF (*yyssp), 1205 &yyvs1, yysize * YYSIZEOF (*yyvsp), 1206 &yystacksize); 1207 yyss = yyss1; 1208 yyvs = yyvs1; 1209 } 1210 # else /* defined YYSTACK_RELOCATE */ 1211 /* Extend the stack our own way. */ 1212 if (YYMAXDEPTH <= yystacksize) 1213 YYNOMEM; 1214 yystacksize *= 2; 1215 if (YYMAXDEPTH < yystacksize) 1216 yystacksize = YYMAXDEPTH; 1217 1218 { 1219 yy_state_t *yyss1 = yyss; 1220 union yyalloc *yyptr = 1221 YY_CAST (union yyalloc *, 1222 YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize)))); 1223 if (! yyptr) 1224 YYNOMEM; 1225 YYSTACK_RELOCATE (yyss_alloc, yyss); 1226 YYSTACK_RELOCATE (yyvs_alloc, yyvs); 1227 # undef YYSTACK_RELOCATE 1228 if (yyss1 != yyssa) 1229 YYSTACK_FREE (yyss1); 1230 } 1231 # endif 1232 1233 yyssp = yyss + yysize - 1; 1234 yyvsp = yyvs + yysize - 1; 1235 1236 YY_IGNORE_USELESS_CAST_BEGIN 1237 YYDPRINTF ((stderr, "Stack size increased to %ld\n", 1238 YY_CAST (long, yystacksize))); 1239 YY_IGNORE_USELESS_CAST_END 1240 1241 if (yyss + yystacksize - 1 <= yyssp) 1242 YYABORT; 1243 } 1244 #endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ 1245 1246 1247 if (yystate == YYFINAL) 1248 YYACCEPT; 1249 1250 goto yybackup; 1251 1252 1253 /*-----------. 1254 | yybackup. | 1255 `-----------*/ 1256 yybackup: 1257 /* Do appropriate processing given the current state. Read a 1258 lookahead token if we need one and don't already have one. */ 1259 1260 /* First try to decide what to do without reference to lookahead token. */ 1261 yyn = yypact[yystate]; 1262 if (yypact_value_is_default (yyn)) 1263 goto yydefault; 1264 1265 /* Not known => get a lookahead token if don't already have one. */ 1266 1267 /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */ 1268 if (yychar == YYEMPTY) 1269 { 1270 YYDPRINTF ((stderr, "Reading a token\n")); 1271 yychar = yylex (); 1272 } 1273 1274 if (yychar <= YYEOF) 1275 { 1276 yychar = YYEOF; 1277 yytoken = YYSYMBOL_YYEOF; 1278 YYDPRINTF ((stderr, "Now at end of input.\n")); 1279 } 1280 else if (yychar == YYerror) 1281 { 1282 /* The scanner already issued an error message, process directly 1283 to error recovery. But do not keep the error token as 1284 lookahead, it is too special and may lead us to an endless 1285 loop in error recovery. */ 1286 yychar = YYUNDEF; 1287 yytoken = YYSYMBOL_YYerror; 1288 goto yyerrlab1; 1289 } 1290 else 1291 { 1292 yytoken = YYTRANSLATE (yychar); 1293 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1294 } 1295 1296 /* If the proper action on seeing token YYTOKEN is to reduce or to 1297 detect an error, take that action. */ 1298 yyn += yytoken; 1299 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 1300 goto yydefault; 1301 yyn = yytable[yyn]; 1302 if (yyn <= 0) 1303 { 1304 if (yytable_value_is_error (yyn)) 1305 goto yyerrlab; 1306 yyn = -yyn; 1307 goto yyreduce; 1308 } 1309 1310 /* Count tokens shifted since error; after three, turn off error 1311 status. */ 1312 if (yyerrstatus) 1313 yyerrstatus--; 1314 1315 /* Shift the lookahead token. */ 1316 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1317 yystate = yyn; 1318 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1319 *++yyvsp = yylval; 1320 YY_IGNORE_MAYBE_UNINITIALIZED_END 1321 1322 /* Discard the shifted token. */ 1323 yychar = YYEMPTY; 1324 goto yynewstate; 1325 1326 1327 /*-----------------------------------------------------------. 1328 | yydefault -- do the default action for the current state. | 1329 `-----------------------------------------------------------*/ 1330 yydefault: 1331 yyn = yydefact[yystate]; 1332 if (yyn == 0) 1333 goto yyerrlab; 1334 goto yyreduce; 1335 1336 1337 /*-----------------------------. 1338 | yyreduce -- do a reduction. | 1339 `-----------------------------*/ 1340 yyreduce: 1341 /* yyn is the number of a rule to reduce with. */ 1342 yylen = yyr2[yyn]; 1343 1344 /* If YYLEN is nonzero, implement the default value of the action: 1345 '$$ = $1'. 1346 1347 Otherwise, the following line sets YYVAL to garbage. 1348 This behavior is undocumented and Bison 1349 users should not rely upon it. Assigning to YYVAL 1350 unconditionally makes the parser a bit smaller, and it avoids a 1351 GCC warning that YYVAL may be used uninitialized. */ 1352 yyval = yyvsp[1-yylen]; 1353 1354 1355 YY_REDUCE_PRINT (yyn); 1356 switch (yyn) 1357 { 1358 case 3: /* operand: motorola_operand optional_ampersand */ 1359 #line 122 "./config/m68k-parse.y" 1360 { 1361 op->trailing_ampersand = (yyvsp[0].trailing_ampersand); 1362 } 1363 #line 1364 "config/m68k-parse.c" 1364 break; 1365 1366 case 4: /* operand: mit_operand optional_ampersand */ 1367 #line 126 "./config/m68k-parse.y" 1368 { 1369 op->trailing_ampersand = (yyvsp[0].trailing_ampersand); 1370 } 1371 #line 1372 "config/m68k-parse.c" 1372 break; 1373 1374 case 5: /* optional_ampersand: %empty */ 1375 #line 134 "./config/m68k-parse.y" 1376 { (yyval.trailing_ampersand) = 0; } 1377 #line 1378 "config/m68k-parse.c" 1378 break; 1379 1380 case 6: /* optional_ampersand: '&' */ 1381 #line 136 "./config/m68k-parse.y" 1382 { (yyval.trailing_ampersand) = 1; } 1383 #line 1384 "config/m68k-parse.c" 1384 break; 1385 1386 case 7: /* generic_operand: '<' '<' */ 1387 #line 143 "./config/m68k-parse.y" 1388 { 1389 op->mode = LSH; 1390 } 1391 #line 1392 "config/m68k-parse.c" 1392 break; 1393 1394 case 8: /* generic_operand: '>' '>' */ 1395 #line 148 "./config/m68k-parse.y" 1396 { 1397 op->mode = RSH; 1398 } 1399 #line 1400 "config/m68k-parse.c" 1400 break; 1401 1402 case 9: /* generic_operand: DR */ 1403 #line 153 "./config/m68k-parse.y" 1404 { 1405 op->mode = DREG; 1406 op->reg = (yyvsp[0].reg); 1407 } 1408 #line 1409 "config/m68k-parse.c" 1409 break; 1410 1411 case 10: /* generic_operand: AR */ 1412 #line 158 "./config/m68k-parse.y" 1413 { 1414 op->mode = AREG; 1415 op->reg = (yyvsp[0].reg); 1416 } 1417 #line 1418 "config/m68k-parse.c" 1418 break; 1419 1420 case 11: /* generic_operand: FPR */ 1421 #line 163 "./config/m68k-parse.y" 1422 { 1423 op->mode = FPREG; 1424 op->reg = (yyvsp[0].reg); 1425 } 1426 #line 1427 "config/m68k-parse.c" 1427 break; 1428 1429 case 12: /* generic_operand: FPCR */ 1430 #line 168 "./config/m68k-parse.y" 1431 { 1432 op->mode = CONTROL; 1433 op->reg = (yyvsp[0].reg); 1434 } 1435 #line 1436 "config/m68k-parse.c" 1436 break; 1437 1438 case 13: /* generic_operand: CREG */ 1439 #line 173 "./config/m68k-parse.y" 1440 { 1441 op->mode = CONTROL; 1442 op->reg = (yyvsp[0].reg); 1443 } 1444 #line 1445 "config/m68k-parse.c" 1445 break; 1446 1447 case 14: /* generic_operand: EXPR */ 1448 #line 178 "./config/m68k-parse.y" 1449 { 1450 op->mode = ABSL; 1451 op->disp = (yyvsp[0].exp); 1452 } 1453 #line 1454 "config/m68k-parse.c" 1454 break; 1455 1456 case 15: /* generic_operand: '#' EXPR */ 1457 #line 183 "./config/m68k-parse.y" 1458 { 1459 op->mode = IMMED; 1460 op->disp = (yyvsp[0].exp); 1461 } 1462 #line 1463 "config/m68k-parse.c" 1463 break; 1464 1465 case 16: /* generic_operand: '&' EXPR */ 1466 #line 188 "./config/m68k-parse.y" 1467 { 1468 op->mode = IMMED; 1469 op->disp = (yyvsp[0].exp); 1470 } 1471 #line 1472 "config/m68k-parse.c" 1472 break; 1473 1474 case 17: /* generic_operand: reglist */ 1475 #line 193 "./config/m68k-parse.y" 1476 { 1477 op->mode = REGLST; 1478 op->mask = (yyvsp[0].mask); 1479 } 1480 #line 1481 "config/m68k-parse.c" 1481 break; 1482 1483 case 18: /* motorola_operand: '(' AR ')' */ 1484 #line 206 "./config/m68k-parse.y" 1485 { 1486 op->mode = AINDR; 1487 op->reg = (yyvsp[-1].reg); 1488 } 1489 #line 1490 "config/m68k-parse.c" 1490 break; 1491 1492 case 19: /* motorola_operand: '(' AR ')' '+' */ 1493 #line 211 "./config/m68k-parse.y" 1494 { 1495 op->mode = AINC; 1496 op->reg = (yyvsp[-2].reg); 1497 } 1498 #line 1499 "config/m68k-parse.c" 1499 break; 1500 1501 case 20: /* motorola_operand: '-' '(' AR ')' */ 1502 #line 216 "./config/m68k-parse.y" 1503 { 1504 op->mode = ADEC; 1505 op->reg = (yyvsp[-1].reg); 1506 } 1507 #line 1508 "config/m68k-parse.c" 1508 break; 1509 1510 case 21: /* motorola_operand: '(' EXPR ',' zapc ')' */ 1511 #line 221 "./config/m68k-parse.y" 1512 { 1513 op->reg = (yyvsp[-1].reg); 1514 op->disp = (yyvsp[-3].exp); 1515 if (((yyvsp[-1].reg) >= ZADDR0 && (yyvsp[-1].reg) <= ZADDR7) 1516 || (yyvsp[-1].reg) == ZPC) 1517 op->mode = BASE; 1518 else 1519 op->mode = DISP; 1520 } 1521 #line 1522 "config/m68k-parse.c" 1522 break; 1523 1524 case 22: /* motorola_operand: '(' zapc ',' EXPR ')' */ 1525 #line 231 "./config/m68k-parse.y" 1526 { 1527 op->reg = (yyvsp[-3].reg); 1528 op->disp = (yyvsp[-1].exp); 1529 if (((yyvsp[-3].reg) >= ZADDR0 && (yyvsp[-3].reg) <= ZADDR7) 1530 || (yyvsp[-3].reg) == ZPC) 1531 op->mode = BASE; 1532 else 1533 op->mode = DISP; 1534 } 1535 #line 1536 "config/m68k-parse.c" 1536 break; 1537 1538 case 23: /* motorola_operand: EXPR '(' zapc ')' */ 1539 #line 241 "./config/m68k-parse.y" 1540 { 1541 op->reg = (yyvsp[-1].reg); 1542 op->disp = (yyvsp[-3].exp); 1543 if (((yyvsp[-1].reg) >= ZADDR0 && (yyvsp[-1].reg) <= ZADDR7) 1544 || (yyvsp[-1].reg) == ZPC) 1545 op->mode = BASE; 1546 else 1547 op->mode = DISP; 1548 } 1549 #line 1550 "config/m68k-parse.c" 1550 break; 1551 1552 case 24: /* motorola_operand: '(' LPC ')' */ 1553 #line 251 "./config/m68k-parse.y" 1554 { 1555 op->mode = DISP; 1556 op->reg = (yyvsp[-1].reg); 1557 } 1558 #line 1559 "config/m68k-parse.c" 1559 break; 1560 1561 case 25: /* motorola_operand: '(' ZAR ')' */ 1562 #line 256 "./config/m68k-parse.y" 1563 { 1564 op->mode = BASE; 1565 op->reg = (yyvsp[-1].reg); 1566 } 1567 #line 1568 "config/m68k-parse.c" 1568 break; 1569 1570 case 26: /* motorola_operand: '(' LZPC ')' */ 1571 #line 261 "./config/m68k-parse.y" 1572 { 1573 op->mode = BASE; 1574 op->reg = (yyvsp[-1].reg); 1575 } 1576 #line 1577 "config/m68k-parse.c" 1577 break; 1578 1579 case 27: /* motorola_operand: '(' EXPR ',' zapc ',' zireg ')' */ 1580 #line 266 "./config/m68k-parse.y" 1581 { 1582 op->mode = BASE; 1583 op->reg = (yyvsp[-3].reg); 1584 op->disp = (yyvsp[-5].exp); 1585 op->index = (yyvsp[-1].indexreg); 1586 } 1587 #line 1588 "config/m68k-parse.c" 1588 break; 1589 1590 case 28: /* motorola_operand: '(' EXPR ',' zapc ',' zpc ')' */ 1591 #line 273 "./config/m68k-parse.y" 1592 { 1593 if ((yyvsp[-3].reg) == PC || (yyvsp[-3].reg) == ZPC) 1594 yyerror (_("syntax error")); 1595 op->mode = BASE; 1596 op->reg = (yyvsp[-1].reg); 1597 op->disp = (yyvsp[-5].exp); 1598 op->index.reg = (yyvsp[-3].reg); 1599 op->index.size = SIZE_UNSPEC; 1600 op->index.scale = 1; 1601 } 1602 #line 1603 "config/m68k-parse.c" 1603 break; 1604 1605 case 29: /* motorola_operand: '(' EXPR ',' zdireg optczapc ')' */ 1606 #line 284 "./config/m68k-parse.y" 1607 { 1608 op->mode = BASE; 1609 op->reg = (yyvsp[-1].reg); 1610 op->disp = (yyvsp[-4].exp); 1611 op->index = (yyvsp[-2].indexreg); 1612 } 1613 #line 1614 "config/m68k-parse.c" 1614 break; 1615 1616 case 30: /* motorola_operand: '(' zdireg ',' EXPR ')' */ 1617 #line 291 "./config/m68k-parse.y" 1618 { 1619 op->mode = BASE; 1620 op->disp = (yyvsp[-1].exp); 1621 op->index = (yyvsp[-3].indexreg); 1622 } 1623 #line 1624 "config/m68k-parse.c" 1624 break; 1625 1626 case 31: /* motorola_operand: EXPR '(' zapc ',' zireg ')' */ 1627 #line 297 "./config/m68k-parse.y" 1628 { 1629 op->mode = BASE; 1630 op->reg = (yyvsp[-3].reg); 1631 op->disp = (yyvsp[-5].exp); 1632 op->index = (yyvsp[-1].indexreg); 1633 } 1634 #line 1635 "config/m68k-parse.c" 1635 break; 1636 1637 case 32: /* motorola_operand: '(' zapc ',' zireg ')' */ 1638 #line 304 "./config/m68k-parse.y" 1639 { 1640 op->mode = BASE; 1641 op->reg = (yyvsp[-3].reg); 1642 op->index = (yyvsp[-1].indexreg); 1643 } 1644 #line 1645 "config/m68k-parse.c" 1645 break; 1646 1647 case 33: /* motorola_operand: EXPR '(' zapc ',' zpc ')' */ 1648 #line 310 "./config/m68k-parse.y" 1649 { 1650 if ((yyvsp[-3].reg) == PC || (yyvsp[-3].reg) == ZPC) 1651 yyerror (_("syntax error")); 1652 op->mode = BASE; 1653 op->reg = (yyvsp[-1].reg); 1654 op->disp = (yyvsp[-5].exp); 1655 op->index.reg = (yyvsp[-3].reg); 1656 op->index.size = SIZE_UNSPEC; 1657 op->index.scale = 1; 1658 } 1659 #line 1660 "config/m68k-parse.c" 1660 break; 1661 1662 case 34: /* motorola_operand: '(' zapc ',' zpc ')' */ 1663 #line 321 "./config/m68k-parse.y" 1664 { 1665 if ((yyvsp[-3].reg) == PC || (yyvsp[-3].reg) == ZPC) 1666 yyerror (_("syntax error")); 1667 op->mode = BASE; 1668 op->reg = (yyvsp[-1].reg); 1669 op->index.reg = (yyvsp[-3].reg); 1670 op->index.size = SIZE_UNSPEC; 1671 op->index.scale = 1; 1672 } 1673 #line 1674 "config/m68k-parse.c" 1674 break; 1675 1676 case 35: /* motorola_operand: EXPR '(' zdireg optczapc ')' */ 1677 #line 331 "./config/m68k-parse.y" 1678 { 1679 op->mode = BASE; 1680 op->reg = (yyvsp[-1].reg); 1681 op->disp = (yyvsp[-4].exp); 1682 op->index = (yyvsp[-2].indexreg); 1683 } 1684 #line 1685 "config/m68k-parse.c" 1685 break; 1686 1687 case 36: /* motorola_operand: '(' zdireg optczapc ')' */ 1688 #line 338 "./config/m68k-parse.y" 1689 { 1690 op->mode = BASE; 1691 op->reg = (yyvsp[-1].reg); 1692 op->index = (yyvsp[-2].indexreg); 1693 } 1694 #line 1695 "config/m68k-parse.c" 1695 break; 1696 1697 case 37: /* motorola_operand: '(' '[' EXPR optczapc ']' ',' zireg optcexpr ')' */ 1698 #line 344 "./config/m68k-parse.y" 1699 { 1700 op->mode = POST; 1701 op->reg = (yyvsp[-5].reg); 1702 op->disp = (yyvsp[-6].exp); 1703 op->index = (yyvsp[-2].indexreg); 1704 op->odisp = (yyvsp[-1].exp); 1705 } 1706 #line 1707 "config/m68k-parse.c" 1707 break; 1708 1709 case 38: /* motorola_operand: '(' '[' EXPR optczapc ']' optcexpr ')' */ 1710 #line 352 "./config/m68k-parse.y" 1711 { 1712 op->mode = POST; 1713 op->reg = (yyvsp[-3].reg); 1714 op->disp = (yyvsp[-4].exp); 1715 op->odisp = (yyvsp[-1].exp); 1716 } 1717 #line 1718 "config/m68k-parse.c" 1718 break; 1719 1720 case 39: /* motorola_operand: '(' '[' zapc ']' ',' zireg optcexpr ')' */ 1721 #line 359 "./config/m68k-parse.y" 1722 { 1723 op->mode = POST; 1724 op->reg = (yyvsp[-5].reg); 1725 op->index = (yyvsp[-2].indexreg); 1726 op->odisp = (yyvsp[-1].exp); 1727 } 1728 #line 1729 "config/m68k-parse.c" 1729 break; 1730 1731 case 40: /* motorola_operand: '(' '[' zapc ']' optcexpr ')' */ 1732 #line 366 "./config/m68k-parse.y" 1733 { 1734 op->mode = POST; 1735 op->reg = (yyvsp[-3].reg); 1736 op->odisp = (yyvsp[-1].exp); 1737 } 1738 #line 1739 "config/m68k-parse.c" 1739 break; 1740 1741 case 41: /* motorola_operand: '(' '[' EXPR ',' zapc ',' zireg ']' optcexpr ')' */ 1742 #line 372 "./config/m68k-parse.y" 1743 { 1744 op->mode = PRE; 1745 op->reg = (yyvsp[-5].reg); 1746 op->disp = (yyvsp[-7].exp); 1747 op->index = (yyvsp[-3].indexreg); 1748 op->odisp = (yyvsp[-1].exp); 1749 } 1750 #line 1751 "config/m68k-parse.c" 1751 break; 1752 1753 case 42: /* motorola_operand: '(' '[' zapc ',' zireg ']' optcexpr ')' */ 1754 #line 380 "./config/m68k-parse.y" 1755 { 1756 op->mode = PRE; 1757 op->reg = (yyvsp[-5].reg); 1758 op->index = (yyvsp[-3].indexreg); 1759 op->odisp = (yyvsp[-1].exp); 1760 } 1761 #line 1762 "config/m68k-parse.c" 1762 break; 1763 1764 case 43: /* motorola_operand: '(' '[' EXPR ',' zapc ',' zpc ']' optcexpr ')' */ 1765 #line 387 "./config/m68k-parse.y" 1766 { 1767 if ((yyvsp[-5].reg) == PC || (yyvsp[-5].reg) == ZPC) 1768 yyerror (_("syntax error")); 1769 op->mode = PRE; 1770 op->reg = (yyvsp[-3].reg); 1771 op->disp = (yyvsp[-7].exp); 1772 op->index.reg = (yyvsp[-5].reg); 1773 op->index.size = SIZE_UNSPEC; 1774 op->index.scale = 1; 1775 op->odisp = (yyvsp[-1].exp); 1776 } 1777 #line 1778 "config/m68k-parse.c" 1778 break; 1779 1780 case 44: /* motorola_operand: '(' '[' zapc ',' zpc ']' optcexpr ')' */ 1781 #line 399 "./config/m68k-parse.y" 1782 { 1783 if ((yyvsp[-5].reg) == PC || (yyvsp[-5].reg) == ZPC) 1784 yyerror (_("syntax error")); 1785 op->mode = PRE; 1786 op->reg = (yyvsp[-3].reg); 1787 op->index.reg = (yyvsp[-5].reg); 1788 op->index.size = SIZE_UNSPEC; 1789 op->index.scale = 1; 1790 op->odisp = (yyvsp[-1].exp); 1791 } 1792 #line 1793 "config/m68k-parse.c" 1793 break; 1794 1795 case 45: /* motorola_operand: '(' '[' optexprc zdireg optczapc ']' optcexpr ')' */ 1796 #line 410 "./config/m68k-parse.y" 1797 { 1798 op->mode = PRE; 1799 op->reg = (yyvsp[-3].reg); 1800 op->disp = (yyvsp[-5].exp); 1801 op->index = (yyvsp[-4].indexreg); 1802 op->odisp = (yyvsp[-1].exp); 1803 } 1804 #line 1805 "config/m68k-parse.c" 1805 break; 1806 1807 case 46: /* mit_operand: optzapc '@' */ 1808 #line 423 "./config/m68k-parse.y" 1809 { 1810 /* We use optzapc to avoid a shift/reduce conflict. */ 1811 if ((yyvsp[-1].reg) < ADDR0 || (yyvsp[-1].reg) > ADDR7) 1812 yyerror (_("syntax error")); 1813 op->mode = AINDR; 1814 op->reg = (yyvsp[-1].reg); 1815 } 1816 #line 1817 "config/m68k-parse.c" 1817 break; 1818 1819 case 47: /* mit_operand: optzapc '@' '+' */ 1820 #line 431 "./config/m68k-parse.y" 1821 { 1822 /* We use optzapc to avoid a shift/reduce conflict. */ 1823 if ((yyvsp[-2].reg) < ADDR0 || (yyvsp[-2].reg) > ADDR7) 1824 yyerror (_("syntax error")); 1825 op->mode = AINC; 1826 op->reg = (yyvsp[-2].reg); 1827 } 1828 #line 1829 "config/m68k-parse.c" 1829 break; 1830 1831 case 48: /* mit_operand: optzapc '@' '-' */ 1832 #line 439 "./config/m68k-parse.y" 1833 { 1834 /* We use optzapc to avoid a shift/reduce conflict. */ 1835 if ((yyvsp[-2].reg) < ADDR0 || (yyvsp[-2].reg) > ADDR7) 1836 yyerror (_("syntax error")); 1837 op->mode = ADEC; 1838 op->reg = (yyvsp[-2].reg); 1839 } 1840 #line 1841 "config/m68k-parse.c" 1841 break; 1842 1843 case 49: /* mit_operand: optzapc '@' '(' EXPR ')' */ 1844 #line 447 "./config/m68k-parse.y" 1845 { 1846 op->reg = (yyvsp[-4].reg); 1847 op->disp = (yyvsp[-1].exp); 1848 if (((yyvsp[-4].reg) >= ZADDR0 && (yyvsp[-4].reg) <= ZADDR7) 1849 || (yyvsp[-4].reg) == ZPC) 1850 op->mode = BASE; 1851 else 1852 op->mode = DISP; 1853 } 1854 #line 1855 "config/m68k-parse.c" 1855 break; 1856 1857 case 50: /* mit_operand: optzapc '@' '(' optexprc zireg ')' */ 1858 #line 457 "./config/m68k-parse.y" 1859 { 1860 op->mode = BASE; 1861 op->reg = (yyvsp[-5].reg); 1862 op->disp = (yyvsp[-2].exp); 1863 op->index = (yyvsp[-1].indexreg); 1864 } 1865 #line 1866 "config/m68k-parse.c" 1866 break; 1867 1868 case 51: /* mit_operand: optzapc '@' '(' EXPR ')' '@' '(' optexprc zireg ')' */ 1869 #line 464 "./config/m68k-parse.y" 1870 { 1871 op->mode = POST; 1872 op->reg = (yyvsp[-9].reg); 1873 op->disp = (yyvsp[-6].exp); 1874 op->index = (yyvsp[-1].indexreg); 1875 op->odisp = (yyvsp[-2].exp); 1876 } 1877 #line 1878 "config/m68k-parse.c" 1878 break; 1879 1880 case 52: /* mit_operand: optzapc '@' '(' EXPR ')' '@' '(' EXPR ')' */ 1881 #line 472 "./config/m68k-parse.y" 1882 { 1883 op->mode = POST; 1884 op->reg = (yyvsp[-8].reg); 1885 op->disp = (yyvsp[-5].exp); 1886 op->odisp = (yyvsp[-1].exp); 1887 } 1888 #line 1889 "config/m68k-parse.c" 1889 break; 1890 1891 case 53: /* mit_operand: optzapc '@' '(' optexprc zireg ')' '@' '(' EXPR ')' */ 1892 #line 479 "./config/m68k-parse.y" 1893 { 1894 op->mode = PRE; 1895 op->reg = (yyvsp[-9].reg); 1896 op->disp = (yyvsp[-6].exp); 1897 op->index = (yyvsp[-5].indexreg); 1898 op->odisp = (yyvsp[-1].exp); 1899 } 1900 #line 1901 "config/m68k-parse.c" 1901 break; 1902 1903 case 55: /* zireg: zadr */ 1904 #line 494 "./config/m68k-parse.y" 1905 { 1906 (yyval.indexreg).reg = (yyvsp[0].reg); 1907 (yyval.indexreg).size = SIZE_UNSPEC; 1908 (yyval.indexreg).scale = 1; 1909 } 1910 #line 1911 "config/m68k-parse.c" 1911 break; 1912 1913 case 57: /* zdireg: zdr */ 1914 #line 508 "./config/m68k-parse.y" 1915 { 1916 (yyval.indexreg).reg = (yyvsp[0].reg); 1917 (yyval.indexreg).size = SIZE_UNSPEC; 1918 (yyval.indexreg).scale = 1; 1919 } 1920 #line 1921 "config/m68k-parse.c" 1921 break; 1922 1923 case 68: /* optzapc: %empty */ 1924 #line 551 "./config/m68k-parse.y" 1925 { 1926 (yyval.reg) = ZADDR0; 1927 } 1928 #line 1929 "config/m68k-parse.c" 1929 break; 1930 1931 case 72: /* optczapc: %empty */ 1932 #line 568 "./config/m68k-parse.y" 1933 { 1934 (yyval.reg) = ZADDR0; 1935 } 1936 #line 1937 "config/m68k-parse.c" 1937 break; 1938 1939 case 73: /* optczapc: ',' zapc */ 1940 #line 572 "./config/m68k-parse.y" 1941 { 1942 (yyval.reg) = (yyvsp[0].reg); 1943 } 1944 #line 1945 "config/m68k-parse.c" 1945 break; 1946 1947 case 74: /* optcexpr: %empty */ 1948 #line 581 "./config/m68k-parse.y" 1949 { 1950 (yyval.exp).exp.X_op = O_absent; 1951 (yyval.exp).size = SIZE_UNSPEC; 1952 } 1953 #line 1954 "config/m68k-parse.c" 1954 break; 1955 1956 case 75: /* optcexpr: ',' EXPR */ 1957 #line 586 "./config/m68k-parse.y" 1958 { 1959 (yyval.exp) = (yyvsp[0].exp); 1960 } 1961 #line 1962 "config/m68k-parse.c" 1962 break; 1963 1964 case 76: /* optexprc: %empty */ 1965 #line 595 "./config/m68k-parse.y" 1966 { 1967 (yyval.exp).exp.X_op = O_absent; 1968 (yyval.exp).size = SIZE_UNSPEC; 1969 } 1970 #line 1971 "config/m68k-parse.c" 1971 break; 1972 1973 case 77: /* optexprc: EXPR ',' */ 1974 #line 600 "./config/m68k-parse.y" 1975 { 1976 (yyval.exp) = (yyvsp[-1].exp); 1977 } 1978 #line 1979 "config/m68k-parse.c" 1979 break; 1980 1981 case 79: /* reglist: reglistpair '/' ireglist */ 1982 #line 610 "./config/m68k-parse.y" 1983 { 1984 (yyval.mask) = (yyvsp[-2].mask) | (yyvsp[0].mask); 1985 } 1986 #line 1987 "config/m68k-parse.c" 1987 break; 1988 1989 case 80: /* reglist: reglistreg '/' ireglist */ 1990 #line 614 "./config/m68k-parse.y" 1991 { 1992 (yyval.mask) = (1 << (yyvsp[-2].onereg)) | (yyvsp[0].mask); 1993 } 1994 #line 1995 "config/m68k-parse.c" 1995 break; 1996 1997 case 81: /* ireglist: reglistreg */ 1998 #line 626 "./config/m68k-parse.y" 1999 { 2000 (yyval.mask) = 1 << (yyvsp[0].onereg); 2001 } 2002 #line 2003 "config/m68k-parse.c" 2003 break; 2004 2005 case 83: /* ireglist: reglistpair '/' ireglist */ 2006 #line 631 "./config/m68k-parse.y" 2007 { 2008 (yyval.mask) = (yyvsp[-2].mask) | (yyvsp[0].mask); 2009 } 2010 #line 2011 "config/m68k-parse.c" 2011 break; 2012 2013 case 84: /* ireglist: reglistreg '/' ireglist */ 2014 #line 635 "./config/m68k-parse.y" 2015 { 2016 (yyval.mask) = (1 << (yyvsp[-2].onereg)) | (yyvsp[0].mask); 2017 } 2018 #line 2019 "config/m68k-parse.c" 2019 break; 2020 2021 case 85: /* reglistpair: reglistreg '-' reglistreg */ 2022 #line 642 "./config/m68k-parse.y" 2023 { 2024 if ((yyvsp[-2].onereg) <= (yyvsp[0].onereg)) 2025 (yyval.mask) = (1 << ((yyvsp[0].onereg) + 1)) - 1 - ((1 << (yyvsp[-2].onereg)) - 1); 2026 else 2027 (yyval.mask) = (1 << ((yyvsp[-2].onereg) + 1)) - 1 - ((1 << (yyvsp[0].onereg)) - 1); 2028 } 2029 #line 2030 "config/m68k-parse.c" 2030 break; 2031 2032 case 86: /* reglistreg: DR */ 2033 #line 652 "./config/m68k-parse.y" 2034 { 2035 (yyval.onereg) = (yyvsp[0].reg) - DATA0; 2036 } 2037 #line 2038 "config/m68k-parse.c" 2038 break; 2039 2040 case 87: /* reglistreg: AR */ 2041 #line 656 "./config/m68k-parse.y" 2042 { 2043 (yyval.onereg) = (yyvsp[0].reg) - ADDR0 + 8; 2044 } 2045 #line 2046 "config/m68k-parse.c" 2046 break; 2047 2048 case 88: /* reglistreg: FPR */ 2049 #line 660 "./config/m68k-parse.y" 2050 { 2051 (yyval.onereg) = (yyvsp[0].reg) - FP0 + 16; 2052 } 2053 #line 2054 "config/m68k-parse.c" 2054 break; 2055 2056 case 89: /* reglistreg: FPCR */ 2057 #line 664 "./config/m68k-parse.y" 2058 { 2059 if ((yyvsp[0].reg) == FPI) 2060 (yyval.onereg) = 24; 2061 else if ((yyvsp[0].reg) == FPS) 2062 (yyval.onereg) = 25; 2063 else 2064 (yyval.onereg) = 26; 2065 } 2066 #line 2067 "config/m68k-parse.c" 2067 break; 2068 2069 2070 #line 2071 "config/m68k-parse.c" 2071 2072 default: break; 2073 } 2074 /* User semantic actions sometimes alter yychar, and that requires 2075 that yytoken be updated with the new translation. We take the 2076 approach of translating immediately before every use of yytoken. 2077 One alternative is translating here after every semantic action, 2078 but that translation would be missed if the semantic action invokes 2079 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 2080 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 2081 incorrect destructor might then be invoked immediately. In the 2082 case of YYERROR or YYBACKUP, subsequent parser actions might lead 2083 to an incorrect destructor call or verbose syntax error message 2084 before the lookahead is translated. */ 2085 YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc); 2086 2087 YYPOPSTACK (yylen); 2088 yylen = 0; 2089 2090 *++yyvsp = yyval; 2091 2092 /* Now 'shift' the result of the reduction. Determine what state 2093 that goes to, based on the state we popped back to and the rule 2094 number reduced by. */ 2095 { 2096 const int yylhs = yyr1[yyn] - YYNTOKENS; 2097 const int yyi = yypgoto[yylhs] + *yyssp; 2098 yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp 2099 ? yytable[yyi] 2100 : yydefgoto[yylhs]); 2101 } 2102 2103 goto yynewstate; 2104 2105 2106 /*--------------------------------------. 2107 | yyerrlab -- here on detecting error. | 2108 `--------------------------------------*/ 2109 yyerrlab: 2110 /* Make sure we have latest lookahead translation. See comments at 2111 user semantic actions for why this is necessary. */ 2112 yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); 2113 /* If not already recovering from an error, report this error. */ 2114 if (!yyerrstatus) 2115 { 2116 ++yynerrs; 2117 yyerror (YY_("syntax error")); 2118 } 2119 2120 if (yyerrstatus == 3) 2121 { 2122 /* If just tried and failed to reuse lookahead token after an 2123 error, discard it. */ 2124 2125 if (yychar <= YYEOF) 2126 { 2127 /* Return failure if at end of input. */ 2128 if (yychar == YYEOF) 2129 YYABORT; 2130 } 2131 else 2132 { 2133 yydestruct ("Error: discarding", 2134 yytoken, &yylval); 2135 yychar = YYEMPTY; 2136 } 2137 } 2138 2139 /* Else will try to reuse lookahead token after shifting the error 2140 token. */ 2141 goto yyerrlab1; 2142 2143 2144 /*---------------------------------------------------. 2145 | yyerrorlab -- error raised explicitly by YYERROR. | 2146 `---------------------------------------------------*/ 2147 yyerrorlab: 2148 /* Pacify compilers when the user code never invokes YYERROR and the 2149 label yyerrorlab therefore never appears in user code. */ 2150 if (0) 2151 YYERROR; 2152 ++yynerrs; 2153 2154 /* Do not reclaim the symbols of the rule whose action triggered 2155 this YYERROR. */ 2156 YYPOPSTACK (yylen); 2157 yylen = 0; 2158 YY_STACK_PRINT (yyss, yyssp); 2159 yystate = *yyssp; 2160 goto yyerrlab1; 2161 2162 2163 /*-------------------------------------------------------------. 2164 | yyerrlab1 -- common code for both syntax error and YYERROR. | 2165 `-------------------------------------------------------------*/ 2166 yyerrlab1: 2167 yyerrstatus = 3; /* Each real token shifted decrements this. */ 2168 2169 /* Pop stack until we find a state that shifts the error token. */ 2170 for (;;) 2171 { 2172 yyn = yypact[yystate]; 2173 if (!yypact_value_is_default (yyn)) 2174 { 2175 yyn += YYSYMBOL_YYerror; 2176 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror) 2177 { 2178 yyn = yytable[yyn]; 2179 if (0 < yyn) 2180 break; 2181 } 2182 } 2183 2184 /* Pop the current state because it cannot handle the error token. */ 2185 if (yyssp == yyss) 2186 YYABORT; 2187 2188 2189 yydestruct ("Error: popping", 2190 YY_ACCESSING_SYMBOL (yystate), yyvsp); 2191 YYPOPSTACK (1); 2192 yystate = *yyssp; 2193 YY_STACK_PRINT (yyss, yyssp); 2194 } 2195 2196 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 2197 *++yyvsp = yylval; 2198 YY_IGNORE_MAYBE_UNINITIALIZED_END 2199 2200 2201 /* Shift the error token. */ 2202 YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp); 2203 2204 yystate = yyn; 2205 goto yynewstate; 2206 2207 2208 /*-------------------------------------. 2209 | yyacceptlab -- YYACCEPT comes here. | 2210 `-------------------------------------*/ 2211 yyacceptlab: 2212 yyresult = 0; 2213 goto yyreturnlab; 2214 2215 2216 /*-----------------------------------. 2217 | yyabortlab -- YYABORT comes here. | 2218 `-----------------------------------*/ 2219 yyabortlab: 2220 yyresult = 1; 2221 goto yyreturnlab; 2222 2223 2224 /*-----------------------------------------------------------. 2225 | yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here. | 2226 `-----------------------------------------------------------*/ 2227 yyexhaustedlab: 2228 yyerror (YY_("memory exhausted")); 2229 yyresult = 2; 2230 goto yyreturnlab; 2231 2232 2233 /*----------------------------------------------------------. 2234 | yyreturnlab -- parsing is finished, clean up and return. | 2235 `----------------------------------------------------------*/ 2236 yyreturnlab: 2237 if (yychar != YYEMPTY) 2238 { 2239 /* Make sure we have latest lookahead translation. See comments at 2240 user semantic actions for why this is necessary. */ 2241 yytoken = YYTRANSLATE (yychar); 2242 yydestruct ("Cleanup: discarding lookahead", 2243 yytoken, &yylval); 2244 } 2245 /* Do not reclaim the symbols of the rule whose action triggered 2246 this YYABORT or YYACCEPT. */ 2247 YYPOPSTACK (yylen); 2248 YY_STACK_PRINT (yyss, yyssp); 2249 while (yyssp != yyss) 2250 { 2251 yydestruct ("Cleanup: popping", 2252 YY_ACCESSING_SYMBOL (+*yyssp), yyvsp); 2253 YYPOPSTACK (1); 2254 } 2255 #ifndef yyoverflow 2256 if (yyss != yyssa) 2257 YYSTACK_FREE (yyss); 2258 #endif 2259 2260 return yyresult; 2261 } 2262 2263 #line 674 "./config/m68k-parse.y" 2264 2265 2266 /* The string to parse is stored here, and modified by yylex. */ 2267 2268 static char *str; 2269 2270 /* The original string pointer. */ 2271 2272 static char *strorig; 2273 2274 /* If *CCP could be a register, return the register number and advance 2275 *CCP. Otherwise don't change *CCP, and return 0. */ 2276 2277 static enum m68k_register 2278 m68k_reg_parse (char **ccp) 2279 { 2280 char *start = *ccp; 2281 char c; 2282 char *p; 2283 symbolS *symbolp; 2284 2285 if (flag_reg_prefix_optional) 2286 { 2287 if (*start == REGISTER_PREFIX) 2288 start++; 2289 p = start; 2290 } 2291 else 2292 { 2293 if (*start != REGISTER_PREFIX) 2294 return 0; 2295 p = start + 1; 2296 } 2297 2298 if (! is_name_beginner (*p)) 2299 return 0; 2300 2301 p++; 2302 while (is_part_of_name (*p) && *p != '.' && *p != ':' && *p != '*') 2303 p++; 2304 2305 c = *p; 2306 *p = 0; 2307 symbolp = symbol_find (start); 2308 *p = c; 2309 2310 if (symbolp != NULL && S_GET_SEGMENT (symbolp) == reg_section) 2311 { 2312 *ccp = p; 2313 return S_GET_VALUE (symbolp); 2314 } 2315 2316 /* In MRI mode, something like foo.bar can be equated to a register 2317 name. */ 2318 while (flag_mri && c == '.') 2319 { 2320 ++p; 2321 while (is_part_of_name (*p) && *p != '.' && *p != ':' && *p != '*') 2322 p++; 2323 c = *p; 2324 *p = '\0'; 2325 symbolp = symbol_find (start); 2326 *p = c; 2327 if (symbolp != NULL && S_GET_SEGMENT (symbolp) == reg_section) 2328 { 2329 *ccp = p; 2330 return S_GET_VALUE (symbolp); 2331 } 2332 } 2333 2334 return 0; 2335 } 2336 2337 /* The lexer. */ 2338 2339 static int 2340 yylex (void) 2341 { 2342 enum m68k_register reg; 2343 char *s; 2344 int parens; 2345 int c = 0; 2346 int tail = 0; 2347 2348 if (is_whitespace (*str)) 2349 ++str; 2350 2351 if (*str == '\0') 2352 return 0; 2353 2354 /* Various special characters are just returned directly. */ 2355 switch (*str) 2356 { 2357 case '@': 2358 /* In MRI mode, this can be the start of an octal number. */ 2359 if (flag_mri) 2360 { 2361 if (ISDIGIT (str[1]) 2362 || ((str[1] == '+' || str[1] == '-') 2363 && ISDIGIT (str[2]))) 2364 break; 2365 } 2366 /* Fall through. */ 2367 case '#': 2368 case '&': 2369 case ',': 2370 case ')': 2371 case '/': 2372 case '[': 2373 case ']': 2374 case '<': 2375 case '>': 2376 return *str++; 2377 case '+': 2378 /* It so happens that a '+' can only appear at the end of an 2379 operand, or if it is trailed by an '&'(see mac load insn). 2380 If it appears anywhere else, it must be a unary. */ 2381 if (str[1] == '\0' || (str[1] == '&' && str[2] == '\0')) 2382 return *str++; 2383 break; 2384 case '-': 2385 /* A '-' can only appear in -(ar), rn-rn, or ar@-. If it 2386 appears anywhere else, it must be a unary minus on an 2387 expression, unless it it trailed by a '&'(see mac load insn). */ 2388 if (str[1] == '\0' || (str[1] == '&' && str[2] == '\0')) 2389 return *str++; 2390 s = str + 1; 2391 if (*s == '(') 2392 ++s; 2393 if (m68k_reg_parse (&s) != 0) 2394 return *str++; 2395 break; 2396 case '(': 2397 /* A '(' can only appear in `(reg)', `(expr,...', `([', `@(', or 2398 `)('. If it appears anywhere else, it must be starting an 2399 expression. */ 2400 if (str[1] == '[' 2401 || (str > strorig 2402 && (str[-1] == '@' 2403 || str[-1] == ')'))) 2404 return *str++; 2405 s = str + 1; 2406 if (m68k_reg_parse (&s) != 0) 2407 return *str++; 2408 /* Check for the case of '(expr,...' by scanning ahead. If we 2409 find a comma outside of balanced parentheses, we return '('. 2410 If we find an unbalanced right parenthesis, then presumably 2411 the '(' really starts an expression. */ 2412 parens = 0; 2413 for (s = str + 1; *s != '\0'; s++) 2414 { 2415 if (*s == '(') 2416 ++parens; 2417 else if (*s == ')') 2418 { 2419 if (parens == 0) 2420 break; 2421 --parens; 2422 } 2423 else if (*s == ',' && parens == 0) 2424 { 2425 /* A comma can not normally appear in an expression, so 2426 this is a case of '(expr,...'. */ 2427 return *str++; 2428 } 2429 } 2430 } 2431 2432 /* See if it's a register. */ 2433 2434 reg = m68k_reg_parse (&str); 2435 if (reg != 0) 2436 { 2437 int ret; 2438 2439 yylval.reg = reg; 2440 2441 if (reg >= DATA0 && reg <= DATA7) 2442 ret = DR; 2443 else if (reg >= ADDR0 && reg <= ADDR7) 2444 ret = AR; 2445 else if (reg >= FP0 && reg <= FP7) 2446 return FPR; 2447 else if (reg == FPI 2448 || reg == FPS 2449 || reg == FPC) 2450 return FPCR; 2451 else if (reg == PC) 2452 return LPC; 2453 else if (reg >= ZDATA0 && reg <= ZDATA7) 2454 ret = ZDR; 2455 else if (reg >= ZADDR0 && reg <= ZADDR7) 2456 ret = ZAR; 2457 else if (reg == ZPC) 2458 return LZPC; 2459 else 2460 return CREG; 2461 2462 /* If we get here, we have a data or address register. We 2463 must check for a size or scale; if we find one, we must 2464 return INDEXREG. */ 2465 2466 s = str; 2467 2468 if (*s != '.' && *s != ':' && *s != '*') 2469 return ret; 2470 2471 yylval.indexreg.reg = reg; 2472 2473 if (*s != '.' && *s != ':') 2474 yylval.indexreg.size = SIZE_UNSPEC; 2475 else 2476 { 2477 ++s; 2478 switch (*s) 2479 { 2480 case 'w': 2481 case 'W': 2482 yylval.indexreg.size = SIZE_WORD; 2483 ++s; 2484 break; 2485 case 'l': 2486 case 'L': 2487 yylval.indexreg.size = SIZE_LONG; 2488 ++s; 2489 break; 2490 default: 2491 yyerror (_("illegal size specification")); 2492 yylval.indexreg.size = SIZE_UNSPEC; 2493 break; 2494 } 2495 } 2496 2497 yylval.indexreg.scale = 1; 2498 2499 if (*s == '*' || *s == ':') 2500 { 2501 expressionS scale; 2502 2503 ++s; 2504 2505 temp_ilp (s); 2506 expression (&scale); 2507 s = input_line_pointer; 2508 restore_ilp (); 2509 2510 if (scale.X_op != O_constant) 2511 yyerror (_("scale specification must resolve to a number")); 2512 else 2513 { 2514 switch (scale.X_add_number) 2515 { 2516 case 1: 2517 case 2: 2518 case 4: 2519 case 8: 2520 yylval.indexreg.scale = scale.X_add_number; 2521 break; 2522 default: 2523 yyerror (_("invalid scale value")); 2524 break; 2525 } 2526 } 2527 } 2528 2529 str = s; 2530 2531 return INDEXREG; 2532 } 2533 2534 /* It must be an expression. Before we call expression, we need to 2535 look ahead to see if there is a size specification. We must do 2536 that first, because otherwise foo.l will be treated as the symbol 2537 foo.l, rather than as the symbol foo with a long size 2538 specification. The grammar requires that all expressions end at 2539 the end of the operand, or with ',', '(', ']', ')'. */ 2540 2541 parens = 0; 2542 for (s = str; *s != '\0'; s++) 2543 { 2544 if (*s == '(') 2545 { 2546 if (parens == 0 2547 && s > str 2548 && (s[-1] == ')' || ISALNUM (s[-1]))) 2549 break; 2550 ++parens; 2551 } 2552 else if (*s == ')') 2553 { 2554 if (parens == 0) 2555 break; 2556 --parens; 2557 } 2558 else if (parens == 0 2559 && (*s == ',' || *s == ']')) 2560 break; 2561 } 2562 2563 yylval.exp.size = SIZE_UNSPEC; 2564 if (s <= str + 2 2565 || (s[-2] != '.' && s[-2] != ':')) 2566 tail = 0; 2567 else 2568 { 2569 switch (s[-1]) 2570 { 2571 case 's': 2572 case 'S': 2573 case 'b': 2574 case 'B': 2575 yylval.exp.size = SIZE_BYTE; 2576 break; 2577 case 'w': 2578 case 'W': 2579 yylval.exp.size = SIZE_WORD; 2580 break; 2581 case 'l': 2582 case 'L': 2583 yylval.exp.size = SIZE_LONG; 2584 break; 2585 default: 2586 break; 2587 } 2588 if (yylval.exp.size != SIZE_UNSPEC) 2589 tail = 2; 2590 } 2591 2592 #ifdef OBJ_ELF 2593 { 2594 /* Look for @PLTPC, etc. */ 2595 char *cp; 2596 2597 yylval.exp.pic_reloc = pic_none; 2598 cp = s - tail; 2599 if (cp - 7 > str && cp[-7] == '@') 2600 { 2601 if (startswith (cp - 7, "@TLSLDM")) 2602 { 2603 yylval.exp.pic_reloc = pic_tls_ldm; 2604 tail += 7; 2605 } 2606 else if (startswith (cp - 7, "@TLSLDO")) 2607 { 2608 yylval.exp.pic_reloc = pic_tls_ldo; 2609 tail += 7; 2610 } 2611 } 2612 else if (cp - 6 > str && cp[-6] == '@') 2613 { 2614 if (startswith (cp - 6, "@PLTPC")) 2615 { 2616 yylval.exp.pic_reloc = pic_plt_pcrel; 2617 tail += 6; 2618 } 2619 else if (startswith (cp - 6, "@GOTPC")) 2620 { 2621 yylval.exp.pic_reloc = pic_got_pcrel; 2622 tail += 6; 2623 } 2624 else if (startswith (cp - 6, "@TLSGD")) 2625 { 2626 yylval.exp.pic_reloc = pic_tls_gd; 2627 tail += 6; 2628 } 2629 else if (startswith (cp - 6, "@TLSIE")) 2630 { 2631 yylval.exp.pic_reloc = pic_tls_ie; 2632 tail += 6; 2633 } 2634 else if (startswith (cp - 6, "@TLSLE")) 2635 { 2636 yylval.exp.pic_reloc = pic_tls_le; 2637 tail += 6; 2638 } 2639 } 2640 else if (cp - 4 > str && cp[-4] == '@') 2641 { 2642 if (startswith (cp - 4, "@PLT")) 2643 { 2644 yylval.exp.pic_reloc = pic_plt_off; 2645 tail += 4; 2646 } 2647 else if (startswith (cp - 4, "@GOT")) 2648 { 2649 yylval.exp.pic_reloc = pic_got_off; 2650 tail += 4; 2651 } 2652 } 2653 } 2654 #endif 2655 2656 if (tail != 0) 2657 { 2658 c = s[-tail]; 2659 s[-tail] = 0; 2660 } 2661 2662 temp_ilp (str); 2663 expression (&yylval.exp.exp); 2664 str = input_line_pointer; 2665 restore_ilp (); 2666 2667 if (tail != 0) 2668 { 2669 s[-tail] = c; 2670 str = s; 2671 } 2672 2673 return EXPR; 2674 } 2675 2676 /* Parse an m68k operand. This is the only function which is called 2677 from outside this file. */ 2678 2679 int 2680 m68k_ip_op (char *s, struct m68k_op *oparg) 2681 { 2682 memset (oparg, 0, sizeof *oparg); 2683 oparg->error = NULL; 2684 oparg->index.reg = ZDATA0; 2685 oparg->index.scale = 1; 2686 oparg->disp.exp.X_op = O_absent; 2687 oparg->odisp.exp.X_op = O_absent; 2688 2689 str = strorig = s; 2690 op = oparg; 2691 2692 return yyparse (); 2693 } 2694 2695 /* The error handler. */ 2696 2697 static void 2698 yyerror (const char *s) 2699 { 2700 op->error = s; 2701 } 2702
Indexes created Sat Mar 21 00:23:06 UTC 2026