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 DREG = 258, 70 CREG = 259, 71 GREG = 260, 72 IMMED = 261, 73 ADDR = 262, 74 INSN = 263, 75 NUM = 264, 76 ID = 265, 77 NL = 266, 78 PNUM = 267 79 }; 80 #endif 81 /* Tokens. */ 82 #define DREG 258 83 #define CREG 259 84 #define GREG 260 85 #define IMMED 261 86 #define ADDR 262 87 #define INSN 263 88 #define NUM 264 89 #define ID 265 90 #define NL 266 91 #define PNUM 267 92 93 94 95 96 /* Copy the first part of user declarations. */ 97 #line 21 "./itbl-parse.y" 98 99 100 /* 101 102 Yacc grammar for instruction table entries. 103 104 ======================================================================= 105 Original Instruction table specification document: 106 107 MIPS Coprocessor Table Specification 108 ==================================== 109 110 This document describes the format of the MIPS coprocessor table. The 111 table specifies a list of valid functions, data registers and control 112 registers that can be used in coprocessor instructions. This list, 113 together with the coprocessor instruction classes listed below, 114 specifies the complete list of coprocessor instructions that will 115 be recognized and assembled by the GNU assembler. In effect, 116 this makes the GNU assembler table-driven, where the table is 117 specified by the programmer. 118 119 The table is an ordinary text file that the GNU assembler reads when 120 it starts. Using the information in the table, the assembler 121 generates an internal list of valid coprocessor registers and 122 functions. The assembler uses this internal list in addition to the 123 standard MIPS registers and instructions which are built-in to the 124 assembler during code generation. 125 126 To specify the coprocessor table when invoking the GNU assembler, use 127 the command line option "--itbl file", where file is the 128 complete name of the table, including path and extension. 129 130 Examples: 131 132 gas -t cop.tbl test.s -o test.o 133 gas -t /usr/local/lib/cop.tbl test.s -o test.o 134 gas --itbl d:\gnu\data\cop.tbl test.s -o test.o 135 136 Only one table may be supplied during a single invocation of 137 the assembler. 138 139 140 Instruction classes 141 =================== 142 143 Below is a list of the valid coprocessor instruction classes for 144 any given coprocessor "z". These instructions are already recognized 145 by the assembler, and are listed here only for reference. 146 147 Class format instructions 148 ------------------------------------------------- 149 Class1: 150 op base rt offset 151 LWCz rt,offset (base) 152 SWCz rt,offset (base) 153 Class2: 154 COPz sub rt rd 0 155 MTCz rt,rd 156 MFCz rt,rd 157 CTCz rt,rd 158 CFCz rt,rd 159 Class3: 160 COPz CO cofun 161 COPz cofun 162 Class4: 163 COPz BC br offset 164 BCzT offset 165 BCzF offset 166 Class5: 167 COPz sub rt rd 0 168 DMFCz rt,rd 169 DMTCz rt,rd 170 Class6: 171 op base rt offset 172 LDCz rt,offset (base) 173 SDCz rt,offset (base) 174 Class7: 175 COPz BC br offset 176 BCzTL offset 177 BCzFL offset 178 179 The coprocessor table defines coprocessor-specific registers that can 180 be used with all of the above classes of instructions, where 181 appropriate. It also defines additional coprocessor-specific 182 functions for Class3 (COPz cofun) instructions, Thus, the table allows 183 the programmer to use convenient mnemonics and operands for these 184 functions, instead of the COPz mmenmonic and cofun operand. 185 186 The names of the MIPS general registers and their aliases are defined 187 by the assembler and will be recognized as valid register names by the 188 assembler when used (where allowed) in coprocessor instructions. 189 However, the names and values of all coprocessor data and control 190 register mnemonics must be specified in the coprocessor table. 191 192 193 Table Grammar 194 ============= 195 196 Here is the grammar for the coprocessor table: 197 198 table -> entry* 199 200 entry -> [z entrydef] [comment] '\n' 201 202 entrydef -> type name val 203 entrydef -> 'insn' name val funcdef ; type of entry (instruction) 204 205 z -> 'p'['0'..'3'] ; processor number 206 type -> ['dreg' | 'creg' | 'greg' ] ; type of entry (register) 207 ; 'dreg', 'creg' or 'greg' specifies a data, control, or general 208 ; register mnemonic, respectively 209 name -> [ltr|dec]* ; mnemonic of register/function 210 val -> [dec|hex] ; register/function number (integer constant) 211 212 funcdef -> frange flags fields 213 ; bitfield range for opcode 214 ; list of fields' formats 215 fields -> field* 216 field -> [','] ftype frange flags 217 flags -> ['*' flagexpr] 218 flagexpr -> '[' flagexpr ']' 219 flagexpr -> val '|' flagexpr 220 ftype -> [ type | 'immed' | 'addr' ] 221 ; 'immed' specifies an immediate value; see grammar for "val" above 222 ; 'addr' specifies a C identifier; name of symbol to be resolved at 223 ; link time 224 frange -> ':' val '-' val ; starting to ending bit positions, where 225 ; where 0 is least significant bit 226 frange -> (null) ; default range of 31-0 will be assumed 227 228 comment -> [';'|'#'] [char]* 229 char -> any printable character 230 ltr -> ['a'..'z'|'A'..'Z'] 231 dec -> ['0'..'9']* ; value in decimal 232 hex -> '0x'['0'..'9' | 'a'..'f' | 'A'..'F']* ; value in hexadecimal 233 234 235 Examples 236 ======== 237 238 Example 1: 239 240 The table: 241 242 p1 dreg d1 1 ; data register "d1" for COP1 has value 1 243 p1 creg c3 3 ; ctrl register "c3" for COP1 has value 3 244 p3 func fill 0x1f:24-20 ; function "fill" for COP3 has value 31 and 245 ; no fields 246 247 will allow the assembler to accept the following coprocessor instructions: 248 249 LWC1 d1,0x100 ($2) 250 fill 251 252 Here, the general purpose register "$2", and instruction "LWC1", are standard 253 mnemonics built-in to the MIPS assembler. 254 255 256 Example 2: 257 258 The table: 259 260 p3 dreg d3 3 ; data register "d3" for COP3 has value 3 261 p3 creg c2 22 ; control register "c2" for COP3 has value 22 262 p3 func fee 0x1f:24-20 dreg:17-13 creg:12-8 immed:7-0 263 ; function "fee" for COP3 has value 31, and 3 fields 264 ; consisting of a data register, a control register, 265 ; and an immediate value. 266 267 will allow the assembler to accept the following coprocessor instruction: 268 269 fee d3,c2,0x1 270 271 and will emit the object code: 272 273 31-26 25 24-20 19-18 17-13 12-8 7-0 274 COPz CO fun dreg creg immed 275 010011 1 11111 00 00011 10110 00000001 276 277 0x4ff07601 278 279 280 Example 3: 281 282 The table: 283 284 p3 dreg d3 3 ; data register "d3" for COP3 has value 3 285 p3 creg c2 22 ; control register "c2" for COP3 has value 22 286 p3 func fuu 0x01f00001 dreg:17-13 creg:12-8 287 288 will allow the assembler to accept the following coprocessor 289 instruction: 290 291 fuu d3,c2 292 293 and will emit the object code: 294 295 31-26 25 24-20 19-18 17-13 12-8 7-0 296 COPz CO fun dreg creg 297 010011 1 11111 00 00011 10110 00000001 298 299 0x4ff07601 300 301 In this way, the programmer can force arbitrary bits of an instruction 302 to have predefined values. 303 304 ======================================================================= 305 Additional notes: 306 307 Encoding of ranges: 308 To handle more than one bit position range within an instruction, 309 use 0s to mask out the ranges which don't apply. 310 May decide to modify the syntax to allow commas separate multiple 311 ranges within an instruction (range','range). 312 313 Changes in grammar: 314 The number of parms argument to the function entry 315 was deleted from the original format such that we now count the fields. 316 317 ---- 318 FIXME! should really change lexical analyzer 319 to recognize 'dreg' etc. in context sensitive way. 320 Currently function names or mnemonics may be incorrectly parsed as keywords 321 322 FIXME! hex is ambiguous with any digit 323 324 */ 325 326 #include "as.h" 327 #include "itbl-lex.h" 328 #include "itbl-ops.h" 329 330 /* #define DEBUG */ 331 332 #ifdef DEBUG 333 #ifndef DBG_LVL 334 #define DBG_LVL 1 335 #endif 336 #else 337 #define DBG_LVL 0 338 #endif 339 340 #if DBG_LVL >= 1 341 #define DBG(x) printf x 342 #else 343 #define DBG(x) 344 #endif 345 346 #if DBG_LVL >= 2 347 #define DBGL2(x) printf x 348 #else 349 #define DBGL2(x) 350 #endif 351 352 static int sbit, ebit; 353 static struct itbl_entry *insn=0; 354 static int yyerror (const char *); 355 356 357 358 /* Enabling traces. */ 359 #ifndef YYDEBUG 360 # define YYDEBUG 0 361 #endif 362 363 /* Enabling verbose error messages. */ 364 #ifdef YYERROR_VERBOSE 365 # undef YYERROR_VERBOSE 366 # define YYERROR_VERBOSE 1 367 #else 368 # define YYERROR_VERBOSE 0 369 #endif 370 371 /* Enabling the token table. */ 372 #ifndef YYTOKEN_TABLE 373 # define YYTOKEN_TABLE 0 374 #endif 375 376 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 377 typedef union YYSTYPE 378 #line 282 "./itbl-parse.y" 379 { 380 char *str; 381 int num; 382 int processor; 383 unsigned long val; 384 } 385 /* Line 193 of yacc.c. */ 386 #line 387 "itbl-parse.c" 387 YYSTYPE; 388 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ 389 # define YYSTYPE_IS_DECLARED 1 390 # define YYSTYPE_IS_TRIVIAL 1 391 #endif 392 393 394 395 /* Copy the second part of user declarations. */ 396 397 398 /* Line 216 of yacc.c. */ 399 #line 400 "itbl-parse.c" 400 401 #ifdef short 402 # undef short 403 #endif 404 405 #ifdef YYTYPE_UINT8 406 typedef YYTYPE_UINT8 yytype_uint8; 407 #else 408 typedef unsigned char yytype_uint8; 409 #endif 410 411 #ifdef YYTYPE_INT8 412 typedef YYTYPE_INT8 yytype_int8; 413 #elif (defined __STDC__ || defined __C99__FUNC__ \ 414 || defined __cplusplus || defined _MSC_VER) 415 typedef signed char yytype_int8; 416 #else 417 typedef short int yytype_int8; 418 #endif 419 420 #ifdef YYTYPE_UINT16 421 typedef YYTYPE_UINT16 yytype_uint16; 422 #else 423 typedef unsigned short int yytype_uint16; 424 #endif 425 426 #ifdef YYTYPE_INT16 427 typedef YYTYPE_INT16 yytype_int16; 428 #else 429 typedef short int yytype_int16; 430 #endif 431 432 #ifndef YYSIZE_T 433 # ifdef __SIZE_TYPE__ 434 # define YYSIZE_T __SIZE_TYPE__ 435 # elif defined size_t 436 # define YYSIZE_T size_t 437 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ 438 || defined __cplusplus || defined _MSC_VER) 439 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 440 # define YYSIZE_T size_t 441 # else 442 # define YYSIZE_T unsigned int 443 # endif 444 #endif 445 446 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 447 448 #ifndef YY_ 449 # if defined YYENABLE_NLS && YYENABLE_NLS 450 # if ENABLE_NLS 451 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 452 # define YY_(msgid) dgettext ("bison-runtime", msgid) 453 # endif 454 # endif 455 # ifndef YY_ 456 # define YY_(msgid) msgid 457 # endif 458 #endif 459 460 /* Suppress unused-variable warnings by "using" E. */ 461 #if ! defined lint || defined __GNUC__ 462 # define YYUSE(e) ((void) (e)) 463 #else 464 # define YYUSE(e) /* empty */ 465 #endif 466 467 /* Identity function, used to suppress warnings about constant conditions. */ 468 #ifndef lint 469 # define YYID(n) (n) 470 #else 471 #if (defined __STDC__ || defined __C99__FUNC__ \ 472 || defined __cplusplus || defined _MSC_VER) 473 static int 474 YYID (int i) 475 #else 476 static int 477 YYID (i) 478 int i; 479 #endif 480 { 481 return i; 482 } 483 #endif 484 485 #if ! defined yyoverflow || YYERROR_VERBOSE 486 487 /* The parser invokes alloca or malloc; define the necessary symbols. */ 488 489 # ifdef YYSTACK_USE_ALLOCA 490 # if YYSTACK_USE_ALLOCA 491 # ifdef __GNUC__ 492 # define YYSTACK_ALLOC __builtin_alloca 493 # elif defined __BUILTIN_VA_ARG_INCR 494 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 495 # elif defined _AIX 496 # define YYSTACK_ALLOC __alloca 497 # elif defined _MSC_VER 498 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 499 # define alloca _alloca 500 # else 501 # define YYSTACK_ALLOC alloca 502 # if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 503 || defined __cplusplus || defined _MSC_VER) 504 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 505 # ifndef _STDLIB_H 506 # define _STDLIB_H 1 507 # endif 508 # endif 509 # endif 510 # endif 511 # endif 512 513 # ifdef YYSTACK_ALLOC 514 /* Pacify GCC's `empty if-body' warning. */ 515 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) 516 # ifndef YYSTACK_ALLOC_MAXIMUM 517 /* The OS might guarantee only one guard page at the bottom of the stack, 518 and a page size can be as small as 4096 bytes. So we cannot safely 519 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 520 to allow for a few compiler-allocated temporary stack slots. */ 521 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 522 # endif 523 # else 524 # define YYSTACK_ALLOC YYMALLOC 525 # define YYSTACK_FREE YYFREE 526 # ifndef YYSTACK_ALLOC_MAXIMUM 527 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 528 # endif 529 # if (defined __cplusplus && ! defined _STDLIB_H \ 530 && ! ((defined YYMALLOC || defined malloc) \ 531 && (defined YYFREE || defined free))) 532 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 533 # ifndef _STDLIB_H 534 # define _STDLIB_H 1 535 # endif 536 # endif 537 # ifndef YYMALLOC 538 # define YYMALLOC malloc 539 # if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 540 || defined __cplusplus || defined _MSC_VER) 541 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 542 # endif 543 # endif 544 # ifndef YYFREE 545 # define YYFREE free 546 # if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 547 || defined __cplusplus || defined _MSC_VER) 548 void free (void *); /* INFRINGES ON USER NAME SPACE */ 549 # endif 550 # endif 551 # endif 552 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */ 553 554 555 #if (! defined yyoverflow \ 556 && (! defined __cplusplus \ 557 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 558 559 /* A type that is properly aligned for any stack member. */ 560 union yyalloc 561 { 562 yytype_int16 yyss; 563 YYSTYPE yyvs; 564 }; 565 566 /* The size of the maximum gap between one aligned stack and the next. */ 567 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 568 569 /* The size of an array large to enough to hold all stacks, each with 570 N elements. */ 571 # define YYSTACK_BYTES(N) \ 572 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ 573 + YYSTACK_GAP_MAXIMUM) 574 575 /* Copy COUNT objects from FROM to TO. The source and destination do 576 not overlap. */ 577 # ifndef YYCOPY 578 # if defined __GNUC__ && 1 < __GNUC__ 579 # define YYCOPY(To, From, Count) \ 580 __builtin_memcpy (To, From, (Count) * sizeof (*(From))) 581 # else 582 # define YYCOPY(To, From, Count) \ 583 do \ 584 { \ 585 YYSIZE_T yyi; \ 586 for (yyi = 0; yyi < (Count); yyi++) \ 587 (To)[yyi] = (From)[yyi]; \ 588 } \ 589 while (YYID (0)) 590 # endif 591 # endif 592 593 /* Relocate STACK from its old location to the new one. The 594 local variables YYSIZE and YYSTACKSIZE give the old and new number of 595 elements in the stack, and YYPTR gives the new location of the 596 stack. Advance YYPTR to a properly aligned location for the next 597 stack. */ 598 # define YYSTACK_RELOCATE(Stack) \ 599 do \ 600 { \ 601 YYSIZE_T yynewbytes; \ 602 YYCOPY (&yyptr->Stack, Stack, yysize); \ 603 Stack = &yyptr->Stack; \ 604 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 605 yyptr += yynewbytes / sizeof (*yyptr); \ 606 } \ 607 while (YYID (0)) 608 609 #endif 610 611 /* YYFINAL -- State number of the termination state. */ 612 #define YYFINAL 9 613 /* YYLAST -- Last index in YYTABLE. */ 614 #define YYLAST 46 615 616 /* YYNTOKENS -- Number of terminals. */ 617 #define YYNTOKENS 20 618 /* YYNNTS -- Number of nonterminals. */ 619 #define YYNNTS 15 620 /* YYNRULES -- Number of rules. */ 621 #define YYNRULES 29 622 /* YYNRULES -- Number of states. */ 623 #define YYNSTATES 51 624 625 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 626 #define YYUNDEFTOK 2 627 #define YYMAXUTOK 267 628 629 #define YYTRANSLATE(YYX) \ 630 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 631 632 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ 633 static const yytype_uint8 yytranslate[] = 634 { 635 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 636 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 637 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 638 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 639 2, 2, 17, 2, 13, 19, 2, 2, 2, 2, 640 2, 2, 2, 2, 2, 2, 2, 2, 18, 2, 641 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 642 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 643 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 644 2, 15, 2, 16, 2, 2, 2, 2, 2, 2, 645 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 646 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 647 2, 2, 2, 2, 14, 2, 2, 2, 2, 2, 648 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 649 2, 2, 2, 2, 2, 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, 2, 2, 2, 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, 1, 2, 3, 4, 661 5, 6, 7, 8, 9, 10, 11, 12 662 }; 663 664 #if YYDEBUG 665 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 666 YYRHS. */ 667 static const yytype_uint8 yyprhs[] = 668 { 669 0, 0, 3, 5, 8, 9, 15, 16, 26, 28, 670 31, 35, 38, 39, 41, 43, 45, 49, 53, 57, 671 59, 62, 63, 68, 69, 71, 73, 75, 77, 79 672 }; 673 674 /* YYRHS -- A `-1'-separated list of the rules' RHS. */ 675 static const yytype_int8 yyrhs[] = 676 { 677 21, 0, -1, 22, -1, 23, 22, -1, -1, 31, 678 32, 33, 34, 11, -1, -1, 31, 8, 33, 34, 679 30, 29, 24, 25, 11, -1, 11, -1, 1, 11, 680 -1, 13, 27, 25, -1, 27, 25, -1, -1, 32, 681 -1, 7, -1, 6, -1, 26, 30, 29, -1, 9, 682 14, 28, -1, 15, 28, 16, -1, 9, -1, 17, 683 28, -1, -1, 18, 9, 19, 9, -1, -1, 12, 684 -1, 3, -1, 4, -1, 5, -1, 10, -1, 9, 685 -1 686 }; 687 688 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ 689 static const yytype_uint16 yyrline[] = 690 { 691 0, 299, 299, 303, 304, 308, 315, 314, 323, 324, 692 328, 329, 330, 334, 339, 344, 352, 361, 365, 369, 693 376, 382, 388, 395, 402, 410, 415, 420, 428, 444 694 }; 695 #endif 696 697 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE 698 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 699 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 700 static const char *const yytname[] = 701 { 702 "$end", "error", "$undefined", "DREG", "CREG", "GREG", "IMMED", "ADDR", 703 "INSN", "NUM", "ID", "NL", "PNUM", "','", "'|'", "'['", "']'", "'*'", 704 "':'", "'-'", "$accept", "insntbl", "entrys", "entry", "@1", 705 "fieldspecs", "ftype", "fieldspec", "flagexpr", "flags", "range", "pnum", 706 "regtype", "name", "value", 0 707 }; 708 #endif 709 710 # ifdef YYPRINT 711 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to 712 token YYLEX-NUM. */ 713 static const yytype_uint16 yytoknum[] = 714 { 715 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 716 265, 266, 267, 44, 124, 91, 93, 42, 58, 45 717 }; 718 # endif 719 720 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 721 static const yytype_uint8 yyr1[] = 722 { 723 0, 20, 21, 22, 22, 23, 24, 23, 23, 23, 724 25, 25, 25, 26, 26, 26, 27, 28, 28, 28, 725 29, 29, 30, 30, 31, 32, 32, 32, 33, 34 726 }; 727 728 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 729 static const yytype_uint8 yyr2[] = 730 { 731 0, 2, 1, 2, 0, 5, 0, 9, 1, 2, 732 3, 2, 0, 1, 1, 1, 3, 3, 3, 1, 733 2, 0, 4, 0, 1, 1, 1, 1, 1, 1 734 }; 735 736 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state 737 STATE-NUM when YYTABLE doesn't specify something else to do. Zero 738 means the default is an error. */ 739 static const yytype_uint8 yydefact[] = 740 { 741 0, 0, 8, 24, 0, 2, 0, 0, 9, 1, 742 3, 25, 26, 27, 0, 0, 28, 0, 0, 29, 743 23, 0, 0, 21, 5, 0, 0, 6, 0, 19, 744 0, 20, 12, 22, 0, 0, 15, 14, 0, 0, 745 23, 12, 13, 17, 18, 12, 7, 21, 11, 10, 746 16 747 }; 748 749 /* YYDEFGOTO[NTERM-NUM]. */ 750 static const yytype_int8 yydefgoto[] = 751 { 752 -1, 4, 5, 6, 32, 39, 40, 41, 31, 27, 753 23, 7, 42, 17, 20 754 }; 755 756 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 757 STATE-NUM. */ 758 #define YYPACT_NINF -16 759 static const yytype_int8 yypact[] = 760 { 761 0, -9, -16, -16, 10, -16, 0, 12, -16, -16, 762 -16, -16, -16, -16, 3, 3, -16, 9, 9, -16, 763 11, 8, 19, 15, -16, 14, -6, -16, 25, 21, 764 -6, -16, 1, -16, -6, 20, -16, -16, 18, 26, 765 11, 1, -16, -16, -16, 1, -16, 15, -16, -16, 766 -16 767 }; 768 769 /* YYPGOTO[NTERM-NUM]. */ 770 static const yytype_int8 yypgoto[] = 771 { 772 -16, -16, 32, -16, -16, -15, -16, 2, -3, -8, 773 4, -16, 34, 27, 28 774 }; 775 776 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 777 positive, shift that token. If negative, reduce the rule which 778 number is the opposite. If zero, do what YYDEFACT says. 779 If YYTABLE_NINF, syntax error. */ 780 #define YYTABLE_NINF -5 781 static const yytype_int8 yytable[] = 782 { 783 -4, 1, 8, 29, 11, 12, 13, 36, 37, 30, 784 9, 2, 3, 16, 38, 11, 12, 13, 19, 24, 785 14, 11, 12, 13, 36, 37, 48, 35, 25, 22, 786 49, 43, 26, 28, 33, 34, 44, 46, 10, 50, 787 45, 15, 18, 0, 47, 0, 21 788 }; 789 790 static const yytype_int8 yycheck[] = 791 { 792 0, 1, 11, 9, 3, 4, 5, 6, 7, 15, 793 0, 11, 12, 10, 13, 3, 4, 5, 9, 11, 794 8, 3, 4, 5, 6, 7, 41, 30, 9, 18, 795 45, 34, 17, 19, 9, 14, 16, 11, 6, 47, 796 38, 7, 15, -1, 40, -1, 18 797 }; 798 799 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 800 symbol of state STATE-NUM. */ 801 static const yytype_uint8 yystos[] = 802 { 803 0, 1, 11, 12, 21, 22, 23, 31, 11, 0, 804 22, 3, 4, 5, 8, 32, 10, 33, 33, 9, 805 34, 34, 18, 30, 11, 9, 17, 29, 19, 9, 806 15, 28, 24, 9, 14, 28, 6, 7, 13, 25, 807 26, 27, 32, 28, 16, 27, 11, 30, 25, 25, 808 29 809 }; 810 811 #define yyerrok (yyerrstatus = 0) 812 #define yyclearin (yychar = YYEMPTY) 813 #define YYEMPTY (-2) 814 #define YYEOF 0 815 816 #define YYACCEPT goto yyacceptlab 817 #define YYABORT goto yyabortlab 818 #define YYERROR goto yyerrorlab 819 820 821 /* Like YYERROR except do call yyerror. This remains here temporarily 822 to ease the transition to the new meaning of YYERROR, for GCC. 823 Once GCC version 2 has supplanted version 1, this can go. */ 824 825 #define YYFAIL goto yyerrlab 826 827 #define YYRECOVERING() (!!yyerrstatus) 828 829 #define YYBACKUP(Token, Value) \ 830 do \ 831 if (yychar == YYEMPTY && yylen == 1) \ 832 { \ 833 yychar = (Token); \ 834 yylval = (Value); \ 835 yytoken = YYTRANSLATE (yychar); \ 836 YYPOPSTACK (1); \ 837 goto yybackup; \ 838 } \ 839 else \ 840 { \ 841 yyerror (YY_("syntax error: cannot back up")); \ 842 YYERROR; \ 843 } \ 844 while (YYID (0)) 845 846 847 #define YYTERROR 1 848 #define YYERRCODE 256 849 850 851 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. 852 If N is 0, then set CURRENT to the empty location which ends 853 the previous symbol: RHS[0] (always defined). */ 854 855 #define YYRHSLOC(Rhs, K) ((Rhs)[K]) 856 #ifndef YYLLOC_DEFAULT 857 # define YYLLOC_DEFAULT(Current, Rhs, N) \ 858 do \ 859 if (YYID (N)) \ 860 { \ 861 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ 862 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ 863 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ 864 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ 865 } \ 866 else \ 867 { \ 868 (Current).first_line = (Current).last_line = \ 869 YYRHSLOC (Rhs, 0).last_line; \ 870 (Current).first_column = (Current).last_column = \ 871 YYRHSLOC (Rhs, 0).last_column; \ 872 } \ 873 while (YYID (0)) 874 #endif 875 876 877 /* YY_LOCATION_PRINT -- Print the location on the stream. 878 This macro was not mandated originally: define only if we know 879 we won't break user code: when these are the locations we know. */ 880 881 #ifndef YY_LOCATION_PRINT 882 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL 883 # define YY_LOCATION_PRINT(File, Loc) \ 884 fprintf (File, "%d.%d-%d.%d", \ 885 (Loc).first_line, (Loc).first_column, \ 886 (Loc).last_line, (Loc).last_column) 887 # else 888 # define YY_LOCATION_PRINT(File, Loc) ((void) 0) 889 # endif 890 #endif 891 892 893 /* YYLEX -- calling `yylex' with the right arguments. */ 894 895 #ifdef YYLEX_PARAM 896 # define YYLEX yylex (YYLEX_PARAM) 897 #else 898 # define YYLEX yylex () 899 #endif 900 901 /* Enable debugging if requested. */ 902 #if YYDEBUG 903 904 # ifndef YYFPRINTF 905 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 906 # define YYFPRINTF fprintf 907 # endif 908 909 # define YYDPRINTF(Args) \ 910 do { \ 911 if (yydebug) \ 912 YYFPRINTF Args; \ 913 } while (YYID (0)) 914 915 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 916 do { \ 917 if (yydebug) \ 918 { \ 919 YYFPRINTF (stderr, "%s ", Title); \ 920 yy_symbol_print (stderr, \ 921 Type, Value); \ 922 YYFPRINTF (stderr, "\n"); \ 923 } \ 924 } while (YYID (0)) 925 926 927 /*--------------------------------. 928 | Print this symbol on YYOUTPUT. | 929 `--------------------------------*/ 930 931 /*ARGSUSED*/ 932 #if (defined __STDC__ || defined __C99__FUNC__ \ 933 || defined __cplusplus || defined _MSC_VER) 934 static void 935 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 936 #else 937 static void 938 yy_symbol_value_print (yyoutput, yytype, yyvaluep) 939 FILE *yyoutput; 940 int yytype; 941 YYSTYPE const * const yyvaluep; 942 #endif 943 { 944 if (!yyvaluep) 945 return; 946 # ifdef YYPRINT 947 if (yytype < YYNTOKENS) 948 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 949 # else 950 YYUSE (yyoutput); 951 # endif 952 switch (yytype) 953 { 954 default: 955 break; 956 } 957 } 958 959 960 /*--------------------------------. 961 | Print this symbol on YYOUTPUT. | 962 `--------------------------------*/ 963 964 #if (defined __STDC__ || defined __C99__FUNC__ \ 965 || defined __cplusplus || defined _MSC_VER) 966 static void 967 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 968 #else 969 static void 970 yy_symbol_print (yyoutput, yytype, yyvaluep) 971 FILE *yyoutput; 972 int yytype; 973 YYSTYPE const * const yyvaluep; 974 #endif 975 { 976 if (yytype < YYNTOKENS) 977 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); 978 else 979 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); 980 981 yy_symbol_value_print (yyoutput, yytype, yyvaluep); 982 YYFPRINTF (yyoutput, ")"); 983 } 984 985 /*------------------------------------------------------------------. 986 | yy_stack_print -- Print the state stack from its BOTTOM up to its | 987 | TOP (included). | 988 `------------------------------------------------------------------*/ 989 990 #if (defined __STDC__ || defined __C99__FUNC__ \ 991 || defined __cplusplus || defined _MSC_VER) 992 static void 993 yy_stack_print (yytype_int16 *bottom, yytype_int16 *top) 994 #else 995 static void 996 yy_stack_print (bottom, top) 997 yytype_int16 *bottom; 998 yytype_int16 *top; 999 #endif 1000 { 1001 YYFPRINTF (stderr, "Stack now"); 1002 for (; bottom <= top; ++bottom) 1003 YYFPRINTF (stderr, " %d", *bottom); 1004 YYFPRINTF (stderr, "\n"); 1005 } 1006 1007 # define YY_STACK_PRINT(Bottom, Top) \ 1008 do { \ 1009 if (yydebug) \ 1010 yy_stack_print ((Bottom), (Top)); \ 1011 } while (YYID (0)) 1012 1013 1014 /*------------------------------------------------. 1015 | Report that the YYRULE is going to be reduced. | 1016 `------------------------------------------------*/ 1017 1018 #if (defined __STDC__ || defined __C99__FUNC__ \ 1019 || defined __cplusplus || defined _MSC_VER) 1020 static void 1021 yy_reduce_print (YYSTYPE *yyvsp, int yyrule) 1022 #else 1023 static void 1024 yy_reduce_print (yyvsp, yyrule) 1025 YYSTYPE *yyvsp; 1026 int yyrule; 1027 #endif 1028 { 1029 int yynrhs = yyr2[yyrule]; 1030 int yyi; 1031 unsigned long int yylno = yyrline[yyrule]; 1032 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", 1033 yyrule - 1, yylno); 1034 /* The symbols being reduced. */ 1035 for (yyi = 0; yyi < yynrhs; yyi++) 1036 { 1037 fprintf (stderr, " $%d = ", yyi + 1); 1038 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], 1039 &(yyvsp[(yyi + 1) - (yynrhs)]) 1040 ); 1041 fprintf (stderr, "\n"); 1042 } 1043 } 1044 1045 # define YY_REDUCE_PRINT(Rule) \ 1046 do { \ 1047 if (yydebug) \ 1048 yy_reduce_print (yyvsp, Rule); \ 1049 } while (YYID (0)) 1050 1051 /* Nonzero means print parse trace. It is left uninitialized so that 1052 multiple parsers can coexist. */ 1053 int yydebug; 1054 #else /* !YYDEBUG */ 1055 # define YYDPRINTF(Args) 1056 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) 1057 # define YY_STACK_PRINT(Bottom, Top) 1058 # define YY_REDUCE_PRINT(Rule) 1059 #endif /* !YYDEBUG */ 1060 1061 1062 /* YYINITDEPTH -- initial size of the parser's stacks. */ 1063 #ifndef YYINITDEPTH 1064 # define YYINITDEPTH 200 1065 #endif 1066 1067 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 1068 if the built-in stack extension method is used). 1069 1070 Do not make this value too large; the results are undefined if 1071 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 1072 evaluated with infinite-precision integer arithmetic. */ 1073 1074 #ifndef YYMAXDEPTH 1075 # define YYMAXDEPTH 10000 1076 #endif 1077 1078 1079 1080 #if YYERROR_VERBOSE 1081 1082 # ifndef yystrlen 1083 # if defined __GLIBC__ && defined _STRING_H 1084 # define yystrlen strlen 1085 # else 1086 /* Return the length of YYSTR. */ 1087 #if (defined __STDC__ || defined __C99__FUNC__ \ 1088 || defined __cplusplus || defined _MSC_VER) 1089 static YYSIZE_T 1090 yystrlen (const char *yystr) 1091 #else 1092 static YYSIZE_T 1093 yystrlen (yystr) 1094 const char *yystr; 1095 #endif 1096 { 1097 YYSIZE_T yylen; 1098 for (yylen = 0; yystr[yylen]; yylen++) 1099 continue; 1100 return yylen; 1101 } 1102 # endif 1103 # endif 1104 1105 # ifndef yystpcpy 1106 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 1107 # define yystpcpy stpcpy 1108 # else 1109 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 1110 YYDEST. */ 1111 #if (defined __STDC__ || defined __C99__FUNC__ \ 1112 || defined __cplusplus || defined _MSC_VER) 1113 static char * 1114 yystpcpy (char *yydest, const char *yysrc) 1115 #else 1116 static char * 1117 yystpcpy (yydest, yysrc) 1118 char *yydest; 1119 const char *yysrc; 1120 #endif 1121 { 1122 char *yyd = yydest; 1123 const char *yys = yysrc; 1124 1125 while ((*yyd++ = *yys++) != '\0') 1126 continue; 1127 1128 return yyd - 1; 1129 } 1130 # endif 1131 # endif 1132 1133 # ifndef yytnamerr 1134 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary 1135 quotes and backslashes, so that it's suitable for yyerror. The 1136 heuristic is that double-quoting is unnecessary unless the string 1137 contains an apostrophe, a comma, or backslash (other than 1138 backslash-backslash). YYSTR is taken from yytname. If YYRES is 1139 null, do not copy; instead, return the length of what the result 1140 would have been. */ 1141 static YYSIZE_T 1142 yytnamerr (char *yyres, const char *yystr) 1143 { 1144 if (*yystr == '"') 1145 { 1146 YYSIZE_T yyn = 0; 1147 char const *yyp = yystr; 1148 1149 for (;;) 1150 switch (*++yyp) 1151 { 1152 case '\'': 1153 case ',': 1154 goto do_not_strip_quotes; 1155 1156 case '\\': 1157 if (*++yyp != '\\') 1158 goto do_not_strip_quotes; 1159 /* Fall through. */ 1160 default: 1161 if (yyres) 1162 yyres[yyn] = *yyp; 1163 yyn++; 1164 break; 1165 1166 case '"': 1167 if (yyres) 1168 yyres[yyn] = '\0'; 1169 return yyn; 1170 } 1171 do_not_strip_quotes: ; 1172 } 1173 1174 if (! yyres) 1175 return yystrlen (yystr); 1176 1177 return yystpcpy (yyres, yystr) - yyres; 1178 } 1179 # endif 1180 1181 /* Copy into YYRESULT an error message about the unexpected token 1182 YYCHAR while in state YYSTATE. Return the number of bytes copied, 1183 including the terminating null byte. If YYRESULT is null, do not 1184 copy anything; just return the number of bytes that would be 1185 copied. As a special case, return 0 if an ordinary "syntax error" 1186 message will do. Return YYSIZE_MAXIMUM if overflow occurs during 1187 size calculation. */ 1188 static YYSIZE_T 1189 yysyntax_error (char *yyresult, int yystate, int yychar) 1190 { 1191 int yyn = yypact[yystate]; 1192 1193 if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) 1194 return 0; 1195 else 1196 { 1197 int yytype = YYTRANSLATE (yychar); 1198 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); 1199 YYSIZE_T yysize = yysize0; 1200 YYSIZE_T yysize1; 1201 int yysize_overflow = 0; 1202 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 1203 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 1204 int yyx; 1205 1206 # if 0 1207 /* This is so xgettext sees the translatable formats that are 1208 constructed on the fly. */ 1209 YY_("syntax error, unexpected %s"); 1210 YY_("syntax error, unexpected %s, expecting %s"); 1211 YY_("syntax error, unexpected %s, expecting %s or %s"); 1212 YY_("syntax error, unexpected %s, expecting %s or %s or %s"); 1213 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); 1214 # endif 1215 char *yyfmt; 1216 char const *yyf; 1217 static char const yyunexpected[] = "syntax error, unexpected %s"; 1218 static char const yyexpecting[] = ", expecting %s"; 1219 static char const yyor[] = " or %s"; 1220 char yyformat[sizeof yyunexpected 1221 + sizeof yyexpecting - 1 1222 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) 1223 * (sizeof yyor - 1))]; 1224 char const *yyprefix = yyexpecting; 1225 1226 /* Start YYX at -YYN if negative to avoid negative indexes in 1227 YYCHECK. */ 1228 int yyxbegin = yyn < 0 ? -yyn : 0; 1229 1230 /* Stay within bounds of both yycheck and yytname. */ 1231 int yychecklim = YYLAST - yyn + 1; 1232 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 1233 int yycount = 1; 1234 1235 yyarg[0] = yytname[yytype]; 1236 yyfmt = yystpcpy (yyformat, yyunexpected); 1237 1238 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 1239 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) 1240 { 1241 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 1242 { 1243 yycount = 1; 1244 yysize = yysize0; 1245 yyformat[sizeof yyunexpected - 1] = '\0'; 1246 break; 1247 } 1248 yyarg[yycount++] = yytname[yyx]; 1249 yysize1 = yysize + yytnamerr (0, yytname[yyx]); 1250 yysize_overflow |= (yysize1 < yysize); 1251 yysize = yysize1; 1252 yyfmt = yystpcpy (yyfmt, yyprefix); 1253 yyprefix = yyor; 1254 } 1255 1256 yyf = YY_(yyformat); 1257 yysize1 = yysize + yystrlen (yyf); 1258 yysize_overflow |= (yysize1 < yysize); 1259 yysize = yysize1; 1260 1261 if (yysize_overflow) 1262 return YYSIZE_MAXIMUM; 1263 1264 if (yyresult) 1265 { 1266 /* Avoid sprintf, as that infringes on the user's name space. 1267 Don't have undefined behavior even if the translation 1268 produced a string with the wrong number of "%s"s. */ 1269 char *yyp = yyresult; 1270 int yyi = 0; 1271 while ((*yyp = *yyf) != '\0') 1272 { 1273 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) 1274 { 1275 yyp += yytnamerr (yyp, yyarg[yyi++]); 1276 yyf += 2; 1277 } 1278 else 1279 { 1280 yyp++; 1281 yyf++; 1282 } 1283 } 1284 } 1285 return yysize; 1286 } 1287 } 1288 #endif /* YYERROR_VERBOSE */ 1289 1290 1291 /*-----------------------------------------------. 1292 | Release the memory associated to this symbol. | 1293 `-----------------------------------------------*/ 1294 1295 /*ARGSUSED*/ 1296 #if (defined __STDC__ || defined __C99__FUNC__ \ 1297 || defined __cplusplus || defined _MSC_VER) 1298 static void 1299 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) 1300 #else 1301 static void 1302 yydestruct (yymsg, yytype, yyvaluep) 1303 const char *yymsg; 1304 int yytype; 1305 YYSTYPE *yyvaluep; 1306 #endif 1307 { 1308 YYUSE (yyvaluep); 1309 1310 if (!yymsg) 1311 yymsg = "Deleting"; 1312 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1313 1314 switch (yytype) 1315 { 1316 1317 default: 1318 break; 1319 } 1320 } 1321 1322 1323 /* Prevent warnings from -Wmissing-prototypes. */ 1324 1325 #ifdef YYPARSE_PARAM 1326 #if defined __STDC__ || defined __cplusplus 1327 int yyparse (void *YYPARSE_PARAM); 1328 #else 1329 int yyparse (); 1330 #endif 1331 #else /* ! YYPARSE_PARAM */ 1332 #if defined __STDC__ || defined __cplusplus 1333 int yyparse (void); 1334 #else 1335 int yyparse (); 1336 #endif 1337 #endif /* ! YYPARSE_PARAM */ 1338 1339 1340 1341 /* The look-ahead symbol. */ 1342 int yychar; 1343 1344 /* The semantic value of the look-ahead symbol. */ 1345 YYSTYPE yylval; 1346 1347 /* Number of syntax errors so far. */ 1348 int yynerrs; 1349 1350 1351 1352 /*----------. 1353 | yyparse. | 1354 `----------*/ 1355 1356 #ifdef YYPARSE_PARAM 1357 #if (defined __STDC__ || defined __C99__FUNC__ \ 1358 || defined __cplusplus || defined _MSC_VER) 1359 int 1360 yyparse (void *YYPARSE_PARAM) 1361 #else 1362 int 1363 yyparse (YYPARSE_PARAM) 1364 void *YYPARSE_PARAM; 1365 #endif 1366 #else /* ! YYPARSE_PARAM */ 1367 #if (defined __STDC__ || defined __C99__FUNC__ \ 1368 || defined __cplusplus || defined _MSC_VER) 1369 int 1370 yyparse (void) 1371 #else 1372 int 1373 yyparse () 1374 1375 #endif 1376 #endif 1377 { 1378 1379 int yystate; 1380 int yyn; 1381 int yyresult; 1382 /* Number of tokens to shift before error messages enabled. */ 1383 int yyerrstatus; 1384 /* Look-ahead token as an internal (translated) token number. */ 1385 int yytoken = 0; 1386 #if YYERROR_VERBOSE 1387 /* Buffer for error messages, and its allocated size. */ 1388 char yymsgbuf[128]; 1389 char *yymsg = yymsgbuf; 1390 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 1391 #endif 1392 1393 /* Three stacks and their tools: 1394 `yyss': related to states, 1395 `yyvs': related to semantic values, 1396 `yyls': related to locations. 1397 1398 Refer to the stacks thru separate pointers, to allow yyoverflow 1399 to reallocate them elsewhere. */ 1400 1401 /* The state stack. */ 1402 yytype_int16 yyssa[YYINITDEPTH]; 1403 yytype_int16 *yyss = yyssa; 1404 yytype_int16 *yyssp; 1405 1406 /* The semantic value stack. */ 1407 YYSTYPE yyvsa[YYINITDEPTH]; 1408 YYSTYPE *yyvs = yyvsa; 1409 YYSTYPE *yyvsp; 1410 1411 1412 1413 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 1414 1415 YYSIZE_T yystacksize = YYINITDEPTH; 1416 1417 /* The variables used to return semantic value and location from the 1418 action routines. */ 1419 YYSTYPE yyval; 1420 1421 1422 /* The number of symbols on the RHS of the reduced rule. 1423 Keep to zero when no symbol should be popped. */ 1424 int yylen = 0; 1425 1426 YYDPRINTF ((stderr, "Starting parse\n")); 1427 1428 yystate = 0; 1429 yyerrstatus = 0; 1430 yynerrs = 0; 1431 yychar = YYEMPTY; /* Cause a token to be read. */ 1432 1433 /* Initialize stack pointers. 1434 Waste one element of value and location stack 1435 so that they stay on the same level as the state stack. 1436 The wasted elements are never initialized. */ 1437 1438 yyssp = yyss; 1439 yyvsp = yyvs; 1440 1441 goto yysetstate; 1442 1443 /*------------------------------------------------------------. 1444 | yynewstate -- Push a new state, which is found in yystate. | 1445 `------------------------------------------------------------*/ 1446 yynewstate: 1447 /* In all cases, when you get here, the value and location stacks 1448 have just been pushed. So pushing a state here evens the stacks. */ 1449 yyssp++; 1450 1451 yysetstate: 1452 *yyssp = yystate; 1453 1454 if (yyss + yystacksize - 1 <= yyssp) 1455 { 1456 /* Get the current used size of the three stacks, in elements. */ 1457 YYSIZE_T yysize = yyssp - yyss + 1; 1458 1459 #ifdef yyoverflow 1460 { 1461 /* Give user a chance to reallocate the stack. Use copies of 1462 these so that the &'s don't force the real ones into 1463 memory. */ 1464 YYSTYPE *yyvs1 = yyvs; 1465 yytype_int16 *yyss1 = yyss; 1466 1467 1468 /* Each stack pointer address is followed by the size of the 1469 data in use in that stack, in bytes. This used to be a 1470 conditional around just the two extra args, but that might 1471 be undefined if yyoverflow is a macro. */ 1472 yyoverflow (YY_("memory exhausted"), 1473 &yyss1, yysize * sizeof (*yyssp), 1474 &yyvs1, yysize * sizeof (*yyvsp), 1475 1476 &yystacksize); 1477 1478 yyss = yyss1; 1479 yyvs = yyvs1; 1480 } 1481 #else /* no yyoverflow */ 1482 # ifndef YYSTACK_RELOCATE 1483 goto yyexhaustedlab; 1484 # else 1485 /* Extend the stack our own way. */ 1486 if (YYMAXDEPTH <= yystacksize) 1487 goto yyexhaustedlab; 1488 yystacksize *= 2; 1489 if (YYMAXDEPTH < yystacksize) 1490 yystacksize = YYMAXDEPTH; 1491 1492 { 1493 yytype_int16 *yyss1 = yyss; 1494 union yyalloc *yyptr = 1495 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 1496 if (! yyptr) 1497 goto yyexhaustedlab; 1498 YYSTACK_RELOCATE (yyss); 1499 YYSTACK_RELOCATE (yyvs); 1500 1501 # undef YYSTACK_RELOCATE 1502 if (yyss1 != yyssa) 1503 YYSTACK_FREE (yyss1); 1504 } 1505 # endif 1506 #endif /* no yyoverflow */ 1507 1508 yyssp = yyss + yysize - 1; 1509 yyvsp = yyvs + yysize - 1; 1510 1511 1512 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 1513 (unsigned long int) yystacksize)); 1514 1515 if (yyss + yystacksize - 1 <= yyssp) 1516 YYABORT; 1517 } 1518 1519 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1520 1521 goto yybackup; 1522 1523 /*-----------. 1524 | yybackup. | 1525 `-----------*/ 1526 yybackup: 1527 1528 /* Do appropriate processing given the current state. Read a 1529 look-ahead token if we need one and don't already have one. */ 1530 1531 /* First try to decide what to do without reference to look-ahead token. */ 1532 yyn = yypact[yystate]; 1533 if (yyn == YYPACT_NINF) 1534 goto yydefault; 1535 1536 /* Not known => get a look-ahead token if don't already have one. */ 1537 1538 /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ 1539 if (yychar == YYEMPTY) 1540 { 1541 YYDPRINTF ((stderr, "Reading a token: ")); 1542 yychar = YYLEX; 1543 } 1544 1545 if (yychar <= YYEOF) 1546 { 1547 yychar = yytoken = YYEOF; 1548 YYDPRINTF ((stderr, "Now at end of input.\n")); 1549 } 1550 else 1551 { 1552 yytoken = YYTRANSLATE (yychar); 1553 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1554 } 1555 1556 /* If the proper action on seeing token YYTOKEN is to reduce or to 1557 detect an error, take that action. */ 1558 yyn += yytoken; 1559 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 1560 goto yydefault; 1561 yyn = yytable[yyn]; 1562 if (yyn <= 0) 1563 { 1564 if (yyn == 0 || yyn == YYTABLE_NINF) 1565 goto yyerrlab; 1566 yyn = -yyn; 1567 goto yyreduce; 1568 } 1569 1570 if (yyn == YYFINAL) 1571 YYACCEPT; 1572 1573 /* Count tokens shifted since error; after three, turn off error 1574 status. */ 1575 if (yyerrstatus) 1576 yyerrstatus--; 1577 1578 /* Shift the look-ahead token. */ 1579 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1580 1581 /* Discard the shifted token unless it is eof. */ 1582 if (yychar != YYEOF) 1583 yychar = YYEMPTY; 1584 1585 yystate = yyn; 1586 *++yyvsp = yylval; 1587 1588 goto yynewstate; 1589 1590 1591 /*-----------------------------------------------------------. 1592 | yydefault -- do the default action for the current state. | 1593 `-----------------------------------------------------------*/ 1594 yydefault: 1595 yyn = yydefact[yystate]; 1596 if (yyn == 0) 1597 goto yyerrlab; 1598 goto yyreduce; 1599 1600 1601 /*-----------------------------. 1602 | yyreduce -- Do a reduction. | 1603 `-----------------------------*/ 1604 yyreduce: 1605 /* yyn is the number of a rule to reduce with. */ 1606 yylen = yyr2[yyn]; 1607 1608 /* If YYLEN is nonzero, implement the default value of the action: 1609 `$$ = $1'. 1610 1611 Otherwise, the following line sets YYVAL to garbage. 1612 This behavior is undocumented and Bison 1613 users should not rely upon it. Assigning to YYVAL 1614 unconditionally makes the parser a bit smaller, and it avoids a 1615 GCC warning that YYVAL may be used uninitialized. */ 1616 yyval = yyvsp[1-yylen]; 1617 1618 1619 YY_REDUCE_PRINT (yyn); 1620 switch (yyn) 1621 { 1622 case 5: 1623 #line 309 "./itbl-parse.y" 1624 { 1625 DBG (("line %d: entry pnum=%d type=%d name=%s value=x%x\n", 1626 insntbl_line, (yyvsp[(1) - (5)].num), (yyvsp[(2) - (5)].num), (yyvsp[(3) - (5)].str), (yyvsp[(4) - (5)].val))); 1627 itbl_add_reg ((yyvsp[(1) - (5)].num), (yyvsp[(2) - (5)].num), (yyvsp[(3) - (5)].str), (yyvsp[(4) - (5)].val)); 1628 } 1629 break; 1630 1631 case 6: 1632 #line 315 "./itbl-parse.y" 1633 { 1634 DBG (("line %d: entry pnum=%d type=INSN name=%s value=x%x", 1635 insntbl_line, (yyvsp[(1) - (6)].num), (yyvsp[(3) - (6)].str), (yyvsp[(4) - (6)].val))); 1636 DBG ((" sbit=%d ebit=%d flags=0x%x\n", sbit, ebit, (yyvsp[(6) - (6)].val))); 1637 insn=itbl_add_insn ((yyvsp[(1) - (6)].num), (yyvsp[(3) - (6)].str), (yyvsp[(4) - (6)].val), sbit, ebit, (yyvsp[(6) - (6)].val)); 1638 } 1639 break; 1640 1641 case 7: 1642 #line 322 "./itbl-parse.y" 1643 {} 1644 break; 1645 1646 case 13: 1647 #line 335 "./itbl-parse.y" 1648 { 1649 DBGL2 (("ftype\n")); 1650 (yyval.num) = (yyvsp[(1) - (1)].num); 1651 } 1652 break; 1653 1654 case 14: 1655 #line 340 "./itbl-parse.y" 1656 { 1657 DBGL2 (("addr\n")); 1658 (yyval.num) = ADDR; 1659 } 1660 break; 1661 1662 case 15: 1663 #line 345 "./itbl-parse.y" 1664 { 1665 DBGL2 (("immed\n")); 1666 (yyval.num) = IMMED; 1667 } 1668 break; 1669 1670 case 16: 1671 #line 353 "./itbl-parse.y" 1672 { 1673 DBG (("line %d: field type=%d sbit=%d ebit=%d, flags=0x%x\n", 1674 insntbl_line, (yyvsp[(1) - (3)].num), sbit, ebit, (yyvsp[(3) - (3)].val))); 1675 itbl_add_operand (insn, (yyvsp[(1) - (3)].num), sbit, ebit, (yyvsp[(3) - (3)].val)); 1676 } 1677 break; 1678 1679 case 17: 1680 #line 362 "./itbl-parse.y" 1681 { 1682 (yyval.val) = (yyvsp[(1) - (3)].num) | (yyvsp[(3) - (3)].val); 1683 } 1684 break; 1685 1686 case 18: 1687 #line 366 "./itbl-parse.y" 1688 { 1689 (yyval.val) = (yyvsp[(2) - (3)].val); 1690 } 1691 break; 1692 1693 case 19: 1694 #line 370 "./itbl-parse.y" 1695 { 1696 (yyval.val) = (yyvsp[(1) - (1)].num); 1697 } 1698 break; 1699 1700 case 20: 1701 #line 377 "./itbl-parse.y" 1702 { 1703 DBGL2 (("flags=%d\n", (yyvsp[(2) - (2)].val))); 1704 (yyval.val) = (yyvsp[(2) - (2)].val); 1705 } 1706 break; 1707 1708 case 21: 1709 #line 382 "./itbl-parse.y" 1710 { 1711 (yyval.val) = 0; 1712 } 1713 break; 1714 1715 case 22: 1716 #line 389 "./itbl-parse.y" 1717 { 1718 DBGL2 (("range %d %d\n", (yyvsp[(2) - (4)].num), (yyvsp[(4) - (4)].num))); 1719 sbit = (yyvsp[(2) - (4)].num); 1720 ebit = (yyvsp[(4) - (4)].num); 1721 } 1722 break; 1723 1724 case 23: 1725 #line 395 "./itbl-parse.y" 1726 { 1727 sbit = 31; 1728 ebit = 0; 1729 } 1730 break; 1731 1732 case 24: 1733 #line 403 "./itbl-parse.y" 1734 { 1735 DBGL2 (("pnum=%d\n",(yyvsp[(1) - (1)].num))); 1736 (yyval.num) = (yyvsp[(1) - (1)].num); 1737 } 1738 break; 1739 1740 case 25: 1741 #line 411 "./itbl-parse.y" 1742 { 1743 DBGL2 (("dreg\n")); 1744 (yyval.num) = DREG; 1745 } 1746 break; 1747 1748 case 26: 1749 #line 416 "./itbl-parse.y" 1750 { 1751 DBGL2 (("creg\n")); 1752 (yyval.num) = CREG; 1753 } 1754 break; 1755 1756 case 27: 1757 #line 421 "./itbl-parse.y" 1758 { 1759 DBGL2 (("greg\n")); 1760 (yyval.num) = GREG; 1761 } 1762 break; 1763 1764 case 28: 1765 #line 429 "./itbl-parse.y" 1766 { 1767 DBGL2 (("name=%s\n",(yyvsp[(1) - (1)].str))); 1768 (yyval.str) = (yyvsp[(1) - (1)].str); 1769 } 1770 break; 1771 1772 case 29: 1773 #line 445 "./itbl-parse.y" 1774 { 1775 DBGL2 (("val=x%x\n",(yyvsp[(1) - (1)].num))); 1776 (yyval.val) = (yyvsp[(1) - (1)].num); 1777 } 1778 break; 1779 1780 1781 /* Line 1267 of yacc.c. */ 1782 #line 1783 "itbl-parse.c" 1783 default: break; 1784 } 1785 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 1786 1787 YYPOPSTACK (yylen); 1788 yylen = 0; 1789 YY_STACK_PRINT (yyss, yyssp); 1790 1791 *++yyvsp = yyval; 1792 1793 1794 /* Now `shift' the result of the reduction. Determine what state 1795 that goes to, based on the state we popped back to and the rule 1796 number reduced by. */ 1797 1798 yyn = yyr1[yyn]; 1799 1800 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 1801 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 1802 yystate = yytable[yystate]; 1803 else 1804 yystate = yydefgoto[yyn - YYNTOKENS]; 1805 1806 goto yynewstate; 1807 1808 1809 /*------------------------------------. 1810 | yyerrlab -- here on detecting error | 1811 `------------------------------------*/ 1812 yyerrlab: 1813 /* If not already recovering from an error, report this error. */ 1814 if (!yyerrstatus) 1815 { 1816 ++yynerrs; 1817 #if ! YYERROR_VERBOSE 1818 yyerror (YY_("syntax error")); 1819 #else 1820 { 1821 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); 1822 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) 1823 { 1824 YYSIZE_T yyalloc = 2 * yysize; 1825 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) 1826 yyalloc = YYSTACK_ALLOC_MAXIMUM; 1827 if (yymsg != yymsgbuf) 1828 YYSTACK_FREE (yymsg); 1829 yymsg = (char *) YYSTACK_ALLOC (yyalloc); 1830 if (yymsg) 1831 yymsg_alloc = yyalloc; 1832 else 1833 { 1834 yymsg = yymsgbuf; 1835 yymsg_alloc = sizeof yymsgbuf; 1836 } 1837 } 1838 1839 if (0 < yysize && yysize <= yymsg_alloc) 1840 { 1841 (void) yysyntax_error (yymsg, yystate, yychar); 1842 yyerror (yymsg); 1843 } 1844 else 1845 { 1846 yyerror (YY_("syntax error")); 1847 if (yysize != 0) 1848 goto yyexhaustedlab; 1849 } 1850 } 1851 #endif 1852 } 1853 1854 1855 1856 if (yyerrstatus == 3) 1857 { 1858 /* If just tried and failed to reuse look-ahead token after an 1859 error, discard it. */ 1860 1861 if (yychar <= YYEOF) 1862 { 1863 /* Return failure if at end of input. */ 1864 if (yychar == YYEOF) 1865 YYABORT; 1866 } 1867 else 1868 { 1869 yydestruct ("Error: discarding", 1870 yytoken, &yylval); 1871 yychar = YYEMPTY; 1872 } 1873 } 1874 1875 /* Else will try to reuse look-ahead token after shifting the error 1876 token. */ 1877 goto yyerrlab1; 1878 1879 1880 /*---------------------------------------------------. 1881 | yyerrorlab -- error raised explicitly by YYERROR. | 1882 `---------------------------------------------------*/ 1883 yyerrorlab: 1884 1885 /* Pacify compilers like GCC when the user code never invokes 1886 YYERROR and the label yyerrorlab therefore never appears in user 1887 code. */ 1888 if (/*CONSTCOND*/ 0) 1889 goto yyerrorlab; 1890 1891 /* Do not reclaim the symbols of the rule which action triggered 1892 this YYERROR. */ 1893 YYPOPSTACK (yylen); 1894 yylen = 0; 1895 YY_STACK_PRINT (yyss, yyssp); 1896 yystate = *yyssp; 1897 goto yyerrlab1; 1898 1899 1900 /*-------------------------------------------------------------. 1901 | yyerrlab1 -- common code for both syntax error and YYERROR. | 1902 `-------------------------------------------------------------*/ 1903 yyerrlab1: 1904 yyerrstatus = 3; /* Each real token shifted decrements this. */ 1905 1906 for (;;) 1907 { 1908 yyn = yypact[yystate]; 1909 if (yyn != YYPACT_NINF) 1910 { 1911 yyn += YYTERROR; 1912 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 1913 { 1914 yyn = yytable[yyn]; 1915 if (0 < yyn) 1916 break; 1917 } 1918 } 1919 1920 /* Pop the current state because it cannot handle the error token. */ 1921 if (yyssp == yyss) 1922 YYABORT; 1923 1924 1925 yydestruct ("Error: popping", 1926 yystos[yystate], yyvsp); 1927 YYPOPSTACK (1); 1928 yystate = *yyssp; 1929 YY_STACK_PRINT (yyss, yyssp); 1930 } 1931 1932 if (yyn == YYFINAL) 1933 YYACCEPT; 1934 1935 *++yyvsp = yylval; 1936 1937 1938 /* Shift the error token. */ 1939 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 1940 1941 yystate = yyn; 1942 goto yynewstate; 1943 1944 1945 /*-------------------------------------. 1946 | yyacceptlab -- YYACCEPT comes here. | 1947 `-------------------------------------*/ 1948 yyacceptlab: 1949 yyresult = 0; 1950 goto yyreturn; 1951 1952 /*-----------------------------------. 1953 | yyabortlab -- YYABORT comes here. | 1954 `-----------------------------------*/ 1955 yyabortlab: 1956 yyresult = 1; 1957 goto yyreturn; 1958 1959 #ifndef yyoverflow 1960 /*-------------------------------------------------. 1961 | yyexhaustedlab -- memory exhaustion comes here. | 1962 `-------------------------------------------------*/ 1963 yyexhaustedlab: 1964 yyerror (YY_("memory exhausted")); 1965 yyresult = 2; 1966 /* Fall through. */ 1967 #endif 1968 1969 yyreturn: 1970 if (yychar != YYEOF && yychar != YYEMPTY) 1971 yydestruct ("Cleanup: discarding lookahead", 1972 yytoken, &yylval); 1973 /* Do not reclaim the symbols of the rule which action triggered 1974 this YYABORT or YYACCEPT. */ 1975 YYPOPSTACK (yylen); 1976 YY_STACK_PRINT (yyss, yyssp); 1977 while (yyssp != yyss) 1978 { 1979 yydestruct ("Cleanup: popping", 1980 yystos[*yyssp], yyvsp); 1981 YYPOPSTACK (1); 1982 } 1983 #ifndef yyoverflow 1984 if (yyss != yyssa) 1985 YYSTACK_FREE (yyss); 1986 #endif 1987 #if YYERROR_VERBOSE 1988 if (yymsg != yymsgbuf) 1989 YYSTACK_FREE (yymsg); 1990 #endif 1991 /* Make sure YYID is used. */ 1992 return YYID (yyresult); 1993 } 1994 1995 1996 #line 450 "./itbl-parse.y" 1997 1998 1999 static int 2000 yyerror (const char *msg) 2001 { 2002 printf ("line %d: %s\n", insntbl_line, msg); 2003 return 0; 2004 } 2005 2006