1 /* A Bison parser, made by GNU Bison 2.3. */
3 /* Skeleton implementation for Bison's Yacc-like parsers in C
5 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
6 Free Software Foundation, Inc.
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)
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.
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. */
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.
33 This special exception was added by the Free Software Foundation in
34 version 2.2 of Bison. */
36 /* C LALR(1) parser skeleton written by Richard Stallman, by
37 simplifying the original so-called "semantic" parser. */
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. */
46 /* Identify Bison output. */
50 #define YYBISON_VERSION "2.3"
53 #define YYSKELETON_NAME "yacc.c"
58 /* Using locations. */
59 #define YYLSP_NEEDED 0
61 /* Substitute the variable and function names. */
62 #define yyparse rx_parse
64 #define yyerror rx_error
65 #define yylval rx_lval
66 #define yychar rx_char
67 #define yydebug rx_debug
68 #define yynerrs rx_nerrs
74 /* Put the tokens into the symbol table, so that GDB and other debuggers
196 #define UNKNOWN_OPCODE 262
197 #define IS_OPCODE 263
308 /* Copy the first part of user declarations. */
309 #line 21 "rx-parse.y"
313 #include "safe-ctype.h"
316 static int rx_lex (void);
328 static int sizemap[] = { BSIZE, WSIZE, LSIZE, WSIZE };
330 /* Ok, here are the rules for using these macros...
332 B*() is used to specify the base opcode bytes. Fields to be filled
333 in later, leave zero. Call this first.
335 F() and FE() are used to fill in fields within the base opcode bytes. You MUST
336 call B*() before any F() or FE().
338 [UN]*O*(), PC*() appends operands to the end of the opcode. You
339 must call P() and B*() before any of these, so that the fixups
340 have the right byte location.
341 O = signed, UO = unsigned, NO = negated, PC = pcrel
343 IMM() adds an immediate and fills in the field for it.
344 NIMM() same, but negates the immediate.
345 NBIMM() same, but negates the immediate, for sbb.
346 DSP() adds a displacement, and fills in the field for it.
348 Note that order is significant for the O, IMM, and DSP macros, as
349 they append their data to the operand buffer in the order that you
352 Use "disp" for displacements whenever possible; this handles the
353 "0" case properly. */
355 #define B1(b1) rx_base1 (b1)
356 #define B2(b1, b2) rx_base2 (b1, b2)
357 #define B3(b1, b2, b3) rx_base3 (b1, b2, b3)
358 #define B4(b1, b2, b3, b4) rx_base4 (b1, b2, b3, b4)
360 /* POS is bits from the MSB of the first byte to the LSB of the last byte. */
361 #define F(val,pos,sz) rx_field (val, pos, sz)
362 #define FE(exp,pos,sz) rx_field (exp_val (exp), pos, sz);
364 #define O1(v) rx_op (v, 1, RXREL_SIGNED)
365 #define O2(v) rx_op (v, 2, RXREL_SIGNED)
366 #define O3(v) rx_op (v, 3, RXREL_SIGNED)
367 #define O4(v) rx_op (v, 4, RXREL_SIGNED)
369 #define UO1(v) rx_op (v, 1, RXREL_UNSIGNED)
370 #define UO2(v) rx_op (v, 2, RXREL_UNSIGNED)
371 #define UO3(v) rx_op (v, 3, RXREL_UNSIGNED)
372 #define UO4(v) rx_op (v, 4, RXREL_UNSIGNED)
374 #define NO1(v) rx_op (v, 1, RXREL_NEGATIVE)
375 #define NO2(v) rx_op (v, 2, RXREL_NEGATIVE)
376 #define NO3(v) rx_op (v, 3, RXREL_NEGATIVE)
377 #define NO4(v) rx_op (v, 4, RXREL_NEGATIVE)
379 #define PC1(v) rx_op (v, 1, RXREL_PCREL)
380 #define PC2(v) rx_op (v, 2, RXREL_PCREL)
381 #define PC3(v) rx_op (v, 3, RXREL_PCREL)
383 #define IMM(v,pos) F (immediate (v, RXREL_SIGNED, pos), pos, 2); \
384 if (v.X_op != O_constant && v.X_op != O_big) rx_linkrelax_imm (pos)
385 #define NIMM(v,pos) F (immediate (v, RXREL_NEGATIVE, pos), pos, 2)
386 #define NBIMM(v,pos) F (immediate (v, RXREL_NEGATIVE_BORROW, pos), pos, 2)
387 #define DSP(v,pos,msz) if (!v.X_md) rx_relax (RX_RELAX_DISP, pos); \
388 else rx_linkrelax_dsp (pos); \
389 F (displacement (v, msz), pos, 2)
391 #define id24(a,b2,b3) B3 (0xfb+a, b2, b3)
393 static int rx_intop (expressionS, int);
394 static int rx_uintop (expressionS, int);
395 static int rx_disp3op (expressionS);
396 static int rx_disp5op (expressionS *, int);
397 static int rx_disp5op0 (expressionS *, int);
398 static int exp_val (expressionS exp);
399 static expressionS zero_expr (void);
400 static int immediate (expressionS, int, int);
401 static int displacement (expressionS, int);
402 static void rtsd_immediate (expressionS);
404 static int need_flag = 0;
405 static int rx_in_brackets = 0;
406 static int rx_last_token = 0;
407 static char * rx_init_start;
408 static char * rx_last_exp_start = 0;
413 #define YYERROR_VERBOSE 1
417 /* Enabling traces. */
422 /* Enabling verbose error messages. */
423 #ifdef YYERROR_VERBOSE
424 # undef YYERROR_VERBOSE
425 # define YYERROR_VERBOSE 1
427 # define YYERROR_VERBOSE 0
430 /* Enabling the token table. */
431 #ifndef YYTOKEN_TABLE
432 # define YYTOKEN_TABLE 0
435 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
436 typedef union YYSTYPE
437 #line 130 "rx-parse.y"
442 /* Line 193 of yacc.c. */
443 #line 444 "rx-parse.c"
445 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
446 # define YYSTYPE_IS_DECLARED 1
447 # define YYSTYPE_IS_TRIVIAL 1
452 /* Copy the second part of user declarations. */
455 /* Line 216 of yacc.c. */
456 #line 457 "rx-parse.c"
463 typedef YYTYPE_UINT8 yytype_uint8;
465 typedef unsigned char yytype_uint8;
469 typedef YYTYPE_INT8 yytype_int8;
470 #elif (defined __STDC__ || defined __C99__FUNC__ \
471 || defined __cplusplus || defined _MSC_VER)
472 typedef signed char yytype_int8;
474 typedef short int yytype_int8;
478 typedef YYTYPE_UINT16 yytype_uint16;
480 typedef unsigned short int yytype_uint16;
484 typedef YYTYPE_INT16 yytype_int16;
486 typedef short int yytype_int16;
490 # ifdef __SIZE_TYPE__
491 # define YYSIZE_T __SIZE_TYPE__
492 # elif defined size_t
493 # define YYSIZE_T size_t
494 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
495 || defined __cplusplus || defined _MSC_VER)
496 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
497 # define YYSIZE_T size_t
499 # define YYSIZE_T unsigned int
503 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
506 # if defined YYENABLE_NLS && YYENABLE_NLS
508 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
509 # define YY_(msgid) dgettext ("bison-runtime", msgid)
513 # define YY_(msgid) msgid
517 /* Suppress unused-variable warnings by "using" E. */
518 #if ! defined lint || defined __GNUC__
519 # define YYUSE(e) ((void) (e))
521 # define YYUSE(e) /* empty */
524 /* Identity function, used to suppress warnings about constant conditions. */
528 #if (defined __STDC__ || defined __C99__FUNC__ \
529 || defined __cplusplus || defined _MSC_VER)
542 #if ! defined yyoverflow || YYERROR_VERBOSE
544 /* The parser invokes alloca or malloc; define the necessary symbols. */
546 # ifdef YYSTACK_USE_ALLOCA
547 # if YYSTACK_USE_ALLOCA
549 # define YYSTACK_ALLOC __builtin_alloca
550 # elif defined __BUILTIN_VA_ARG_INCR
551 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
553 # define YYSTACK_ALLOC __alloca
554 # elif defined _MSC_VER
555 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
556 # define alloca _alloca
558 # define YYSTACK_ALLOC alloca
559 # if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
560 || defined __cplusplus || defined _MSC_VER)
561 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
570 # ifdef YYSTACK_ALLOC
571 /* Pacify GCC's `empty if-body' warning. */
572 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
573 # ifndef YYSTACK_ALLOC_MAXIMUM
574 /* The OS might guarantee only one guard page at the bottom of the stack,
575 and a page size can be as small as 4096 bytes. So we cannot safely
576 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
577 to allow for a few compiler-allocated temporary stack slots. */
578 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
581 # define YYSTACK_ALLOC YYMALLOC
582 # define YYSTACK_FREE YYFREE
583 # ifndef YYSTACK_ALLOC_MAXIMUM
584 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
586 # if (defined __cplusplus && ! defined _STDLIB_H \
587 && ! ((defined YYMALLOC || defined malloc) \
588 && (defined YYFREE || defined free)))
589 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
595 # define YYMALLOC malloc
596 # if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
597 || defined __cplusplus || defined _MSC_VER)
598 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
603 # if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
604 || defined __cplusplus || defined _MSC_VER)
605 void free (void *); /* INFRINGES ON USER NAME SPACE */
609 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
612 #if (! defined yyoverflow \
613 && (! defined __cplusplus \
614 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
616 /* A type that is properly aligned for any stack member. */
623 /* The size of the maximum gap between one aligned stack and the next. */
624 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
626 /* The size of an array large to enough to hold all stacks, each with
628 # define YYSTACK_BYTES(N) \
629 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
630 + YYSTACK_GAP_MAXIMUM)
632 /* Copy COUNT objects from FROM to TO. The source and destination do
635 # if defined __GNUC__ && 1 < __GNUC__
636 # define YYCOPY(To, From, Count) \
637 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
639 # define YYCOPY(To, From, Count) \
643 for (yyi = 0; yyi < (Count); yyi++) \
644 (To)[yyi] = (From)[yyi]; \
650 /* Relocate STACK from its old location to the new one. The
651 local variables YYSIZE and YYSTACKSIZE give the old and new number of
652 elements in the stack, and YYPTR gives the new location of the
653 stack. Advance YYPTR to a properly aligned location for the next
655 # define YYSTACK_RELOCATE(Stack) \
658 YYSIZE_T yynewbytes; \
659 YYCOPY (&yyptr->Stack, Stack, yysize); \
660 Stack = &yyptr->Stack; \
661 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
662 yyptr += yynewbytes / sizeof (*yyptr); \
668 /* YYFINAL -- State number of the termination state. */
670 /* YYLAST -- Last index in YYTABLE. */
673 /* YYNTOKENS -- Number of terminals. */
674 #define YYNTOKENS 121
675 /* YYNNTS -- Number of nonterminals. */
677 /* YYNRULES -- Number of rules. */
679 /* YYNRULES -- Number of states. */
680 #define YYNSTATES 594
682 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
684 #define YYMAXUTOK 369
686 #define YYTRANSLATE(YYX) \
687 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
689 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
690 static const yytype_uint8 yytranslate[] =
692 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
693 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
694 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
695 2, 2, 2, 2, 2, 115, 2, 2, 2, 2,
696 2, 2, 2, 120, 116, 119, 2, 2, 2, 2,
697 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
698 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
699 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
700 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
701 2, 117, 2, 118, 2, 2, 2, 2, 2, 2,
702 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
703 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
704 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
705 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
706 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
707 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
708 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
709 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
710 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
711 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
712 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
713 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
714 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
715 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
716 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
717 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
718 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
719 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
720 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
721 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
722 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
723 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
724 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
725 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
726 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
727 95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
728 105, 106, 107, 108, 109, 110, 111, 112, 113, 114
732 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
734 static const yytype_uint16 yyprhs[] =
736 0, 0, 3, 5, 7, 9, 11, 13, 16, 20,
737 24, 27, 31, 35, 39, 43, 47, 51, 55, 58,
738 68, 78, 88, 96, 101, 110, 119, 125, 133, 142,
739 148, 154, 160, 166, 172, 178, 185, 191, 195, 196,
740 200, 201, 205, 206, 210, 215, 220, 228, 232, 238,
741 244, 250, 253, 256, 259, 263, 266, 269, 272, 275,
742 278, 281, 284, 288, 292, 294, 296, 298, 300, 303,
743 306, 309, 312, 314, 316, 318, 320, 324, 333, 342,
744 350, 361, 373, 379, 387, 397, 407, 417, 424, 425,
745 429, 430, 434, 435, 439, 440, 444, 445, 449, 450,
746 454, 455, 459, 460, 464, 465, 469, 470, 474, 475,
747 479, 480, 484, 485, 489, 490, 494, 495, 499, 500,
748 504, 505, 509, 510, 514, 515, 519, 524, 529, 534,
749 539, 548, 557, 566, 575, 576, 580, 581, 585, 586,
750 590, 591, 595, 596, 600, 601, 605, 606, 610, 614,
751 621, 631, 641, 646, 651, 656, 661, 664, 667, 670,
752 673, 676, 680, 689, 698, 707, 716, 725, 734, 735,
753 739, 740, 744, 745, 749, 750, 754, 759, 764, 770,
754 776, 782, 788, 794, 804, 814, 824, 825, 829, 830,
755 834, 835, 839, 840, 844, 845, 849, 855, 859, 867,
756 875, 881, 885, 893, 901, 906, 908, 910, 912, 914,
757 918, 926, 934, 938, 943, 950, 952, 957, 959, 963,
758 971, 972, 974, 975, 978, 980, 982, 983, 985, 987,
759 988, 990, 992, 994, 995, 997, 999, 1000
762 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
763 static const yytype_int16 yyrhs[] =
765 122, 0, -1, 7, -1, 25, -1, 31, -1, 90,
766 -1, 68, -1, 24, 6, -1, 24, 13, 6, -1,
767 24, 9, 6, -1, 27, 6, -1, 27, 13, 6,
768 -1, 21, 9, 6, -1, 21, 10, 6, -1, 24,
769 10, 6, -1, 24, 11, 6, -1, 27, 11, 6,
770 -1, 21, 11, 6, -1, 21, 6, -1, 53, 10,
771 115, 6, 116, 171, 117, 3, 118, -1, 53, 11,
772 115, 6, 116, 171, 117, 3, 118, -1, 53, 12,
773 115, 6, 116, 171, 117, 3, 118, -1, 91, 115,
774 6, 116, 3, 119, 3, -1, 30, 3, 116, 3,
775 -1, 30, 171, 117, 3, 118, 14, 116, 3, -1,
776 30, 171, 117, 3, 118, 174, 116, 3, -1, 54,
777 176, 3, 116, 3, -1, 54, 176, 117, 3, 118,
778 116, 3, -1, 54, 176, 6, 117, 3, 118, 116,
779 3, -1, 108, 115, 6, 116, 3, -1, 30, 115,
780 6, 116, 3, -1, 18, 115, 6, 116, 3, -1,
781 55, 115, 6, 116, 3, -1, 19, 115, 6, 116,
782 3, -1, 70, 115, 6, 116, 3, -1, 53, 12,
783 115, 6, 116, 3, -1, 53, 115, 6, 116, 3,
784 -1, 91, 115, 6, -1, -1, 100, 123, 168, -1,
785 -1, 98, 124, 168, -1, -1, 99, 125, 168, -1,
786 77, 3, 119, 3, -1, 73, 3, 119, 3, -1,
787 18, 115, 6, 116, 3, 116, 3, -1, 45, 115,
788 6, -1, 26, 115, 6, 116, 3, -1, 20, 115,
789 6, 116, 3, -1, 28, 115, 6, 116, 3, -1,
790 92, 3, -1, 84, 3, -1, 83, 3, -1, 74,
791 175, 3, -1, 71, 3, -1, 76, 5, -1, 72,
792 5, -1, 97, 172, -1, 29, 172, -1, 47, 3,
793 -1, 48, 3, -1, 24, 177, 3, -1, 27, 177,
794 3, -1, 96, -1, 103, -1, 101, -1, 102, -1,
795 109, 175, -1, 110, 175, -1, 104, 175, -1, 82,
796 175, -1, 89, -1, 88, -1, 112, -1, 93, -1,
797 66, 115, 6, -1, 53, 175, 3, 116, 6, 117,
798 3, 118, -1, 53, 175, 6, 117, 3, 118, 116,
799 3, -1, 53, 175, 3, 116, 117, 3, 118, -1,
800 53, 175, 117, 3, 118, 116, 171, 117, 3, 118,
801 -1, 53, 175, 6, 117, 3, 118, 116, 171, 117,
802 3, 118, -1, 53, 175, 3, 116, 3, -1, 53,
803 175, 117, 3, 118, 116, 3, -1, 26, 115, 6,
804 116, 171, 117, 3, 118, 10, -1, 20, 115, 6,
805 116, 171, 117, 3, 118, 10, -1, 28, 115, 6,
806 116, 171, 117, 3, 118, 10, -1, 74, 175, 171,
807 117, 3, 118, -1, -1, 94, 126, 162, -1, -1,
808 67, 127, 165, -1, -1, 17, 128, 164, -1, -1,
809 16, 129, 165, -1, -1, 51, 130, 164, -1, -1,
810 52, 131, 164, -1, -1, 36, 132, 163, -1, -1,
811 37, 133, 163, -1, -1, 32, 134, 164, -1, -1,
812 33, 135, 164, -1, -1, 111, 136, 164, -1, -1,
813 114, 137, 164, -1, -1, 69, 138, 165, -1, -1,
814 107, 139, 163, -1, -1, 105, 140, 163, -1, -1,
815 36, 141, 166, -1, -1, 37, 142, 166, -1, -1,
816 113, 143, 166, -1, -1, 46, 144, 166, -1, 26,
817 3, 116, 3, -1, 20, 3, 116, 3, -1, 28,
818 3, 116, 3, -1, 23, 3, 116, 3, -1, 26,
819 3, 116, 171, 117, 3, 118, 10, -1, 20, 3,
820 116, 171, 117, 3, 118, 10, -1, 28, 3, 116,
821 171, 117, 3, 118, 10, -1, 23, 3, 116, 171,
822 117, 3, 118, 10, -1, -1, 43, 145, 169, -1,
823 -1, 39, 146, 169, -1, -1, 38, 147, 169, -1,
824 -1, 41, 148, 169, -1, -1, 40, 149, 169, -1,
825 -1, 44, 150, 170, -1, -1, 87, 151, 170, -1,
826 95, 12, 3, -1, 95, 175, 171, 117, 3, 118,
827 -1, 22, 115, 6, 116, 171, 117, 3, 118, 10,
828 -1, 23, 115, 6, 116, 171, 117, 3, 118, 10,
829 -1, 56, 3, 116, 3, -1, 57, 3, 116, 3,
830 -1, 49, 3, 116, 3, -1, 50, 3, 116, 3,
831 -1, 63, 3, -1, 64, 3, -1, 59, 3, -1,
832 60, 3, -1, 61, 3, -1, 78, 115, 6, -1,
833 53, 175, 3, 116, 117, 3, 120, 118, -1, 53,
834 175, 3, 116, 117, 119, 3, 118, -1, 53, 175,
835 117, 3, 120, 118, 116, 3, -1, 53, 175, 117,
836 119, 3, 118, 116, 3, -1, 54, 176, 117, 3,
837 120, 118, 116, 3, -1, 54, 176, 117, 119, 3,
838 118, 116, 3, -1, -1, 85, 152, 167, -1, -1,
839 86, 153, 167, -1, -1, 81, 154, 167, -1, -1,
840 80, 155, 167, -1, 65, 3, 116, 5, -1, 62,
841 5, 116, 3, -1, 85, 115, 6, 116, 3, -1,
842 86, 115, 6, 116, 3, -1, 65, 115, 6, 116,
843 5, -1, 22, 115, 6, 116, 3, -1, 23, 115,
844 6, 116, 3, -1, 53, 175, 3, 116, 117, 3,
845 116, 3, 118, -1, 53, 175, 117, 3, 116, 3,
846 118, 116, 3, -1, 54, 176, 117, 3, 116, 3,
847 118, 116, 3, -1, -1, 108, 156, 161, -1, -1,
848 18, 157, 161, -1, -1, 55, 158, 161, -1, -1,
849 19, 159, 161, -1, -1, 70, 160, 161, -1, 94,
850 115, 6, 116, 3, -1, 3, 116, 3, -1, 171,
851 117, 3, 118, 14, 116, 3, -1, 171, 117, 3,
852 118, 174, 116, 3, -1, 3, 116, 3, 116, 3,
853 -1, 3, 116, 3, -1, 171, 117, 3, 118, 14,
854 116, 3, -1, 171, 117, 3, 118, 174, 116, 3,
855 -1, 115, 6, 116, 3, -1, 162, -1, 163, -1,
856 162, -1, 3, -1, 3, 116, 3, -1, 171, 117,
857 3, 118, 14, 116, 3, -1, 171, 117, 3, 118,
858 174, 116, 3, -1, 3, 116, 3, -1, 115, 6,
859 116, 3, -1, 115, 6, 116, 3, 116, 3, -1,
860 167, -1, 115, 6, 116, 3, -1, 170, -1, 3,
861 116, 3, -1, 171, 117, 3, 118, 177, 116, 3,
862 -1, -1, 6, -1, -1, 173, 4, -1, 10, -1,
863 11, -1, -1, 12, -1, 15, -1, -1, 10, -1,
864 11, -1, 12, -1, -1, 10, -1, 11, -1, -1,
868 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
869 static const yytype_uint16 yyrline[] =
871 0, 170, 170, 175, 178, 181, 184, 189, 204, 207,
872 212, 221, 226, 234, 237, 242, 244, 246, 251, 269,
873 277, 283, 291, 300, 305, 308, 313, 318, 321, 329,
874 336, 344, 350, 356, 362, 368, 376, 386, 391, 391,
875 392, 392, 393, 393, 397, 410, 423, 428, 433, 435,
876 440, 445, 447, 449, 454, 459, 464, 472, 480, 482,
877 487, 489, 491, 493, 498, 500, 502, 504, 509, 511,
878 513, 518, 523, 525, 527, 529, 534, 540, 548, 562,
879 567, 572, 577, 582, 587, 589, 591, 596, 601, 601,
880 602, 602, 603, 603, 604, 604, 605, 605, 606, 606,
881 607, 607, 608, 608, 609, 609, 610, 610, 611, 611,
882 612, 612, 613, 613, 614, 614, 615, 615, 619, 619,
883 620, 620, 621, 621, 622, 622, 626, 628, 630, 632,
884 635, 637, 639, 641, 646, 646, 647, 647, 648, 648,
885 649, 649, 650, 650, 651, 651, 652, 652, 656, 658,
886 663, 669, 675, 677, 679, 681, 687, 689, 691, 693,
887 695, 698, 709, 711, 716, 718, 723, 725, 730, 730,
888 731, 731, 732, 732, 733, 733, 737, 743, 748, 750,
889 755, 760, 766, 771, 774, 777, 782, 782, 783, 783,
890 784, 784, 785, 785, 786, 786, 791, 801, 803, 805,
891 807, 814, 816, 818, 824, 829, 830, 834, 835, 841,
892 843, 845, 852, 856, 858, 860, 866, 868, 871, 873,
893 879, 880, 883, 883, 888, 889, 890, 891, 892, 895,
894 896, 897, 898, 901, 902, 903, 906, 907
898 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
899 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
900 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
901 static const char *const yytname[] =
903 "$end", "error", "$undefined", "REG", "FLAG", "CREG", "EXPR",
904 "UNKNOWN_OPCODE", "IS_OPCODE", "DOT_S", "DOT_B", "DOT_W", "DOT_L",
905 "DOT_A", "DOT_UB", "DOT_UW", "ABS", "ADC", "ADD", "AND_", "BCLR", "BCND",
906 "BMCND", "BNOT", "BRA", "BRK", "BSET", "BSR", "BTST", "CLRPSW", "CMP",
907 "DBT", "DIV", "DIVU", "EDIV", "EDIVU", "EMUL", "EMULU", "FADD", "FCMP",
908 "FDIV", "FMUL", "FREIT", "FSUB", "FTOI", "INT", "ITOF", "JMP", "JSR",
909 "MACHI", "MACLO", "MAX", "MIN", "MOV", "MOVU", "MUL", "MULHI", "MULLO",
910 "MULU", "MVFACHI", "MVFACMI", "MVFACLO", "MVFC", "MVTACHI", "MVTACLO",
911 "MVTC", "MVTIPL", "NEG", "NOP", "NOT", "OR", "POP", "POPC", "POPM",
912 "PUSH", "PUSHA", "PUSHC", "PUSHM", "RACW", "REIT", "REVL", "REVW",
913 "RMPA", "ROLC", "RORC", "ROTL", "ROTR", "ROUND", "RTE", "RTFI", "RTS",
914 "RTSD", "SAT", "SATR", "SBB", "SCCND", "SCMPU", "SETPSW", "SHAR", "SHLL",
915 "SHLR", "SMOVB", "SMOVF", "SMOVU", "SSTR", "STNZ", "STOP", "STZ", "SUB",
916 "SUNTIL", "SWHILE", "TST", "WAIT", "XCHG", "XOR", "'#'", "','", "'['",
917 "']'", "'-'", "'+'", "$accept", "statement", "@1", "@2", "@3", "@4",
918 "@5", "@6", "@7", "@8", "@9", "@10", "@11", "@12", "@13", "@14", "@15",
919 "@16", "@17", "@18", "@19", "@20", "@21", "@22", "@23", "@24", "@25",
920 "@26", "@27", "@28", "@29", "@30", "@31", "@32", "@33", "@34", "@35",
921 "@36", "@37", "@38", "op_subadd", "op_dp20_rm", "op_dp20_i",
922 "op_dp20_rim", "op_dp20_rms", "op_xchg", "op_shift_rot", "op_shift",
923 "float2_op", "float2_op_ni", "disp", "flag", "@39", "memex", "bwl", "bw",
929 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
931 static const yytype_uint16 yytoknum[] =
933 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
934 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
935 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
936 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
937 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
938 305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
939 315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
940 325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
941 335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
942 345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
943 355, 356, 357, 358, 359, 360, 361, 362, 363, 364,
944 365, 366, 367, 368, 369, 35, 44, 91, 93, 45,
949 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
950 static const yytype_uint8 yyr1[] =
952 0, 121, 122, 122, 122, 122, 122, 122, 122, 122,
953 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
954 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
955 122, 122, 122, 122, 122, 122, 122, 122, 123, 122,
956 124, 122, 125, 122, 122, 122, 122, 122, 122, 122,
957 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
958 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
959 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
960 122, 122, 122, 122, 122, 122, 122, 122, 126, 122,
961 127, 122, 128, 122, 129, 122, 130, 122, 131, 122,
962 132, 122, 133, 122, 134, 122, 135, 122, 136, 122,
963 137, 122, 138, 122, 139, 122, 140, 122, 141, 122,
964 142, 122, 143, 122, 144, 122, 122, 122, 122, 122,
965 122, 122, 122, 122, 145, 122, 146, 122, 147, 122,
966 148, 122, 149, 122, 150, 122, 151, 122, 122, 122,
967 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
968 122, 122, 122, 122, 122, 122, 122, 122, 152, 122,
969 153, 122, 154, 122, 155, 122, 122, 122, 122, 122,
970 122, 122, 122, 122, 122, 122, 156, 122, 157, 122,
971 158, 122, 159, 122, 160, 122, 122, 161, 161, 161,
972 161, 162, 162, 162, 163, 164, 164, 165, 165, 166,
973 166, 166, 167, 168, 168, 168, 169, 169, 170, 170,
974 171, 171, 173, 172, 174, 174, 174, 174, 174, 175,
975 175, 175, 175, 176, 176, 176, 177, 177
978 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
979 static const yytype_uint8 yyr2[] =
981 0, 2, 1, 1, 1, 1, 1, 2, 3, 3,
982 2, 3, 3, 3, 3, 3, 3, 3, 2, 9,
983 9, 9, 7, 4, 8, 8, 5, 7, 8, 5,
984 5, 5, 5, 5, 5, 6, 5, 3, 0, 3,
985 0, 3, 0, 3, 4, 4, 7, 3, 5, 5,
986 5, 2, 2, 2, 3, 2, 2, 2, 2, 2,
987 2, 2, 3, 3, 1, 1, 1, 1, 2, 2,
988 2, 2, 1, 1, 1, 1, 3, 8, 8, 7,
989 10, 11, 5, 7, 9, 9, 9, 6, 0, 3,
990 0, 3, 0, 3, 0, 3, 0, 3, 0, 3,
991 0, 3, 0, 3, 0, 3, 0, 3, 0, 3,
992 0, 3, 0, 3, 0, 3, 0, 3, 0, 3,
993 0, 3, 0, 3, 0, 3, 4, 4, 4, 4,
994 8, 8, 8, 8, 0, 3, 0, 3, 0, 3,
995 0, 3, 0, 3, 0, 3, 0, 3, 3, 6,
996 9, 9, 4, 4, 4, 4, 2, 2, 2, 2,
997 2, 3, 8, 8, 8, 8, 8, 8, 0, 3,
998 0, 3, 0, 3, 0, 3, 4, 4, 5, 5,
999 5, 5, 5, 9, 9, 9, 0, 3, 0, 3,
1000 0, 3, 0, 3, 0, 3, 5, 3, 7, 7,
1001 5, 3, 7, 7, 4, 1, 1, 1, 1, 3,
1002 7, 7, 3, 4, 6, 1, 4, 1, 3, 7,
1003 0, 1, 0, 2, 1, 1, 0, 1, 1, 0,
1004 1, 1, 1, 0, 1, 1, 0, 1
1007 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
1008 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
1009 means the default is an error. */
1010 static const yytype_uint8 yydefact[] =
1012 0, 2, 94, 92, 188, 192, 0, 0, 0, 0,
1013 236, 3, 0, 236, 0, 222, 220, 4, 104, 106,
1014 118, 120, 138, 136, 142, 140, 134, 144, 0, 124,
1015 0, 0, 0, 0, 96, 98, 229, 233, 190, 0,
1016 0, 0, 0, 0, 0, 0, 0, 0, 0, 90,
1017 6, 112, 194, 0, 0, 0, 229, 0, 0, 0,
1018 174, 172, 229, 0, 0, 168, 170, 146, 73, 72,
1019 5, 0, 0, 75, 88, 229, 64, 222, 40, 42,
1020 38, 66, 67, 65, 229, 116, 114, 186, 229, 229,
1021 108, 74, 122, 110, 0, 220, 220, 0, 220, 0,
1022 220, 0, 0, 18, 0, 0, 0, 0, 0, 0,
1023 7, 0, 0, 0, 237, 0, 0, 0, 0, 10,
1024 0, 0, 0, 0, 0, 59, 0, 0, 221, 0,
1025 0, 220, 220, 0, 220, 0, 220, 220, 220, 220,
1026 220, 220, 220, 0, 220, 60, 61, 0, 0, 220,
1027 220, 230, 231, 232, 0, 0, 234, 235, 0, 0,
1028 220, 0, 0, 158, 159, 160, 0, 156, 157, 0,
1029 0, 0, 220, 220, 0, 220, 55, 57, 0, 230,
1030 231, 232, 220, 56, 0, 0, 0, 0, 71, 53,
1031 52, 0, 0, 0, 0, 220, 0, 51, 0, 220,
1032 232, 220, 58, 0, 0, 0, 70, 0, 0, 0,
1033 220, 68, 69, 220, 220, 220, 1, 208, 207, 95,
1034 0, 0, 0, 205, 206, 93, 0, 0, 189, 0,
1035 0, 193, 220, 0, 12, 13, 17, 0, 220, 0,
1036 9, 14, 15, 8, 62, 220, 0, 16, 11, 63,
1037 220, 0, 223, 0, 0, 0, 105, 107, 101, 0,
1038 119, 0, 103, 121, 0, 0, 139, 217, 0, 137,
1039 143, 141, 135, 145, 47, 125, 0, 0, 97, 99,
1040 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1041 0, 191, 0, 0, 0, 0, 0, 76, 91, 113,
1042 0, 195, 0, 54, 0, 0, 161, 0, 175, 173,
1043 0, 169, 0, 171, 147, 37, 0, 89, 148, 0,
1044 0, 215, 41, 43, 39, 117, 115, 0, 187, 109,
1045 123, 111, 0, 0, 0, 0, 0, 0, 0, 127,
1046 0, 220, 220, 129, 0, 220, 126, 0, 220, 128,
1047 0, 220, 23, 0, 0, 0, 0, 0, 0, 0,
1048 154, 155, 0, 0, 0, 0, 0, 0, 0, 0,
1049 0, 0, 0, 0, 0, 152, 153, 177, 176, 0,
1050 0, 45, 0, 44, 0, 0, 0, 0, 0, 0,
1051 0, 0, 201, 0, 0, 31, 197, 0, 33, 0,
1052 49, 0, 181, 0, 0, 182, 0, 0, 48, 0,
1053 0, 50, 0, 30, 226, 209, 0, 218, 0, 0,
1054 220, 220, 220, 36, 82, 0, 0, 0, 0, 0,
1055 0, 0, 26, 0, 0, 0, 0, 0, 32, 180,
1056 34, 0, 212, 178, 179, 0, 196, 0, 0, 29,
1057 226, 204, 0, 0, 226, 0, 0, 0, 0, 0,
1058 0, 0, 0, 0, 224, 225, 227, 0, 228, 0,
1059 226, 216, 236, 0, 0, 35, 0, 0, 0, 0,
1060 0, 0, 220, 0, 0, 0, 0, 0, 0, 0,
1061 87, 0, 149, 213, 0, 0, 46, 200, 0, 0,
1062 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1063 0, 0, 0, 0, 0, 0, 0, 0, 0, 79,
1064 0, 0, 220, 0, 83, 0, 0, 0, 0, 0,
1065 27, 0, 0, 22, 0, 0, 0, 0, 0, 131,
1066 0, 0, 133, 0, 130, 0, 132, 0, 24, 25,
1067 0, 0, 0, 0, 0, 0, 77, 0, 162, 163,
1068 78, 0, 0, 0, 164, 165, 28, 0, 166, 167,
1069 214, 202, 203, 198, 199, 85, 150, 151, 84, 86,
1070 210, 211, 219, 19, 20, 21, 183, 0, 184, 0,
1074 /* YYDEFGOTO[NTERM-NUM]. */
1075 static const yytype_int16 yydefgoto[] =
1077 -1, 94, 205, 203, 204, 199, 172, 96, 95, 149,
1078 150, 133, 135, 131, 132, 213, 215, 173, 208, 207,
1079 134, 136, 214, 144, 141, 138, 137, 140, 139, 142,
1080 195, 192, 194, 187, 186, 210, 98, 160, 100, 175,
1081 228, 223, 224, 225, 219, 260, 321, 322, 266, 267,
1082 220, 125, 126, 469, 155, 158, 116
1085 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1087 #define YYPACT_NINF -415
1088 static const yytype_int16 yypact[] =
1090 464, -415, -415, -415, -67, -62, 24, 94, -54, 25,
1091 83, -415, 26, 39, 27, -415, 18, -415, -415, -415,
1092 -32, -30, -415, -415, -415, -415, -415, -415, -6, -415,
1093 112, 114, 129, 134, -415, -415, -4, 4, 34, 150,
1094 154, 173, 179, 192, 203, 200, 206, 28, 95, -415,
1095 -415, -415, 96, 209, 208, 211, 57, 210, 214, 103,
1096 -415, -415, 57, 216, 217, 106, 108, -415, -415, -415,
1097 -415, 109, 222, -415, 111, 195, -415, -415, -415, -415,
1098 -415, -415, -415, -415, 57, -415, -415, 113, 57, 57,
1099 -415, -415, -415, -415, 227, 40, 19, 224, 152, 225,
1100 152, 116, 229, -415, 230, 231, 232, 233, 117, 234,
1101 -415, 235, 236, 237, -415, 238, 242, 130, 241, -415,
1102 243, 244, 245, 135, 246, -415, 249, 138, -415, 250,
1103 140, 19, 19, 143, 161, 143, 161, 20, 20, 20,
1104 20, 20, 162, 253, 161, -415, -415, 139, 144, 19,
1105 19, 146, 147, 148, 258, -1, -415, -415, 13, 259,
1106 152, 151, 153, -415, -415, -415, 155, -415, -415, 156,
1107 260, 262, 40, 40, 264, 152, -415, -415, 157, -415,
1108 -415, -415, 166, -415, 158, 267, 271, 271, -415, -415,
1109 -415, 269, 271, 272, 271, 162, 273, -415, 274, 167,
1110 278, 276, -415, 30, 30, 30, -415, 143, 143, 277,
1111 152, -415, -415, 19, 161, 19, -415, 169, -415, -415,
1112 170, 169, 280, -415, -415, -415, 175, 176, -415, 171,
1113 177, -415, 168, 181, -415, -415, -415, 182, 172, 183,
1114 -415, -415, -415, -415, -415, 174, 187, -415, -415, -415,
1115 178, 188, -415, 281, 189, 286, -415, -415, -415, 191,
1116 -415, 193, -415, -415, 197, 284, -415, -415, 199, -415,
1117 -415, -415, -415, -415, -415, -415, 291, 292, -415, -415,
1118 290, 294, 295, 201, 202, 204, 0, 207, 205, 8,
1119 212, -415, 299, 303, 305, 304, 215, -415, -415, -415,
1120 218, -415, 308, -415, 213, 309, -415, 220, -415, -415,
1121 221, -415, 223, -415, -415, 226, 228, -415, -415, 239,
1122 313, -415, -415, -415, -415, -415, -415, 247, -415, -415,
1123 -415, -415, 311, 312, 248, 317, 321, 324, 330, -415,
1124 240, 180, 184, -415, 251, 185, -415, 252, 186, -415,
1125 254, 190, -415, 335, 255, 337, 338, 340, 256, 342,
1126 -415, -415, 261, 263, 265, 343, 14, 344, -81, 345,
1127 346, 347, -8, 348, 349, -415, -415, -415, -415, 350,
1128 351, -415, 355, -415, 356, 357, 358, 359, 362, 363,
1129 266, 364, -415, 257, 367, 268, 270, 275, -415, 371,
1130 -415, 279, -415, 282, 373, -415, 283, 375, -415, 285,
1131 377, -415, 293, -415, 48, -415, 289, -415, 380, 296,
1132 276, 276, 194, -415, -415, 298, 10, 300, 382, 287,
1133 301, 302, -415, 306, 384, 297, 307, 310, -415, -415,
1134 -415, 314, -415, -415, -415, 315, -415, 318, 385, -415,
1135 66, -415, 386, 387, 87, 319, 388, 389, 320, 391,
1136 322, 392, 323, 394, -415, -415, -415, 326, -415, 327,
1137 136, -415, 341, 316, 328, -415, 329, 395, 36, 398,
1138 331, 332, 196, 333, 336, 339, 352, 405, 353, 360,
1139 -415, 406, -415, 361, 383, 423, -415, -415, 427, 454,
1140 401, 354, 404, 402, 461, 407, 462, 411, 463, 413,
1141 419, 466, 467, 468, 420, 424, 426, 469, 428, -415,
1142 470, 471, 198, 474, -415, 334, 432, 436, 441, 475,
1143 -415, 445, 450, -415, 451, 453, 455, 456, 458, -415,
1144 416, 447, -415, 452, -415, 457, -415, 465, -415, -415,
1145 460, 476, 495, 477, 478, 479, -415, 480, -415, -415,
1146 -415, 482, 582, 583, -415, -415, -415, 589, -415, -415,
1147 -415, -415, -415, -415, -415, -415, -415, -415, -415, -415,
1148 -415, -415, -415, -415, -415, -415, -415, 590, -415, 483,
1149 -415, 484, -415, -415
1152 /* YYPGOTO[NTERM-NUM]. */
1153 static const yytype_int16 yypgoto[] =
1155 -415, -415, -415, -415, -415, -415, -415, -415, -415, -415,
1156 -415, -415, -415, -415, -415, -415, -415, -415, -415, -415,
1157 -415, -415, -415, -415, -415, -415, -415, -415, -415, -415,
1158 -415, -415, -415, -415, -415, -415, -415, -415, -415, -415,
1159 -96, -86, -101, -77, -98, -126, -145, -114, 22, -130,
1160 -16, 396, -415, -414, -18, -415, -12
1163 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
1164 positive, shift that token. If negative, reduce the rule which
1165 number is the opposite. If zero, do what YYDEFACT says.
1166 If YYTABLE_NINF, syntax error. */
1167 #define YYTABLE_NINF -103
1168 static const yytype_int16 yytable[] =
1170 130, 122, 284, 368, 231, 285, 151, 152, 153, 218,
1171 263, 372, 273, 478, 156, 157, 287, 424, 275, 288,
1172 425, 127, 221, 264, 128, 128, 128, 101, 108, 117,
1173 123, 169, 258, 307, 262, 428, 495, 429, 182, 430,
1174 499, 308, 309, 217, 188, 119, 128, 311, 97, 313,
1175 120, 114, 121, 99, 256, 257, 512, 201, 464, 465,
1176 466, 107, 467, 468, 291, 314, 206, 179, 180, 181,
1177 211, 212, 278, 279, 298, 299, 464, 465, 466, 301,
1178 494, 468, 229, -100, 229, -102, 218, 218, 330, 110,
1179 323, 324, 111, 112, 113, 114, 115, 464, 465, 466,
1180 103, 498, 468, 104, 105, 106, 325, 326, 434, 143,
1181 435, 154, 436, 317, 328, 145, 286, 146, 261, 369,
1182 261, 268, 268, 268, 268, 268, 268, 373, 261, 479,
1183 289, 426, 147, 129, 222, 265, 329, 148, 331, 102,
1184 109, 118, 124, 170, 229, 320, 464, 465, 466, 159,
1185 511, 468, 518, 161, 519, 227, 520, 162, 128, 229,
1186 269, 270, 271, 272, 259, 264, 304, 128, 128, 303,
1187 221, 339, 128, 128, 128, 343, 163, 346, 128, 268,
1188 128, 349, 164, 400, 128, 319, 128, 402, 405, 408,
1189 128, 128, 128, 411, 229, 165, 128, 475, 261, 524,
1190 128, 560, 128, 167, 128, 179, 180, 200, 166, 168,
1191 171, 174, 176, 177, 178, 183, 340, 184, 185, 189,
1192 190, 191, 344, 193, 196, 197, 198, 216, 209, 347,
1193 226, 230, 232, 238, 350, 233, 234, 235, 236, 237,
1194 239, 240, 241, 242, 243, 244, 245, 246, 249, 247,
1195 248, 250, 251, 252, 253, 276, 254, 255, 222, 274,
1196 277, 280, 281, 282, 283, 290, 296, 292, 297, 293,
1197 300, 294, 295, 306, 307, 310, 302, 305, 312, 315,
1198 316, 318, 128, 327, 352, 332, 334, 333, 337, 354,
1199 358, 335, 336, 338, 360, 361, 362, 341, 342, 345,
1200 363, 364, 375, 348, 351, 353, 376, 355, 377, 378,
1201 356, 381, 383, 357, 392, 393, 359, 365, 366, 390,
1202 395, 367, 371, 370, 396, 401, 403, 397, 374, 406,
1203 382, 379, 409, 398, 380, 412, 384, 385, 413, 386,
1204 415, 416, 387, 417, 388, 419, 423, 427, 431, 432,
1205 433, 437, 438, 114, 440, 439, 389, 399, 441, 442,
1206 443, 444, 445, 391, 394, 446, 447, 449, 404, 407,
1207 451, 410, 418, 414, 455, 450, 458, 420, 460, 421,
1208 462, 422, 448, 471, 452, 481, 453, 486, 493, 496,
1209 497, 501, 502, 454, 504, 506, 456, 508, 517, 457,
1210 459, 521, 461, 482, 473, 474, 476, 470, 530, 533,
1211 463, 539, 542, 487, 472, 477, 548, 544, 480, 483,
1212 484, 546, 549, 553, 485, 488, 575, 554, 489, 555,
1213 0, 557, 490, 514, 491, 564, 492, 500, 503, 565,
1214 505, 507, 509, 510, 566, 515, 516, 522, 568, 526,
1215 523, 563, 527, 569, 570, 528, 571, 576, 572, 573,
1216 513, 574, 577, 580, 0, 0, 525, 578, 0, 531,
1217 529, 1, 540, 202, 0, 579, 532, 534, 0, 581,
1218 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
1219 12, 13, 14, 15, 16, 17, 18, 19, 582, 535,
1220 20, 21, 22, 23, 24, 25, 561, 26, 27, 28,
1221 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
1222 39, 40, 541, 41, 42, 43, 44, 45, 46, 47,
1223 48, 49, 50, 51, 52, 53, 54, 55, 56, 536,
1224 57, 58, 59, 537, 60, 61, 62, 63, 64, 65,
1225 66, 67, 68, 69, 70, 71, 72, 73, 74, 75,
1226 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
1227 538, 86, 87, 88, 89, 90, 91, 92, 93, 543,
1228 545, 547, 550, 551, 552, 588, 589, 556, 558, 559,
1229 562, 567, 590, 591, 0, 583, 584, 585, 586, 587,
1233 static const yytype_int16 yycheck[] =
1235 16, 13, 3, 3, 100, 6, 10, 11, 12, 95,
1236 136, 3, 142, 3, 10, 11, 3, 3, 144, 6,
1237 6, 3, 3, 3, 6, 6, 6, 3, 3, 3,
1238 3, 3, 133, 3, 135, 116, 450, 118, 56, 120,
1239 454, 186, 187, 3, 62, 6, 6, 192, 115, 194,
1240 11, 12, 13, 115, 131, 132, 470, 75, 10, 11,
1241 12, 115, 14, 15, 160, 195, 84, 10, 11, 12,
1242 88, 89, 149, 150, 172, 173, 10, 11, 12, 175,
1243 14, 15, 98, 115, 100, 115, 172, 173, 214, 6,
1244 204, 205, 9, 10, 11, 12, 13, 10, 11, 12,
1245 6, 14, 15, 9, 10, 11, 207, 208, 116, 115,
1246 118, 115, 120, 199, 210, 3, 117, 3, 134, 119,
1247 136, 137, 138, 139, 140, 141, 142, 119, 144, 119,
1248 117, 117, 3, 115, 115, 115, 213, 3, 215, 115,
1249 115, 115, 115, 115, 160, 115, 10, 11, 12, 115,
1250 14, 15, 116, 3, 118, 3, 120, 3, 6, 175,
1251 138, 139, 140, 141, 3, 3, 182, 6, 6, 3,
1252 3, 3, 6, 6, 6, 3, 3, 3, 6, 195,
1253 6, 3, 3, 3, 6, 201, 6, 3, 3, 3,
1254 6, 6, 6, 3, 210, 3, 6, 3, 214, 3,
1255 6, 3, 6, 3, 6, 10, 11, 12, 5, 3,
1256 115, 115, 3, 5, 3, 5, 232, 3, 115, 3,
1257 3, 115, 238, 115, 115, 3, 115, 0, 115, 245,
1258 6, 6, 116, 116, 250, 6, 6, 6, 6, 6,
1259 6, 6, 6, 6, 6, 3, 116, 6, 3, 6,
1260 6, 116, 6, 4, 116, 116, 6, 117, 115, 6,
1261 116, 115, 115, 115, 6, 6, 6, 116, 6, 116,
1262 6, 116, 116, 6, 3, 6, 119, 119, 6, 6,
1263 6, 3, 6, 6, 3, 116, 6, 117, 117, 3,
1264 6, 116, 116, 116, 3, 3, 6, 116, 116, 116,
1265 6, 6, 3, 116, 116, 116, 3, 116, 3, 5,
1266 117, 3, 3, 116, 3, 3, 117, 116, 116, 6,
1267 3, 117, 117, 116, 3, 341, 342, 3, 116, 345,
1268 117, 116, 348, 3, 116, 351, 116, 116, 3, 116,
1269 3, 3, 116, 3, 116, 3, 3, 3, 3, 3,
1270 3, 3, 3, 12, 3, 5, 117, 117, 3, 3,
1271 3, 3, 3, 116, 116, 3, 3, 3, 117, 117,
1272 3, 117, 116, 118, 3, 118, 3, 116, 3, 116,
1273 3, 116, 116, 3, 116, 3, 116, 3, 3, 3,
1274 3, 3, 3, 118, 3, 3, 117, 3, 3, 117,
1275 117, 3, 117, 116, 420, 421, 422, 118, 3, 3,
1276 117, 10, 10, 116, 118, 117, 3, 10, 118, 118,
1277 118, 10, 3, 3, 118, 118, 10, 3, 118, 3,
1278 -1, 3, 118, 117, 119, 3, 118, 118, 118, 3,
1279 118, 118, 116, 116, 3, 117, 117, 116, 3, 116,
1280 118, 117, 116, 3, 3, 116, 3, 10, 3, 3,
1281 472, 3, 10, 3, -1, -1, 482, 10, -1, 116,
1282 118, 7, 118, 77, -1, 10, 116, 116, -1, 3,
1283 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
1284 26, 27, 28, 29, 30, 31, 32, 33, 3, 116,
1285 36, 37, 38, 39, 40, 41, 522, 43, 44, 45,
1286 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
1287 56, 57, 118, 59, 60, 61, 62, 63, 64, 65,
1288 66, 67, 68, 69, 70, 71, 72, 73, 74, 116,
1289 76, 77, 78, 116, 80, 81, 82, 83, 84, 85,
1290 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
1291 96, 97, 98, 99, 100, 101, 102, 103, 104, 105,
1292 116, 107, 108, 109, 110, 111, 112, 113, 114, 118,
1293 118, 118, 116, 116, 116, 3, 3, 118, 118, 118,
1294 116, 116, 3, 3, -1, 118, 118, 118, 118, 117,
1298 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1299 symbol of state STATE-NUM. */
1300 static const yytype_uint8 yystos[] =
1302 0, 7, 16, 17, 18, 19, 20, 21, 22, 23,
1303 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
1304 36, 37, 38, 39, 40, 41, 43, 44, 45, 46,
1305 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
1306 57, 59, 60, 61, 62, 63, 64, 65, 66, 67,
1307 68, 69, 70, 71, 72, 73, 74, 76, 77, 78,
1308 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
1309 90, 91, 92, 93, 94, 95, 96, 97, 98, 99,
1310 100, 101, 102, 103, 104, 105, 107, 108, 109, 110,
1311 111, 112, 113, 114, 122, 129, 128, 115, 157, 115,
1312 159, 3, 115, 6, 9, 10, 11, 115, 3, 115,
1313 6, 9, 10, 11, 12, 13, 177, 3, 115, 6,
1314 11, 13, 177, 3, 115, 172, 173, 3, 6, 115,
1315 171, 134, 135, 132, 141, 133, 142, 147, 146, 149,
1316 148, 145, 150, 115, 144, 3, 3, 3, 3, 130,
1317 131, 10, 11, 12, 115, 175, 10, 11, 176, 115,
1318 158, 3, 3, 3, 3, 3, 5, 3, 3, 3,
1319 115, 115, 127, 138, 115, 160, 3, 5, 3, 10,
1320 11, 12, 175, 5, 3, 115, 155, 154, 175, 3,
1321 3, 115, 152, 115, 153, 151, 115, 3, 115, 126,
1322 12, 175, 172, 124, 125, 123, 175, 140, 139, 115,
1323 156, 175, 175, 136, 143, 137, 0, 3, 162, 165,
1324 171, 3, 115, 162, 163, 164, 6, 3, 161, 171,
1325 6, 161, 116, 6, 6, 6, 6, 6, 116, 6,
1326 6, 6, 6, 6, 3, 116, 6, 6, 6, 3,
1327 116, 6, 4, 116, 6, 117, 164, 164, 163, 3,
1328 166, 171, 163, 166, 3, 115, 169, 170, 171, 169,
1329 169, 169, 169, 170, 6, 166, 116, 116, 164, 164,
1330 115, 115, 115, 6, 3, 6, 117, 3, 6, 117,
1331 6, 161, 116, 116, 116, 116, 6, 6, 165, 165,
1332 6, 161, 119, 3, 171, 119, 6, 3, 167, 167,
1333 6, 167, 6, 167, 170, 6, 6, 162, 3, 171,
1334 115, 167, 168, 168, 168, 163, 163, 6, 161, 164,
1335 166, 164, 116, 117, 6, 116, 116, 117, 116, 3,
1336 171, 116, 116, 3, 171, 116, 3, 171, 116, 3,
1337 171, 116, 3, 116, 3, 116, 117, 116, 6, 117,
1338 3, 3, 6, 6, 6, 116, 116, 117, 3, 119,
1339 116, 117, 3, 119, 116, 3, 3, 3, 5, 116,
1340 116, 3, 117, 3, 116, 116, 116, 116, 116, 117,
1341 6, 116, 3, 3, 116, 3, 3, 3, 3, 117,
1342 3, 171, 3, 171, 117, 3, 171, 117, 3, 171,
1343 117, 3, 171, 3, 118, 3, 3, 3, 116, 3,
1344 116, 116, 116, 3, 3, 6, 117, 3, 116, 118,
1345 120, 3, 3, 3, 116, 118, 120, 3, 3, 5,
1346 3, 3, 3, 3, 3, 3, 3, 3, 116, 3,
1347 118, 3, 116, 116, 118, 3, 117, 117, 3, 117,
1348 3, 117, 3, 117, 10, 11, 12, 14, 15, 174,
1349 118, 3, 118, 171, 171, 3, 171, 117, 3, 119,
1350 118, 3, 116, 118, 118, 118, 3, 116, 118, 118,
1351 118, 119, 118, 3, 14, 174, 3, 3, 14, 174,
1352 118, 3, 3, 118, 3, 118, 3, 118, 3, 116,
1353 116, 14, 174, 177, 117, 117, 117, 3, 116, 118,
1354 120, 3, 116, 118, 3, 171, 116, 116, 116, 118,
1355 3, 116, 116, 3, 116, 116, 116, 116, 116, 10,
1356 118, 118, 10, 118, 10, 118, 10, 118, 3, 3,
1357 116, 116, 116, 3, 3, 3, 118, 3, 118, 118,
1358 3, 171, 116, 117, 3, 3, 3, 116, 3, 3,
1359 3, 3, 3, 3, 3, 10, 10, 10, 10, 10,
1360 3, 3, 3, 118, 118, 118, 118, 117, 3, 3,
1364 #define yyerrok (yyerrstatus = 0)
1365 #define yyclearin (yychar = YYEMPTY)
1366 #define YYEMPTY (-2)
1369 #define YYACCEPT goto yyacceptlab
1370 #define YYABORT goto yyabortlab
1371 #define YYERROR goto yyerrorlab
1374 /* Like YYERROR except do call yyerror. This remains here temporarily
1375 to ease the transition to the new meaning of YYERROR, for GCC.
1376 Once GCC version 2 has supplanted version 1, this can go. */
1378 #define YYFAIL goto yyerrlab
1380 #define YYRECOVERING() (!!yyerrstatus)
1382 #define YYBACKUP(Token, Value) \
1384 if (yychar == YYEMPTY && yylen == 1) \
1388 yytoken = YYTRANSLATE (yychar); \
1394 yyerror (YY_("syntax error: cannot back up")); \
1401 #define YYERRCODE 256
1404 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
1405 If N is 0, then set CURRENT to the empty location which ends
1406 the previous symbol: RHS[0] (always defined). */
1408 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
1409 #ifndef YYLLOC_DEFAULT
1410 # define YYLLOC_DEFAULT(Current, Rhs, N) \
1414 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
1415 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
1416 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
1417 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
1421 (Current).first_line = (Current).last_line = \
1422 YYRHSLOC (Rhs, 0).last_line; \
1423 (Current).first_column = (Current).last_column = \
1424 YYRHSLOC (Rhs, 0).last_column; \
1430 /* YY_LOCATION_PRINT -- Print the location on the stream.
1431 This macro was not mandated originally: define only if we know
1432 we won't break user code: when these are the locations we know. */
1434 #ifndef YY_LOCATION_PRINT
1435 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
1436 # define YY_LOCATION_PRINT(File, Loc) \
1437 fprintf (File, "%d.%d-%d.%d", \
1438 (Loc).first_line, (Loc).first_column, \
1439 (Loc).last_line, (Loc).last_column)
1441 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1446 /* YYLEX -- calling `yylex' with the right arguments. */
1449 # define YYLEX yylex (YYLEX_PARAM)
1451 # define YYLEX yylex ()
1454 /* Enable debugging if requested. */
1458 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1459 # define YYFPRINTF fprintf
1462 # define YYDPRINTF(Args) \
1468 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
1472 YYFPRINTF (stderr, "%s ", Title); \
1473 yy_symbol_print (stderr, \
1475 YYFPRINTF (stderr, "\n"); \
1480 /*--------------------------------.
1481 | Print this symbol on YYOUTPUT. |
1482 `--------------------------------*/
1485 #if (defined __STDC__ || defined __C99__FUNC__ \
1486 || defined __cplusplus || defined _MSC_VER)
1488 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1491 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
1494 YYSTYPE const * const yyvaluep;
1500 if (yytype < YYNTOKENS)
1501 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1513 /*--------------------------------.
1514 | Print this symbol on YYOUTPUT. |
1515 `--------------------------------*/
1517 #if (defined __STDC__ || defined __C99__FUNC__ \
1518 || defined __cplusplus || defined _MSC_VER)
1520 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1523 yy_symbol_print (yyoutput, yytype, yyvaluep)
1526 YYSTYPE const * const yyvaluep;
1529 if (yytype < YYNTOKENS)
1530 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1532 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1534 yy_symbol_value_print (yyoutput, yytype, yyvaluep);
1535 YYFPRINTF (yyoutput, ")");
1538 /*------------------------------------------------------------------.
1539 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1541 `------------------------------------------------------------------*/
1543 #if (defined __STDC__ || defined __C99__FUNC__ \
1544 || defined __cplusplus || defined _MSC_VER)
1546 yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
1549 yy_stack_print (bottom, top)
1550 yytype_int16 *bottom;
1554 YYFPRINTF (stderr, "Stack now");
1555 for (; bottom <= top; ++bottom)
1556 YYFPRINTF (stderr, " %d", *bottom);
1557 YYFPRINTF (stderr, "\n");
1560 # define YY_STACK_PRINT(Bottom, Top) \
1563 yy_stack_print ((Bottom), (Top)); \
1567 /*------------------------------------------------.
1568 | Report that the YYRULE is going to be reduced. |
1569 `------------------------------------------------*/
1571 #if (defined __STDC__ || defined __C99__FUNC__ \
1572 || defined __cplusplus || defined _MSC_VER)
1574 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
1577 yy_reduce_print (yyvsp, yyrule)
1582 int yynrhs = yyr2[yyrule];
1584 unsigned long int yylno = yyrline[yyrule];
1585 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1587 /* The symbols being reduced. */
1588 for (yyi = 0; yyi < yynrhs; yyi++)
1590 fprintf (stderr, " $%d = ", yyi + 1);
1591 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1592 &(yyvsp[(yyi + 1) - (yynrhs)])
1594 fprintf (stderr, "\n");
1598 # define YY_REDUCE_PRINT(Rule) \
1601 yy_reduce_print (yyvsp, Rule); \
1604 /* Nonzero means print parse trace. It is left uninitialized so that
1605 multiple parsers can coexist. */
1607 #else /* !YYDEBUG */
1608 # define YYDPRINTF(Args)
1609 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1610 # define YY_STACK_PRINT(Bottom, Top)
1611 # define YY_REDUCE_PRINT(Rule)
1612 #endif /* !YYDEBUG */
1615 /* YYINITDEPTH -- initial size of the parser's stacks. */
1617 # define YYINITDEPTH 200
1620 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1621 if the built-in stack extension method is used).
1623 Do not make this value too large; the results are undefined if
1624 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1625 evaluated with infinite-precision integer arithmetic. */
1628 # define YYMAXDEPTH 10000
1636 # if defined __GLIBC__ && defined _STRING_H
1637 # define yystrlen strlen
1639 /* Return the length of YYSTR. */
1640 #if (defined __STDC__ || defined __C99__FUNC__ \
1641 || defined __cplusplus || defined _MSC_VER)
1643 yystrlen (const char *yystr)
1651 for (yylen = 0; yystr[yylen]; yylen++)
1659 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1660 # define yystpcpy stpcpy
1662 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1664 #if (defined __STDC__ || defined __C99__FUNC__ \
1665 || defined __cplusplus || defined _MSC_VER)
1667 yystpcpy (char *yydest, const char *yysrc)
1670 yystpcpy (yydest, yysrc)
1676 const char *yys = yysrc;
1678 while ((*yyd++ = *yys++) != '\0')
1687 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1688 quotes and backslashes, so that it's suitable for yyerror. The
1689 heuristic is that double-quoting is unnecessary unless the string
1690 contains an apostrophe, a comma, or backslash (other than
1691 backslash-backslash). YYSTR is taken from yytname. If YYRES is
1692 null, do not copy; instead, return the length of what the result
1695 yytnamerr (char *yyres, const char *yystr)
1700 char const *yyp = yystr;
1707 goto do_not_strip_quotes;
1711 goto do_not_strip_quotes;
1724 do_not_strip_quotes: ;
1728 return yystrlen (yystr);
1730 return yystpcpy (yyres, yystr) - yyres;
1734 /* Copy into YYRESULT an error message about the unexpected token
1735 YYCHAR while in state YYSTATE. Return the number of bytes copied,
1736 including the terminating null byte. If YYRESULT is null, do not
1737 copy anything; just return the number of bytes that would be
1738 copied. As a special case, return 0 if an ordinary "syntax error"
1739 message will do. Return YYSIZE_MAXIMUM if overflow occurs during
1740 size calculation. */
1742 yysyntax_error (char *yyresult, int yystate, int yychar)
1744 int yyn = yypact[yystate];
1746 if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
1750 int yytype = YYTRANSLATE (yychar);
1751 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
1752 YYSIZE_T yysize = yysize0;
1754 int yysize_overflow = 0;
1755 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1756 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1760 /* This is so xgettext sees the translatable formats that are
1761 constructed on the fly. */
1762 YY_("syntax error, unexpected %s");
1763 YY_("syntax error, unexpected %s, expecting %s");
1764 YY_("syntax error, unexpected %s, expecting %s or %s");
1765 YY_("syntax error, unexpected %s, expecting %s or %s or %s");
1766 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
1770 static char const yyunexpected[] = "syntax error, unexpected %s";
1771 static char const yyexpecting[] = ", expecting %s";
1772 static char const yyor[] = " or %s";
1773 char yyformat[sizeof yyunexpected
1774 + sizeof yyexpecting - 1
1775 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
1776 * (sizeof yyor - 1))];
1777 char const *yyprefix = yyexpecting;
1779 /* Start YYX at -YYN if negative to avoid negative indexes in
1781 int yyxbegin = yyn < 0 ? -yyn : 0;
1783 /* Stay within bounds of both yycheck and yytname. */
1784 int yychecklim = YYLAST - yyn + 1;
1785 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1788 yyarg[0] = yytname[yytype];
1789 yyfmt = yystpcpy (yyformat, yyunexpected);
1791 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1792 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1794 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1798 yyformat[sizeof yyunexpected - 1] = '\0';
1801 yyarg[yycount++] = yytname[yyx];
1802 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1803 yysize_overflow |= (yysize1 < yysize);
1805 yyfmt = yystpcpy (yyfmt, yyprefix);
1809 yyf = YY_(yyformat);
1810 yysize1 = yysize + yystrlen (yyf);
1811 yysize_overflow |= (yysize1 < yysize);
1814 if (yysize_overflow)
1815 return YYSIZE_MAXIMUM;
1819 /* Avoid sprintf, as that infringes on the user's name space.
1820 Don't have undefined behavior even if the translation
1821 produced a string with the wrong number of "%s"s. */
1822 char *yyp = yyresult;
1824 while ((*yyp = *yyf) != '\0')
1826 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
1828 yyp += yytnamerr (yyp, yyarg[yyi++]);
1841 #endif /* YYERROR_VERBOSE */
1844 /*-----------------------------------------------.
1845 | Release the memory associated to this symbol. |
1846 `-----------------------------------------------*/
1849 #if (defined __STDC__ || defined __C99__FUNC__ \
1850 || defined __cplusplus || defined _MSC_VER)
1852 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1855 yydestruct (yymsg, yytype, yyvaluep)
1865 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1876 /* Prevent warnings from -Wmissing-prototypes. */
1878 #ifdef YYPARSE_PARAM
1879 #if defined __STDC__ || defined __cplusplus
1880 int yyparse (void *YYPARSE_PARAM);
1884 #else /* ! YYPARSE_PARAM */
1885 #if defined __STDC__ || defined __cplusplus
1890 #endif /* ! YYPARSE_PARAM */
1894 /* The look-ahead symbol. */
1897 /* The semantic value of the look-ahead symbol. */
1900 /* Number of syntax errors so far. */
1909 #ifdef YYPARSE_PARAM
1910 #if (defined __STDC__ || defined __C99__FUNC__ \
1911 || defined __cplusplus || defined _MSC_VER)
1913 yyparse (void *YYPARSE_PARAM)
1916 yyparse (YYPARSE_PARAM)
1917 void *YYPARSE_PARAM;
1919 #else /* ! YYPARSE_PARAM */
1920 #if (defined __STDC__ || defined __C99__FUNC__ \
1921 || defined __cplusplus || defined _MSC_VER)
1935 /* Number of tokens to shift before error messages enabled. */
1937 /* Look-ahead token as an internal (translated) token number. */
1940 /* Buffer for error messages, and its allocated size. */
1942 char *yymsg = yymsgbuf;
1943 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1946 /* Three stacks and their tools:
1947 `yyss': related to states,
1948 `yyvs': related to semantic values,
1949 `yyls': related to locations.
1951 Refer to the stacks thru separate pointers, to allow yyoverflow
1952 to reallocate them elsewhere. */
1954 /* The state stack. */
1955 yytype_int16 yyssa[YYINITDEPTH];
1956 yytype_int16 *yyss = yyssa;
1957 yytype_int16 *yyssp;
1959 /* The semantic value stack. */
1960 YYSTYPE yyvsa[YYINITDEPTH];
1961 YYSTYPE *yyvs = yyvsa;
1966 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1968 YYSIZE_T yystacksize = YYINITDEPTH;
1970 /* The variables used to return semantic value and location from the
1975 /* The number of symbols on the RHS of the reduced rule.
1976 Keep to zero when no symbol should be popped. */
1979 YYDPRINTF ((stderr, "Starting parse\n"));
1984 yychar = YYEMPTY; /* Cause a token to be read. */
1986 /* Initialize stack pointers.
1987 Waste one element of value and location stack
1988 so that they stay on the same level as the state stack.
1989 The wasted elements are never initialized. */
1996 /*------------------------------------------------------------.
1997 | yynewstate -- Push a new state, which is found in yystate. |
1998 `------------------------------------------------------------*/
2000 /* In all cases, when you get here, the value and location stacks
2001 have just been pushed. So pushing a state here evens the stacks. */
2007 if (yyss + yystacksize - 1 <= yyssp)
2009 /* Get the current used size of the three stacks, in elements. */
2010 YYSIZE_T yysize = yyssp - yyss + 1;
2014 /* Give user a chance to reallocate the stack. Use copies of
2015 these so that the &'s don't force the real ones into
2017 YYSTYPE *yyvs1 = yyvs;
2018 yytype_int16 *yyss1 = yyss;
2021 /* Each stack pointer address is followed by the size of the
2022 data in use in that stack, in bytes. This used to be a
2023 conditional around just the two extra args, but that might
2024 be undefined if yyoverflow is a macro. */
2025 yyoverflow (YY_("memory exhausted"),
2026 &yyss1, yysize * sizeof (*yyssp),
2027 &yyvs1, yysize * sizeof (*yyvsp),
2034 #else /* no yyoverflow */
2035 # ifndef YYSTACK_RELOCATE
2036 goto yyexhaustedlab;
2038 /* Extend the stack our own way. */
2039 if (YYMAXDEPTH <= yystacksize)
2040 goto yyexhaustedlab;
2042 if (YYMAXDEPTH < yystacksize)
2043 yystacksize = YYMAXDEPTH;
2046 yytype_int16 *yyss1 = yyss;
2047 union yyalloc *yyptr =
2048 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
2050 goto yyexhaustedlab;
2051 YYSTACK_RELOCATE (yyss);
2052 YYSTACK_RELOCATE (yyvs);
2054 # undef YYSTACK_RELOCATE
2056 YYSTACK_FREE (yyss1);
2059 #endif /* no yyoverflow */
2061 yyssp = yyss + yysize - 1;
2062 yyvsp = yyvs + yysize - 1;
2065 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
2066 (unsigned long int) yystacksize));
2068 if (yyss + yystacksize - 1 <= yyssp)
2072 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2081 /* Do appropriate processing given the current state. Read a
2082 look-ahead token if we need one and don't already have one. */
2084 /* First try to decide what to do without reference to look-ahead token. */
2085 yyn = yypact[yystate];
2086 if (yyn == YYPACT_NINF)
2089 /* Not known => get a look-ahead token if don't already have one. */
2091 /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
2092 if (yychar == YYEMPTY)
2094 YYDPRINTF ((stderr, "Reading a token: "));
2098 if (yychar <= YYEOF)
2100 yychar = yytoken = YYEOF;
2101 YYDPRINTF ((stderr, "Now at end of input.\n"));
2105 yytoken = YYTRANSLATE (yychar);
2106 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2109 /* If the proper action on seeing token YYTOKEN is to reduce or to
2110 detect an error, take that action. */
2112 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
2117 if (yyn == 0 || yyn == YYTABLE_NINF)
2126 /* Count tokens shifted since error; after three, turn off error
2131 /* Shift the look-ahead token. */
2132 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2134 /* Discard the shifted token unless it is eof. */
2135 if (yychar != YYEOF)
2144 /*-----------------------------------------------------------.
2145 | yydefault -- do the default action for the current state. |
2146 `-----------------------------------------------------------*/
2148 yyn = yydefact[yystate];
2154 /*-----------------------------.
2155 | yyreduce -- Do a reduction. |
2156 `-----------------------------*/
2158 /* yyn is the number of a rule to reduce with. */
2161 /* If YYLEN is nonzero, implement the default value of the action:
2164 Otherwise, the following line sets YYVAL to garbage.
2165 This behavior is undocumented and Bison
2166 users should not rely upon it. Assigning to YYVAL
2167 unconditionally makes the parser a bit smaller, and it avoids a
2168 GCC warning that YYVAL may be used uninitialized. */
2169 yyval = yyvsp[1-yylen];
2172 YY_REDUCE_PRINT (yyn);
2176 #line 171 "rx-parse.y"
2177 { as_bad (_("Unknown opcode: %s"), rx_init_start); }
2181 #line 176 "rx-parse.y"
2186 #line 179 "rx-parse.y"
2191 #line 182 "rx-parse.y"
2196 #line 185 "rx-parse.y"
2201 #line 190 "rx-parse.y"
2202 { if (rx_disp3op ((yyvsp[(2) - (2)].exp)))
2203 { B1 (0x08); rx_disp3 ((yyvsp[(2) - (2)].exp), 5); }
2204 else if (rx_intop ((yyvsp[(2) - (2)].exp), 8))
2205 { B1 (0x2e); PC1 ((yyvsp[(2) - (2)].exp)); }
2206 else if (rx_intop ((yyvsp[(2) - (2)].exp), 16))
2207 { B1 (0x38); PC2 ((yyvsp[(2) - (2)].exp)); }
2208 else if (rx_intop ((yyvsp[(2) - (2)].exp), 24))
2209 { B1 (0x04); PC3 ((yyvsp[(2) - (2)].exp)); }
2211 { rx_relax (RX_RELAX_BRANCH, 0);
2212 rx_linkrelax_branch ();
2213 /* We'll convert this to a longer one later if needed. */
2214 B1 (0x08); rx_disp3 ((yyvsp[(2) - (2)].exp), 5); } }
2218 #line 205 "rx-parse.y"
2219 { B1 (0x04); PC3 ((yyvsp[(3) - (3)].exp)); }
2223 #line 208 "rx-parse.y"
2224 { B1 (0x08); rx_disp3 ((yyvsp[(3) - (3)].exp), 5); }
2228 #line 213 "rx-parse.y"
2229 { if (rx_intop ((yyvsp[(2) - (2)].exp), 16))
2230 { B1 (0x39); PC2 ((yyvsp[(2) - (2)].exp)); }
2231 else if (rx_intop ((yyvsp[(2) - (2)].exp), 24))
2232 { B1 (0x05); PC3 ((yyvsp[(2) - (2)].exp)); }
2234 { rx_relax (RX_RELAX_BRANCH, 0);
2235 rx_linkrelax_branch ();
2236 B1 (0x39); PC2 ((yyvsp[(2) - (2)].exp)); } }
2240 #line 222 "rx-parse.y"
2241 { B1 (0x05), PC3 ((yyvsp[(3) - (3)].exp)); }
2245 #line 227 "rx-parse.y"
2246 { if ((yyvsp[(1) - (3)].regno) == COND_EQ || (yyvsp[(1) - (3)].regno) == COND_NE)
2247 { B1 ((yyvsp[(1) - (3)].regno) == COND_EQ ? 0x10 : 0x18); rx_disp3 ((yyvsp[(3) - (3)].exp), 5); }
2249 as_bad (_("Only BEQ and BNE may have .S")); }
2253 #line 235 "rx-parse.y"
2254 { B1 (0x20); F ((yyvsp[(1) - (3)].regno), 4, 4); PC1 ((yyvsp[(3) - (3)].exp)); }
2258 #line 238 "rx-parse.y"
2259 { B1 (0x2e), PC1 ((yyvsp[(3) - (3)].exp)); }
2263 #line 243 "rx-parse.y"
2264 { B1 (0x38), PC2 ((yyvsp[(3) - (3)].exp)); }
2268 #line 245 "rx-parse.y"
2269 { B1 (0x39), PC2 ((yyvsp[(3) - (3)].exp)); }
2273 #line 247 "rx-parse.y"
2274 { if ((yyvsp[(1) - (3)].regno) == COND_EQ || (yyvsp[(1) - (3)].regno) == COND_NE)
2275 { B1 ((yyvsp[(1) - (3)].regno) == COND_EQ ? 0x3a : 0x3b); PC2 ((yyvsp[(3) - (3)].exp)); }
2277 as_bad (_("Only BEQ and BNE may have .W")); }
2281 #line 252 "rx-parse.y"
2282 { if ((yyvsp[(1) - (2)].regno) == COND_EQ || (yyvsp[(1) - (2)].regno) == COND_NE)
2284 rx_relax (RX_RELAX_BRANCH, 0);
2285 rx_linkrelax_branch ();
2286 B1 ((yyvsp[(1) - (2)].regno) == COND_EQ ? 0x10 : 0x18); rx_disp3 ((yyvsp[(2) - (2)].exp), 5);
2290 rx_relax (RX_RELAX_BRANCH, 0);
2291 /* This is because we might turn it into a
2292 jump-over-jump long branch. */
2293 rx_linkrelax_branch ();
2294 B1 (0x20); F ((yyvsp[(1) - (2)].regno), 4, 4); PC1 ((yyvsp[(2) - (2)].exp));
2299 #line 271 "rx-parse.y"
2300 { if ((yyvsp[(8) - (9)].regno) <= 7 && rx_uintop ((yyvsp[(4) - (9)].exp), 8) && rx_disp5op0 (&(yyvsp[(6) - (9)].exp), BSIZE))
2301 { B2 (0x3c, 0); rx_field5s2 ((yyvsp[(6) - (9)].exp)); F ((yyvsp[(8) - (9)].regno), 9, 3); O1 ((yyvsp[(4) - (9)].exp)); }
2303 { B2 (0xf8, 0x04); F ((yyvsp[(8) - (9)].regno), 8, 4); DSP ((yyvsp[(6) - (9)].exp), 6, BSIZE); O1 ((yyvsp[(4) - (9)].exp));
2304 if ((yyvsp[(4) - (9)].exp).X_op != O_constant && (yyvsp[(4) - (9)].exp).X_op != O_big) rx_linkrelax_imm (12); } }
2308 #line 278 "rx-parse.y"
2309 { if ((yyvsp[(8) - (9)].regno) <= 7 && rx_uintop ((yyvsp[(4) - (9)].exp), 8) && rx_disp5op0 (&(yyvsp[(6) - (9)].exp), WSIZE))
2310 { B2 (0x3d, 0); rx_field5s2 ((yyvsp[(6) - (9)].exp)); F ((yyvsp[(8) - (9)].regno), 9, 3); O1 ((yyvsp[(4) - (9)].exp)); }
2312 { B2 (0xf8, 0x01); F ((yyvsp[(8) - (9)].regno), 8, 4); DSP ((yyvsp[(6) - (9)].exp), 6, WSIZE); IMM ((yyvsp[(4) - (9)].exp), 12); } }
2316 #line 284 "rx-parse.y"
2317 { if ((yyvsp[(8) - (9)].regno) <= 7 && rx_uintop ((yyvsp[(4) - (9)].exp), 8) && rx_disp5op0 (&(yyvsp[(6) - (9)].exp), LSIZE))
2318 { B2 (0x3e, 0); rx_field5s2 ((yyvsp[(6) - (9)].exp)); F ((yyvsp[(8) - (9)].regno), 9, 3); O1 ((yyvsp[(4) - (9)].exp)); }
2320 { B2 (0xf8, 0x02); F ((yyvsp[(8) - (9)].regno), 8, 4); DSP ((yyvsp[(6) - (9)].exp), 6, LSIZE); IMM ((yyvsp[(4) - (9)].exp), 12); } }
2324 #line 292 "rx-parse.y"
2325 { B2 (0x3f, 0); F ((yyvsp[(5) - (7)].regno), 8, 4); F ((yyvsp[(7) - (7)].regno), 12, 4); rtsd_immediate ((yyvsp[(3) - (7)].exp));
2326 if ((yyvsp[(5) - (7)].regno) == 0)
2327 rx_error (_("RTSD cannot pop R0"));
2328 if ((yyvsp[(5) - (7)].regno) > (yyvsp[(7) - (7)].regno))
2329 rx_error (_("RTSD first reg must be <= second reg")); }
2333 #line 301 "rx-parse.y"
2334 { B2 (0x47, 0); F ((yyvsp[(2) - (4)].regno), 8, 4); F ((yyvsp[(4) - (4)].regno), 12, 4); }
2338 #line 306 "rx-parse.y"
2339 { B2 (0x44, 0); F ((yyvsp[(4) - (8)].regno), 8, 4); F ((yyvsp[(8) - (8)].regno), 12, 4); DSP ((yyvsp[(2) - (8)].exp), 6, BSIZE); }
2343 #line 309 "rx-parse.y"
2344 { B3 (MEMEX, 0x04, 0); F ((yyvsp[(6) - (8)].regno), 8, 2); F ((yyvsp[(4) - (8)].regno), 16, 4); F ((yyvsp[(8) - (8)].regno), 20, 4); DSP ((yyvsp[(2) - (8)].exp), 14, sizemap[(yyvsp[(6) - (8)].regno)]); }
2348 #line 314 "rx-parse.y"
2349 { B2 (0x5b, 0x00); F ((yyvsp[(2) - (5)].regno), 5, 1); F ((yyvsp[(3) - (5)].regno), 8, 4); F ((yyvsp[(5) - (5)].regno), 12, 4); }
2353 #line 319 "rx-parse.y"
2354 { B2 (0x58, 0x00); F ((yyvsp[(2) - (7)].regno), 5, 1); F ((yyvsp[(4) - (7)].regno), 8, 4); F ((yyvsp[(7) - (7)].regno), 12, 4); }
2358 #line 322 "rx-parse.y"
2359 { if ((yyvsp[(5) - (8)].regno) <= 7 && (yyvsp[(8) - (8)].regno) <= 7 && rx_disp5op (&(yyvsp[(3) - (8)].exp), (yyvsp[(2) - (8)].regno)))
2360 { B2 (0xb0, 0); F ((yyvsp[(2) - (8)].regno), 4, 1); F ((yyvsp[(5) - (8)].regno), 9, 3); F ((yyvsp[(8) - (8)].regno), 13, 3); rx_field5s ((yyvsp[(3) - (8)].exp)); }
2362 { B2 (0x58, 0x00); F ((yyvsp[(2) - (8)].regno), 5, 1); F ((yyvsp[(5) - (8)].regno), 8, 4); F ((yyvsp[(8) - (8)].regno), 12, 4); DSP ((yyvsp[(3) - (8)].exp), 6, (yyvsp[(2) - (8)].regno)); } }
2366 #line 330 "rx-parse.y"
2367 { if (rx_uintop ((yyvsp[(3) - (5)].exp), 4))
2368 { B2 (0x60, 0); FE ((yyvsp[(3) - (5)].exp), 8, 4); F ((yyvsp[(5) - (5)].regno), 12, 4); }
2370 /* This is really an add, but we negate the immediate. */
2371 { B2 (0x70, 0); F ((yyvsp[(5) - (5)].regno), 8, 4); F ((yyvsp[(5) - (5)].regno), 12, 4); NIMM ((yyvsp[(3) - (5)].exp), 6); } }
2375 #line 337 "rx-parse.y"
2376 { if (rx_uintop ((yyvsp[(3) - (5)].exp), 4))
2377 { B2 (0x61, 0); FE ((yyvsp[(3) - (5)].exp), 8, 4); F ((yyvsp[(5) - (5)].regno), 12, 4); }
2378 else if (rx_uintop ((yyvsp[(3) - (5)].exp), 8))
2379 { B2 (0x75, 0x50); F ((yyvsp[(5) - (5)].regno), 12, 4); UO1 ((yyvsp[(3) - (5)].exp)); }
2381 { B2 (0x74, 0x00); F ((yyvsp[(5) - (5)].regno), 12, 4); IMM ((yyvsp[(3) - (5)].exp), 6); } }
2385 #line 345 "rx-parse.y"
2386 { if (rx_uintop ((yyvsp[(3) - (5)].exp), 4))
2387 { B2 (0x62, 0); FE ((yyvsp[(3) - (5)].exp), 8, 4); F ((yyvsp[(5) - (5)].regno), 12, 4); }
2389 { B2 (0x70, 0); F ((yyvsp[(5) - (5)].regno), 8, 4); F ((yyvsp[(5) - (5)].regno), 12, 4); IMM ((yyvsp[(3) - (5)].exp), 6); } }
2393 #line 351 "rx-parse.y"
2394 { if (rx_uintop ((yyvsp[(3) - (5)].exp), 4))
2395 { B2 (0x63, 0); FE ((yyvsp[(3) - (5)].exp), 8, 4); F ((yyvsp[(5) - (5)].regno), 12, 4); }
2397 { B2 (0x74, 0x10); F ((yyvsp[(5) - (5)].regno), 12, 4); IMM ((yyvsp[(3) - (5)].exp), 6); } }
2401 #line 357 "rx-parse.y"
2402 { if (rx_uintop ((yyvsp[(3) - (5)].exp), 4))
2403 { B2 (0x64, 0); FE ((yyvsp[(3) - (5)].exp), 8, 4); F ((yyvsp[(5) - (5)].regno), 12, 4); }
2405 { B2 (0x74, 0x20); F ((yyvsp[(5) - (5)].regno), 12, 4); IMM ((yyvsp[(3) - (5)].exp), 6); } }
2409 #line 363 "rx-parse.y"
2410 { if (rx_uintop ((yyvsp[(3) - (5)].exp), 4))
2411 { B2 (0x65, 0); FE ((yyvsp[(3) - (5)].exp), 8, 4); F ((yyvsp[(5) - (5)].regno), 12, 4); }
2413 { B2 (0x74, 0x30); F ((yyvsp[(5) - (5)].regno), 12, 4); IMM ((yyvsp[(3) - (5)].exp), 6); } }
2417 #line 369 "rx-parse.y"
2418 { if (rx_uintop ((yyvsp[(4) - (6)].exp), 4))
2419 { B2 (0x66, 0); FE ((yyvsp[(4) - (6)].exp), 8, 4); F ((yyvsp[(6) - (6)].regno), 12, 4); }
2420 else if (rx_uintop ((yyvsp[(4) - (6)].exp), 8))
2421 { B2 (0x75, 0x40); F ((yyvsp[(6) - (6)].regno), 12, 4); UO1 ((yyvsp[(4) - (6)].exp)); }
2423 { B2 (0xfb, 0x02); F ((yyvsp[(6) - (6)].regno), 8, 4); IMM ((yyvsp[(4) - (6)].exp), 12); } }
2427 #line 377 "rx-parse.y"
2428 { if (rx_uintop ((yyvsp[(3) - (5)].exp), 4))
2429 { B2 (0x66, 0); FE ((yyvsp[(3) - (5)].exp), 8, 4); F ((yyvsp[(5) - (5)].regno), 12, 4); }
2430 else if (rx_uintop ((yyvsp[(3) - (5)].exp), 8))
2431 { B2 (0x75, 0x40); F ((yyvsp[(5) - (5)].regno), 12, 4); UO1 ((yyvsp[(3) - (5)].exp)); }
2433 { B2 (0xfb, 0x02); F ((yyvsp[(5) - (5)].regno), 8, 4); IMM ((yyvsp[(3) - (5)].exp), 12); } }
2437 #line 387 "rx-parse.y"
2438 { B1 (0x67); rtsd_immediate ((yyvsp[(3) - (3)].exp)); }
2442 #line 391 "rx-parse.y"
2447 #line 392 "rx-parse.y"
2452 #line 393 "rx-parse.y"
2457 #line 398 "rx-parse.y"
2459 if ((yyvsp[(2) - (4)].regno) == (yyvsp[(4) - (4)].regno))
2460 { B2 (0x7e, 0x80); F (LSIZE, 10, 2); F ((yyvsp[(2) - (4)].regno), 12, 4); }
2462 { B2 (0x6e, 0); F ((yyvsp[(2) - (4)].regno), 8, 4); F ((yyvsp[(4) - (4)].regno), 12, 4); }
2463 if ((yyvsp[(2) - (4)].regno) == 0)
2464 rx_error (_("PUSHM cannot push R0"));
2465 if ((yyvsp[(2) - (4)].regno) > (yyvsp[(4) - (4)].regno))
2466 rx_error (_("PUSHM first reg must be <= second reg")); }
2470 #line 411 "rx-parse.y"
2472 if ((yyvsp[(2) - (4)].regno) == (yyvsp[(4) - (4)].regno))
2473 { B2 (0x7e, 0xb0); F ((yyvsp[(2) - (4)].regno), 12, 4); }
2475 { B2 (0x6f, 0); F ((yyvsp[(2) - (4)].regno), 8, 4); F ((yyvsp[(4) - (4)].regno), 12, 4); }
2476 if ((yyvsp[(2) - (4)].regno) == 0)
2477 rx_error (_("POPM cannot pop R0"));
2478 if ((yyvsp[(2) - (4)].regno) > (yyvsp[(4) - (4)].regno))
2479 rx_error (_("POPM first reg must be <= second reg")); }
2483 #line 424 "rx-parse.y"
2484 { B2 (0x70, 0x00); F ((yyvsp[(5) - (7)].regno), 8, 4); F ((yyvsp[(7) - (7)].regno), 12, 4); IMM ((yyvsp[(3) - (7)].exp), 6); }
2488 #line 429 "rx-parse.y"
2489 { B2(0x75, 0x60), UO1 ((yyvsp[(3) - (3)].exp)); }
2493 #line 434 "rx-parse.y"
2494 { B2 (0x78, 0); FE ((yyvsp[(3) - (5)].exp), 7, 5); F ((yyvsp[(5) - (5)].regno), 12, 4); }
2498 #line 436 "rx-parse.y"
2499 { B2 (0x7a, 0); FE ((yyvsp[(3) - (5)].exp), 7, 5); F ((yyvsp[(5) - (5)].regno), 12, 4); }
2503 #line 441 "rx-parse.y"
2504 { B2 (0x7c, 0x00); FE ((yyvsp[(3) - (5)].exp), 7, 5); F ((yyvsp[(5) - (5)].regno), 12, 4); }
2508 #line 446 "rx-parse.y"
2509 { B2 (0x7e, 0x30); F ((yyvsp[(2) - (2)].regno), 12, 4); }
2513 #line 448 "rx-parse.y"
2514 { B2 (0x7e, 0x40); F ((yyvsp[(2) - (2)].regno), 12, 4); }
2518 #line 450 "rx-parse.y"
2519 { B2 (0x7e, 0x50); F ((yyvsp[(2) - (2)].regno), 12, 4); }
2523 #line 455 "rx-parse.y"
2524 { B2 (0x7e, 0x80); F ((yyvsp[(2) - (3)].regno), 10, 2); F ((yyvsp[(3) - (3)].regno), 12, 4); }
2528 #line 460 "rx-parse.y"
2529 { B2 (0x7e, 0xb0); F ((yyvsp[(2) - (2)].regno), 12, 4); }
2533 #line 465 "rx-parse.y"
2534 { if ((yyvsp[(2) - (2)].regno) < 16)
2535 { B2 (0x7e, 0xc0); F ((yyvsp[(2) - (2)].regno), 12, 4); }
2537 as_bad (_("PUSHC can only push the first 16 control registers")); }
2541 #line 473 "rx-parse.y"
2542 { if ((yyvsp[(2) - (2)].regno) < 16)
2543 { B2 (0x7e, 0xe0); F ((yyvsp[(2) - (2)].regno), 12, 4); }
2545 as_bad (_("POPC can only pop the first 16 control registers")); }
2549 #line 481 "rx-parse.y"
2550 { B2 (0x7f, 0xa0); F ((yyvsp[(2) - (2)].regno), 12, 4); }
2554 #line 483 "rx-parse.y"
2555 { B2 (0x7f, 0xb0); F ((yyvsp[(2) - (2)].regno), 12, 4); }
2559 #line 488 "rx-parse.y"
2560 { B2 (0x7f, 0x00); F ((yyvsp[(2) - (2)].regno), 12, 4); }
2564 #line 490 "rx-parse.y"
2565 { B2 (0x7f, 0x10); F ((yyvsp[(2) - (2)].regno), 12, 4); }
2569 #line 492 "rx-parse.y"
2570 { B2 (0x7f, 0x40); F ((yyvsp[(3) - (3)].regno), 12, 4); }
2574 #line 494 "rx-parse.y"
2575 { B2 (0x7f, 0x50); F ((yyvsp[(3) - (3)].regno), 12, 4); }
2579 #line 499 "rx-parse.y"
2580 { B2 (0x7f, 0x83); }
2584 #line 501 "rx-parse.y"
2585 { B2 (0x7f, 0x87); }
2589 #line 503 "rx-parse.y"
2590 { B2 (0x7f, 0x8b); }
2594 #line 505 "rx-parse.y"
2595 { B2 (0x7f, 0x8f); }
2599 #line 510 "rx-parse.y"
2600 { B2 (0x7f, 0x80); F ((yyvsp[(2) - (2)].regno), 14, 2); }
2604 #line 512 "rx-parse.y"
2605 { B2 (0x7f, 0x84); F ((yyvsp[(2) - (2)].regno), 14, 2); }
2609 #line 514 "rx-parse.y"
2610 { B2 (0x7f, 0x88); F ((yyvsp[(2) - (2)].regno), 14, 2); }
2614 #line 519 "rx-parse.y"
2615 { B2 (0x7f, 0x8c); F ((yyvsp[(2) - (2)].regno), 14, 2); }
2619 #line 524 "rx-parse.y"
2620 { B2 (0x7f, 0x94); }
2624 #line 526 "rx-parse.y"
2625 { B2 (0x7f, 0x95); }
2629 #line 528 "rx-parse.y"
2630 { B2 (0x7f, 0x96); }
2634 #line 530 "rx-parse.y"
2635 { B2 (0x7f, 0x93); }
2639 #line 535 "rx-parse.y"
2640 { B3 (0x75, 0x70, 0x00); FE ((yyvsp[(3) - (3)].exp), 20, 4); }
2644 #line 541 "rx-parse.y"
2645 { if ((yyvsp[(3) - (8)].regno) <= 7 && (yyvsp[(7) - (8)].regno) <= 7 && rx_disp5op (&(yyvsp[(5) - (8)].exp), (yyvsp[(2) - (8)].regno)))
2646 { B2 (0x80, 0); F ((yyvsp[(2) - (8)].regno), 2, 2); F ((yyvsp[(7) - (8)].regno), 9, 3); F ((yyvsp[(3) - (8)].regno), 13, 3); rx_field5s ((yyvsp[(5) - (8)].exp)); }
2648 { B2 (0xc3, 0x00); F ((yyvsp[(2) - (8)].regno), 2, 2); F ((yyvsp[(7) - (8)].regno), 8, 4); F ((yyvsp[(3) - (8)].regno), 12, 4); DSP ((yyvsp[(5) - (8)].exp), 4, (yyvsp[(2) - (8)].regno)); }}
2652 #line 549 "rx-parse.y"
2653 { if ((yyvsp[(5) - (8)].regno) <= 7 && (yyvsp[(8) - (8)].regno) <= 7 && rx_disp5op (&(yyvsp[(3) - (8)].exp), (yyvsp[(2) - (8)].regno)))
2654 { B2 (0x88, 0); F ((yyvsp[(2) - (8)].regno), 2, 2); F ((yyvsp[(5) - (8)].regno), 9, 3); F ((yyvsp[(8) - (8)].regno), 13, 3); rx_field5s ((yyvsp[(3) - (8)].exp)); }
2656 { B2 (0xcc, 0x00); F ((yyvsp[(2) - (8)].regno), 2, 2); F ((yyvsp[(5) - (8)].regno), 8, 4); F ((yyvsp[(8) - (8)].regno), 12, 4); DSP ((yyvsp[(3) - (8)].exp), 6, (yyvsp[(2) - (8)].regno)); } }
2660 #line 563 "rx-parse.y"
2661 { B2 (0xc3, 0x00); F ((yyvsp[(2) - (7)].regno), 2, 2); F ((yyvsp[(6) - (7)].regno), 8, 4); F ((yyvsp[(3) - (7)].regno), 12, 4); }
2665 #line 568 "rx-parse.y"
2666 { B2 (0xc0, 0); F ((yyvsp[(2) - (10)].regno), 2, 2); F ((yyvsp[(4) - (10)].regno), 8, 4); F ((yyvsp[(9) - (10)].regno), 12, 4); DSP ((yyvsp[(7) - (10)].exp), 4, (yyvsp[(2) - (10)].regno)); }
2670 #line 573 "rx-parse.y"
2671 { B2 (0xc0, 0x00); F ((yyvsp[(2) - (11)].regno), 2, 2); F ((yyvsp[(5) - (11)].regno), 8, 4); F ((yyvsp[(10) - (11)].regno), 12, 4); DSP ((yyvsp[(3) - (11)].exp), 6, (yyvsp[(2) - (11)].regno)); DSP ((yyvsp[(8) - (11)].exp), 4, (yyvsp[(2) - (11)].regno)); }
2675 #line 578 "rx-parse.y"
2676 { B2 (0xcf, 0x00); F ((yyvsp[(2) - (5)].regno), 2, 2); F ((yyvsp[(3) - (5)].regno), 8, 4); F ((yyvsp[(5) - (5)].regno), 12, 4); }
2680 #line 583 "rx-parse.y"
2681 { B2 (0xcc, 0x00); F ((yyvsp[(2) - (7)].regno), 2, 2); F ((yyvsp[(4) - (7)].regno), 8, 4); F ((yyvsp[(7) - (7)].regno), 12, 4); }
2685 #line 588 "rx-parse.y"
2686 { B2 (0xf0, 0x00); F ((yyvsp[(7) - (9)].regno), 8, 4); FE ((yyvsp[(3) - (9)].exp), 13, 3); DSP ((yyvsp[(5) - (9)].exp), 6, BSIZE); }
2690 #line 590 "rx-parse.y"
2691 { B2 (0xf0, 0x08); F ((yyvsp[(7) - (9)].regno), 8, 4); FE ((yyvsp[(3) - (9)].exp), 13, 3); DSP ((yyvsp[(5) - (9)].exp), 6, BSIZE); }
2695 #line 592 "rx-parse.y"
2696 { B2 (0xf4, 0x00); F ((yyvsp[(7) - (9)].regno), 8, 4); FE ((yyvsp[(3) - (9)].exp), 13, 3); DSP ((yyvsp[(5) - (9)].exp), 6, BSIZE); }
2700 #line 597 "rx-parse.y"
2701 { B2 (0xf4, 0x08); F ((yyvsp[(2) - (6)].regno), 14, 2); F ((yyvsp[(5) - (6)].regno), 8, 4); DSP ((yyvsp[(3) - (6)].exp), 6, (yyvsp[(2) - (6)].regno)); }
2705 #line 601 "rx-parse.y"
2710 #line 602 "rx-parse.y"
2711 { sub_op = 1; sub_op2 = 1; }
2715 #line 603 "rx-parse.y"
2720 #line 604 "rx-parse.y"
2721 { sub_op = 3; sub_op2 = 2; }
2725 #line 605 "rx-parse.y"
2730 #line 606 "rx-parse.y"
2735 #line 607 "rx-parse.y"
2740 #line 608 "rx-parse.y"
2745 #line 609 "rx-parse.y"
2750 #line 610 "rx-parse.y"
2755 #line 611 "rx-parse.y"
2760 #line 612 "rx-parse.y"
2765 #line 613 "rx-parse.y"
2766 { sub_op = 14; sub_op2 = 0; }
2770 #line 614 "rx-parse.y"
2775 #line 615 "rx-parse.y"
2780 #line 619 "rx-parse.y"
2785 #line 620 "rx-parse.y"
2790 #line 621 "rx-parse.y"
2795 #line 622 "rx-parse.y"
2800 #line 627 "rx-parse.y"
2801 { id24 (1, 0x63, 0x00); F ((yyvsp[(4) - (4)].regno), 16, 4); F ((yyvsp[(2) - (4)].regno), 20, 4); }
2805 #line 629 "rx-parse.y"
2806 { id24 (1, 0x67, 0x00); F ((yyvsp[(4) - (4)].regno), 16, 4); F ((yyvsp[(2) - (4)].regno), 20, 4); }
2810 #line 631 "rx-parse.y"
2811 { id24 (1, 0x6b, 0x00); F ((yyvsp[(4) - (4)].regno), 16, 4); F ((yyvsp[(2) - (4)].regno), 20, 4); }
2815 #line 633 "rx-parse.y"
2816 { id24 (1, 0x6f, 0x00); F ((yyvsp[(4) - (4)].regno), 16, 4); F ((yyvsp[(2) - (4)].regno), 20, 4); }
2820 #line 636 "rx-parse.y"
2821 { id24 (1, 0x60, 0x00); F ((yyvsp[(6) - (8)].regno), 16, 4); F ((yyvsp[(2) - (8)].regno), 20, 4); DSP ((yyvsp[(4) - (8)].exp), 14, BSIZE); }
2825 #line 638 "rx-parse.y"
2826 { id24 (1, 0x64, 0x00); F ((yyvsp[(6) - (8)].regno), 16, 4); F ((yyvsp[(2) - (8)].regno), 20, 4); DSP ((yyvsp[(4) - (8)].exp), 14, BSIZE); }
2830 #line 640 "rx-parse.y"
2831 { id24 (1, 0x68, 0x00); F ((yyvsp[(6) - (8)].regno), 16, 4); F ((yyvsp[(2) - (8)].regno), 20, 4); DSP ((yyvsp[(4) - (8)].exp), 14, BSIZE); }
2835 #line 642 "rx-parse.y"
2836 { id24 (1, 0x6c, 0x00); F ((yyvsp[(6) - (8)].regno), 16, 4); F ((yyvsp[(2) - (8)].regno), 20, 4); DSP ((yyvsp[(4) - (8)].exp), 14, BSIZE); }
2840 #line 646 "rx-parse.y"
2845 #line 647 "rx-parse.y"
2850 #line 648 "rx-parse.y"
2855 #line 649 "rx-parse.y"
2860 #line 650 "rx-parse.y"
2865 #line 651 "rx-parse.y"
2870 #line 652 "rx-parse.y"
2875 #line 657 "rx-parse.y"
2876 { id24 (1, 0xdb, 0x00); F ((yyvsp[(1) - (3)].regno), 20, 4); F ((yyvsp[(3) - (3)].regno), 16, 4); }
2880 #line 659 "rx-parse.y"
2881 { id24 (1, 0xd0, 0x00); F ((yyvsp[(1) - (6)].regno), 20, 4); F ((yyvsp[(2) - (6)].regno), 12, 2); F ((yyvsp[(5) - (6)].regno), 16, 4); DSP ((yyvsp[(3) - (6)].exp), 14, (yyvsp[(2) - (6)].regno)); }
2885 #line 664 "rx-parse.y"
2886 { id24 (1, 0xe0, 0x00); F ((yyvsp[(1) - (9)].regno), 20, 4); FE ((yyvsp[(3) - (9)].exp), 11, 3);
2887 F ((yyvsp[(7) - (9)].regno), 16, 4); DSP ((yyvsp[(5) - (9)].exp), 14, BSIZE); }
2891 #line 670 "rx-parse.y"
2892 { id24 (1, 0xe0, 0x0f); FE ((yyvsp[(3) - (9)].exp), 11, 3); F ((yyvsp[(7) - (9)].regno), 16, 4);
2893 DSP ((yyvsp[(5) - (9)].exp), 14, BSIZE); }
2897 #line 676 "rx-parse.y"
2898 { id24 (2, 0x00, 0x00); F ((yyvsp[(2) - (4)].regno), 16, 4); F ((yyvsp[(4) - (4)].regno), 20, 4); }
2902 #line 678 "rx-parse.y"
2903 { id24 (2, 0x01, 0x00); F ((yyvsp[(2) - (4)].regno), 16, 4); F ((yyvsp[(4) - (4)].regno), 20, 4); }
2907 #line 680 "rx-parse.y"
2908 { id24 (2, 0x04, 0x00); F ((yyvsp[(2) - (4)].regno), 16, 4); F ((yyvsp[(4) - (4)].regno), 20, 4); }
2912 #line 682 "rx-parse.y"
2913 { id24 (2, 0x05, 0x00); F ((yyvsp[(2) - (4)].regno), 16, 4); F ((yyvsp[(4) - (4)].regno), 20, 4); }
2917 #line 688 "rx-parse.y"
2918 { id24 (2, 0x17, 0x00); F ((yyvsp[(2) - (2)].regno), 20, 4); }
2922 #line 690 "rx-parse.y"
2923 { id24 (2, 0x17, 0x10); F ((yyvsp[(2) - (2)].regno), 20, 4); }
2927 #line 692 "rx-parse.y"
2928 { id24 (2, 0x1f, 0x00); F ((yyvsp[(2) - (2)].regno), 20, 4); }
2932 #line 694 "rx-parse.y"
2933 { id24 (2, 0x1f, 0x20); F ((yyvsp[(2) - (2)].regno), 20, 4); }
2937 #line 696 "rx-parse.y"
2938 { id24 (2, 0x1f, 0x10); F ((yyvsp[(2) - (2)].regno), 20, 4); }
2942 #line 699 "rx-parse.y"
2943 { id24 (2, 0x18, 0x00);
2944 if (rx_uintop ((yyvsp[(3) - (3)].exp), 4) && (yyvsp[(3) - (3)].exp).X_add_number == 1)
2946 else if (rx_uintop ((yyvsp[(3) - (3)].exp), 4) && (yyvsp[(3) - (3)].exp).X_add_number == 2)
2949 as_bad (_("RACW expects #1 or #2"));}
2953 #line 710 "rx-parse.y"
2954 { id24 (2, 0x20, 0); F ((yyvsp[(2) - (8)].regno), 14, 2); F ((yyvsp[(6) - (8)].regno), 16, 4); F ((yyvsp[(3) - (8)].regno), 20, 4); }
2958 #line 712 "rx-parse.y"
2959 { id24 (2, 0x24, 0); F ((yyvsp[(2) - (8)].regno), 14, 2); F ((yyvsp[(7) - (8)].regno), 16, 4); F ((yyvsp[(3) - (8)].regno), 20, 4); }
2963 #line 717 "rx-parse.y"
2964 { id24 (2, 0x28, 0); F ((yyvsp[(2) - (8)].regno), 14, 2); F ((yyvsp[(4) - (8)].regno), 16, 4); F ((yyvsp[(8) - (8)].regno), 20, 4); }
2968 #line 719 "rx-parse.y"
2969 { id24 (2, 0x2c, 0); F ((yyvsp[(2) - (8)].regno), 14, 2); F ((yyvsp[(5) - (8)].regno), 16, 4); F ((yyvsp[(8) - (8)].regno), 20, 4); }
2973 #line 724 "rx-parse.y"
2974 { id24 (2, 0x38, 0); F ((yyvsp[(2) - (8)].regno), 15, 1); F ((yyvsp[(4) - (8)].regno), 16, 4); F ((yyvsp[(8) - (8)].regno), 20, 4); }
2978 #line 726 "rx-parse.y"
2979 { id24 (2, 0x3c, 0); F ((yyvsp[(2) - (8)].regno), 15, 1); F ((yyvsp[(5) - (8)].regno), 16, 4); F ((yyvsp[(8) - (8)].regno), 20, 4); }
2983 #line 730 "rx-parse.y"
2988 #line 731 "rx-parse.y"
2993 #line 732 "rx-parse.y"
2998 #line 733 "rx-parse.y"
3003 #line 738 "rx-parse.y"
3004 { id24 (2, 0x68, 0x00); F ((yyvsp[(4) - (4)].regno) % 16, 20, 4); F ((yyvsp[(4) - (4)].regno) / 16, 15, 1);
3005 F ((yyvsp[(2) - (4)].regno), 16, 4); }
3009 #line 744 "rx-parse.y"
3010 { id24 (2, 0x6a, 0); F ((yyvsp[(2) - (4)].regno), 15, 5); F ((yyvsp[(4) - (4)].regno), 20, 4); }
3014 #line 749 "rx-parse.y"
3015 { id24 (2, 0x6e, 0); FE ((yyvsp[(3) - (5)].exp), 15, 5); F ((yyvsp[(5) - (5)].regno), 20, 4); }
3019 #line 751 "rx-parse.y"
3020 { id24 (2, 0x6c, 0); FE ((yyvsp[(3) - (5)].exp), 15, 5); F ((yyvsp[(5) - (5)].regno), 20, 4); }
3024 #line 756 "rx-parse.y"
3025 { id24 (2, 0x73, 0x00); F ((yyvsp[(5) - (5)].regno), 19, 5); IMM ((yyvsp[(3) - (5)].exp), 12); }
3029 #line 761 "rx-parse.y"
3030 { id24 (2, 0xe0, 0x00); F ((yyvsp[(1) - (5)].regno), 16, 4); FE ((yyvsp[(3) - (5)].exp), 11, 5);
3031 F ((yyvsp[(5) - (5)].regno), 20, 4); }
3035 #line 767 "rx-parse.y"
3036 { id24 (2, 0xe0, 0xf0); FE ((yyvsp[(3) - (5)].exp), 11, 5); F ((yyvsp[(5) - (5)].regno), 20, 4); }
3040 #line 772 "rx-parse.y"
3041 { id24 (3, 0x00, 0); F ((yyvsp[(2) - (9)].regno), 10, 2); F ((yyvsp[(6) - (9)].regno), 12, 4); F ((yyvsp[(8) - (9)].regno), 16, 4); F ((yyvsp[(3) - (9)].regno), 20, 4); }
3045 #line 775 "rx-parse.y"
3046 { id24 (3, 0x40, 0); F ((yyvsp[(2) - (9)].regno), 10, 2); F ((yyvsp[(4) - (9)].regno), 12, 4); F ((yyvsp[(6) - (9)].regno), 16, 4); F ((yyvsp[(9) - (9)].regno), 20, 4); }
3050 #line 778 "rx-parse.y"
3051 { id24 (3, 0xc0, 0); F ((yyvsp[(2) - (9)].regno), 10, 2); F ((yyvsp[(4) - (9)].regno), 12, 4); F ((yyvsp[(6) - (9)].regno), 16, 4); F ((yyvsp[(9) - (9)].regno), 20, 4); }
3055 #line 782 "rx-parse.y"
3060 #line 783 "rx-parse.y"
3065 #line 784 "rx-parse.y"
3070 #line 785 "rx-parse.y"
3075 #line 786 "rx-parse.y"
3080 #line 792 "rx-parse.y"
3081 { id24 (2, 0x70, 0x20); F ((yyvsp[(5) - (5)].regno), 20, 4); NBIMM ((yyvsp[(3) - (5)].exp), 12); }
3085 #line 802 "rx-parse.y"
3086 { B2 (0x43 + (sub_op<<2), 0); F ((yyvsp[(1) - (3)].regno), 8, 4); F ((yyvsp[(3) - (3)].regno), 12, 4); }
3090 #line 804 "rx-parse.y"
3091 { B2 (0x40 + (sub_op<<2), 0); F ((yyvsp[(3) - (7)].regno), 8, 4); F ((yyvsp[(7) - (7)].regno), 12, 4); DSP ((yyvsp[(1) - (7)].exp), 6, BSIZE); }
3095 #line 806 "rx-parse.y"
3096 { B3 (MEMEX, sub_op<<2, 0); F ((yyvsp[(5) - (7)].regno), 8, 2); F ((yyvsp[(3) - (7)].regno), 16, 4); F ((yyvsp[(7) - (7)].regno), 20, 4); DSP ((yyvsp[(1) - (7)].exp), 14, sizemap[(yyvsp[(5) - (7)].regno)]); }
3100 #line 808 "rx-parse.y"
3101 { id24 (4, sub_op<<4, 0), F ((yyvsp[(5) - (5)].regno), 12, 4), F ((yyvsp[(1) - (5)].regno), 16, 4), F ((yyvsp[(3) - (5)].regno), 20, 4); }
3105 #line 815 "rx-parse.y"
3106 { id24 (1, 0x03 + (sub_op<<2), 0x00); F ((yyvsp[(1) - (3)].regno), 16, 4); F ((yyvsp[(3) - (3)].regno), 20, 4); }
3110 #line 817 "rx-parse.y"
3111 { id24 (1, 0x00 + (sub_op<<2), 0x00); F ((yyvsp[(3) - (7)].regno), 16, 4); F ((yyvsp[(7) - (7)].regno), 20, 4); DSP ((yyvsp[(1) - (7)].exp), 14, BSIZE); }
3115 #line 819 "rx-parse.y"
3116 { B4 (MEMEX, 0x20 + ((yyvsp[(5) - (7)].regno) << 6), 0x00 + sub_op, 0x00);
3117 F ((yyvsp[(3) - (7)].regno), 24, 4); F ((yyvsp[(7) - (7)].regno), 28, 4); DSP ((yyvsp[(1) - (7)].exp), 14, sizemap[(yyvsp[(5) - (7)].regno)]); }
3121 #line 825 "rx-parse.y"
3122 { id24 (2, 0x70, sub_op<<4); F ((yyvsp[(4) - (4)].regno), 20, 4); IMM ((yyvsp[(2) - (4)].exp), 12); }
3126 #line 836 "rx-parse.y"
3127 { B2 (0x7e, sub_op2 << 4); F ((yyvsp[(1) - (1)].regno), 12, 4); }
3131 #line 842 "rx-parse.y"
3132 { id24 (1, 0x03 + (sub_op<<2), 0); F ((yyvsp[(1) - (3)].regno), 16, 4); F ((yyvsp[(3) - (3)].regno), 20, 4); }
3136 #line 844 "rx-parse.y"
3137 { id24 (1, 0x00 + (sub_op<<2), 0); F ((yyvsp[(3) - (7)].regno), 16, 4); F ((yyvsp[(7) - (7)].regno), 20, 4); DSP ((yyvsp[(1) - (7)].exp), 14, BSIZE); }
3141 #line 846 "rx-parse.y"
3142 { B4 (MEMEX, 0x20, 0x00 + sub_op, 0); F ((yyvsp[(5) - (7)].regno), 8, 2); F ((yyvsp[(3) - (7)].regno), 24, 4); F ((yyvsp[(7) - (7)].regno), 28, 4);
3143 DSP ((yyvsp[(1) - (7)].exp), 14, sizemap[(yyvsp[(5) - (7)].regno)]); }
3147 #line 853 "rx-parse.y"
3148 { id24 (2, 0x60 + sub_op, 0); F ((yyvsp[(1) - (3)].regno), 16, 4); F ((yyvsp[(3) - (3)].regno), 20, 4); }
3152 #line 857 "rx-parse.y"
3153 { B2 (0x68 + (sub_op<<1), 0); FE ((yyvsp[(2) - (4)].exp), 7, 5); F ((yyvsp[(4) - (4)].regno), 12, 4); }
3157 #line 859 "rx-parse.y"
3158 { id24 (2, 0x80 + (sub_op << 5), 0); FE ((yyvsp[(2) - (6)].exp), 11, 5); F ((yyvsp[(4) - (6)].regno), 16, 4); F ((yyvsp[(6) - (6)].regno), 20, 4); }
3162 #line 867 "rx-parse.y"
3163 { id24 (2, 0x72, sub_op << 4); F ((yyvsp[(4) - (4)].regno), 20, 4); O4 ((yyvsp[(2) - (4)].exp)); }
3167 #line 872 "rx-parse.y"
3168 { id24 (1, 0x83 + (sub_op << 2), 0); F ((yyvsp[(1) - (3)].regno), 16, 4); F ((yyvsp[(3) - (3)].regno), 20, 4); }
3172 #line 874 "rx-parse.y"
3173 { id24 (1, 0x80 + (sub_op << 2), 0); F ((yyvsp[(3) - (7)].regno), 16, 4); F ((yyvsp[(7) - (7)].regno), 20, 4); DSP ((yyvsp[(1) - (7)].exp), 14, LSIZE); }
3177 #line 879 "rx-parse.y"
3178 { (yyval.exp) = zero_expr (); }
3182 #line 880 "rx-parse.y"
3183 { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
3187 #line 883 "rx-parse.y"
3192 #line 883 "rx-parse.y"
3193 { need_flag = 0; (yyval.regno) = (yyvsp[(2) - (2)].regno); }
3197 #line 888 "rx-parse.y"
3198 { (yyval.regno) = 0; }
3202 #line 889 "rx-parse.y"
3203 { (yyval.regno) = 1; }
3207 #line 890 "rx-parse.y"
3208 { (yyval.regno) = 2; }
3212 #line 891 "rx-parse.y"
3213 { (yyval.regno) = 2; }
3217 #line 892 "rx-parse.y"
3218 { (yyval.regno) = 3; }
3222 #line 895 "rx-parse.y"
3223 { (yyval.regno) = LSIZE; }
3227 #line 896 "rx-parse.y"
3228 { (yyval.regno) = BSIZE; }
3232 #line 897 "rx-parse.y"
3233 { (yyval.regno) = WSIZE; }
3237 #line 898 "rx-parse.y"
3238 { (yyval.regno) = LSIZE; }
3242 #line 901 "rx-parse.y"
3243 { (yyval.regno) = 1; }
3247 #line 902 "rx-parse.y"
3248 { (yyval.regno) = 0; }
3252 #line 903 "rx-parse.y"
3253 { (yyval.regno) = 1; }
3257 #line 906 "rx-parse.y"
3262 #line 907 "rx-parse.y"
3267 /* Line 1267 of yacc.c. */
3268 #line 3269 "rx-parse.c"
3271 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
3275 YY_STACK_PRINT (yyss, yyssp);
3280 /* Now `shift' the result of the reduction. Determine what state
3281 that goes to, based on the state we popped back to and the rule
3282 number reduced by. */
3286 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
3287 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
3288 yystate = yytable[yystate];
3290 yystate = yydefgoto[yyn - YYNTOKENS];
3295 /*------------------------------------.
3296 | yyerrlab -- here on detecting error |
3297 `------------------------------------*/
3299 /* If not already recovering from an error, report this error. */
3303 #if ! YYERROR_VERBOSE
3304 yyerror (YY_("syntax error"));
3307 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
3308 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
3310 YYSIZE_T yyalloc = 2 * yysize;
3311 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
3312 yyalloc = YYSTACK_ALLOC_MAXIMUM;
3313 if (yymsg != yymsgbuf)
3314 YYSTACK_FREE (yymsg);
3315 yymsg = (char *) YYSTACK_ALLOC (yyalloc);
3317 yymsg_alloc = yyalloc;
3321 yymsg_alloc = sizeof yymsgbuf;
3325 if (0 < yysize && yysize <= yymsg_alloc)
3327 (void) yysyntax_error (yymsg, yystate, yychar);
3332 yyerror (YY_("syntax error"));
3334 goto yyexhaustedlab;
3342 if (yyerrstatus == 3)
3344 /* If just tried and failed to reuse look-ahead token after an
3345 error, discard it. */
3347 if (yychar <= YYEOF)
3349 /* Return failure if at end of input. */
3350 if (yychar == YYEOF)
3355 yydestruct ("Error: discarding",
3361 /* Else will try to reuse look-ahead token after shifting the error
3366 /*---------------------------------------------------.
3367 | yyerrorlab -- error raised explicitly by YYERROR. |
3368 `---------------------------------------------------*/
3371 /* Pacify compilers like GCC when the user code never invokes
3372 YYERROR and the label yyerrorlab therefore never appears in user
3374 if (/*CONSTCOND*/ 0)
3377 /* Do not reclaim the symbols of the rule which action triggered
3381 YY_STACK_PRINT (yyss, yyssp);
3386 /*-------------------------------------------------------------.
3387 | yyerrlab1 -- common code for both syntax error and YYERROR. |
3388 `-------------------------------------------------------------*/
3390 yyerrstatus = 3; /* Each real token shifted decrements this. */
3394 yyn = yypact[yystate];
3395 if (yyn != YYPACT_NINF)
3398 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
3406 /* Pop the current state because it cannot handle the error token. */
3411 yydestruct ("Error: popping",
3412 yystos[yystate], yyvsp);
3415 YY_STACK_PRINT (yyss, yyssp);
3424 /* Shift the error token. */
3425 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
3431 /*-------------------------------------.
3432 | yyacceptlab -- YYACCEPT comes here. |
3433 `-------------------------------------*/
3438 /*-----------------------------------.
3439 | yyabortlab -- YYABORT comes here. |
3440 `-----------------------------------*/
3446 /*-------------------------------------------------.
3447 | yyexhaustedlab -- memory exhaustion comes here. |
3448 `-------------------------------------------------*/
3450 yyerror (YY_("memory exhausted"));
3456 if (yychar != YYEOF && yychar != YYEMPTY)
3457 yydestruct ("Cleanup: discarding lookahead",
3459 /* Do not reclaim the symbols of the rule which action triggered
3460 this YYABORT or YYACCEPT. */
3462 YY_STACK_PRINT (yyss, yyssp);
3463 while (yyssp != yyss)
3465 yydestruct ("Cleanup: popping",
3466 yystos[*yyssp], yyvsp);
3471 YYSTACK_FREE (yyss);
3474 if (yymsg != yymsgbuf)
3475 YYSTACK_FREE (yymsg);
3477 /* Make sure YYID is used. */
3478 return YYID (yyresult);
3482 #line 910 "rx-parse.y"
3484 /* ====================================================================== */
3488 const char * string;
3514 { "fpsw", CREG, 3 },
3520 { "bpsw", CREG, 8 },
3522 { "isp", CREG, 10 },
3523 { "fintv", CREG, 11 },
3524 { "intb", CREG, 12 },
3526 { "pbp", CREG, 16 },
3527 { "pben", CREG, 17 },
3529 { "bbpsw", CREG, 24 },
3530 { "bbpc", CREG, 25 },
3537 { ".ub", DOT_UB, 0 },
3538 { ".uw", DOT_UW , 0},
3547 #define OPC(x) { #x, x, IS_OPCODE }
3551 { "and", AND_, IS_OPCODE },
3649 #define NUM_TOKENS (sizeof (token_table) / sizeof (token_table[0]))
3656 condition_opcode_table[] =
3663 #define NUM_CONDITION_OPCODES (sizeof (condition_opcode_table) / sizeof (condition_opcode_table[0]))
3694 #define NUM_CONDITIONS (sizeof (condition_table) / sizeof (condition_table[0]))
3697 rx_lex_init (char * beginning, char * ending)
3699 rx_init_start = beginning;
3700 rx_lex_start = beginning;
3701 rx_lex_end = ending;
3709 check_condition (char * base)
3714 if ((unsigned) (rx_lex_end - rx_lex_start) < strlen (base) + 1)
3716 if (memcmp (rx_lex_start, base, strlen (base)))
3718 cp = rx_lex_start + strlen (base);
3719 for (i = 0; i < NUM_CONDITIONS; i ++)
3721 if (strcasecmp (cp, condition_table[i].string) == 0)
3723 rx_lval.regno = condition_table[i].val;
3734 char * save_input_pointer;
3736 while (ISSPACE (*rx_lex_start)
3737 && rx_lex_start != rx_lex_end)
3740 rx_last_exp_start = rx_lex_start;
3742 if (rx_lex_start == rx_lex_end)
3745 if (ISALPHA (*rx_lex_start)
3746 || (*rx_lex_start == '.' && ISALPHA (rx_lex_start[1])))
3752 for (e = rx_lex_start + 1;
3753 e < rx_lex_end && ISALNUM (*e);
3759 if (rx_last_token == 0)
3760 for (ci = 0; ci < NUM_CONDITION_OPCODES; ci ++)
3761 if (check_condition (condition_opcode_table[ci].string))
3765 rx_last_token = condition_opcode_table[ci].token;
3766 return condition_opcode_table[ci].token;
3769 for (i = 0; i < NUM_TOKENS; i++)
3770 if (strcasecmp (rx_lex_start, token_table[i].string) == 0
3771 && !(token_table[i].val == IS_OPCODE && rx_last_token != 0)
3772 && !(token_table[i].token == FLAG && !need_flag))
3774 rx_lval.regno = token_table[i].val;
3777 rx_last_token = token_table[i].token;
3778 return token_table[i].token;
3783 if (rx_last_token == 0)
3785 rx_last_token = UNKNOWN_OPCODE;
3786 return UNKNOWN_OPCODE;
3789 if (rx_last_token == UNKNOWN_OPCODE)
3792 if (*rx_lex_start == '[')
3794 if (*rx_lex_start == ']')
3798 || rx_last_token == REG
3799 || strchr ("[],#", *rx_lex_start))
3801 rx_last_token = *rx_lex_start;
3802 return *rx_lex_start ++;
3805 save_input_pointer = input_line_pointer;
3806 input_line_pointer = rx_lex_start;
3807 rx_lval.exp.X_md = 0;
3808 expression (&rx_lval.exp);
3810 /* We parse but ignore any :<size> modifier on expressions. */
3811 if (*input_line_pointer == ':')
3815 for (cp = input_line_pointer + 1; *cp && cp < rx_lex_end; cp++)
3818 if (cp > input_line_pointer+1)
3819 input_line_pointer = cp;
3822 rx_lex_start = input_line_pointer;
3823 input_line_pointer = save_input_pointer;
3824 rx_last_token = EXPR;
3829 rx_error (char * str)
3833 len = rx_last_exp_start - rx_init_start;
3835 as_bad ("%s", rx_init_start);
3836 as_bad ("%*s^ %s", len, "", str);
3841 rx_intop (expressionS exp, int nbits)
3845 if (exp.X_op == O_big && nbits == 32)
3847 if (exp.X_op != O_constant)
3849 v = exp.X_add_number;
3854 return -0x8 <= v && v <= 0x7;
3856 return -0x10 <= v && v <= 0x17;
3858 return -0x80 <= v && v <= 0x7f;
3860 return -0x8000 <= v && v <= 0x7fff;
3862 return -0x800000 <= v && v <= 0x7fffff;
3866 printf ("rx_intop passed %d\n", nbits);
3873 rx_uintop (expressionS exp, int nbits)
3877 if (exp.X_op != O_constant)
3879 v = exp.X_add_number;
3890 return v <= 0xffffff;
3892 printf ("rx_uintop passed %d\n", nbits);
3899 rx_disp3op (expressionS exp)
3903 if (exp.X_op != O_constant)
3905 v = exp.X_add_number;
3906 if (v < 3 || v > 10)
3912 rx_disp5op (expressionS * exp, int msize)
3916 if (exp->X_op != O_constant)
3918 v = exp->X_add_number;
3923 if (0 < v && v <= 31)
3929 if (0 < v && v <= 63)
3931 exp->X_add_number >>= 1;
3938 if (0 < v && v <= 127)
3940 exp->X_add_number >>= 2;
3948 /* Just like the above, but allows a zero displacement. */
3951 rx_disp5op0 (expressionS * exp, int msize)
3953 if (exp->X_op != O_constant)
3955 if (exp->X_add_number == 0)
3957 return rx_disp5op (exp, msize);
3961 exp_val (expressionS exp)
3963 if (exp.X_op != O_constant)
3965 rx_error (_("constant expected"));
3968 return exp.X_add_number;
3974 /* Static, so program load sets it to all zeros, which is what we want. */
3975 static expressionS zero;
3976 zero.X_op = O_constant;
3981 immediate (expressionS exp, int type, int pos)
3983 /* We will emit constants ourself here, so negate them. */
3984 if (type == RXREL_NEGATIVE && exp.X_op == O_constant)
3985 exp.X_add_number = - exp.X_add_number;
3986 if (type == RXREL_NEGATIVE_BORROW)
3988 if (exp.X_op == O_constant)
3989 exp.X_add_number = - exp.X_add_number - 1;
3991 rx_error (_("sbb cannot use symbolic immediates"));
3994 if (rx_intop (exp, 8))
3996 rx_op (exp, 1, type);
3999 else if (rx_intop (exp, 16))
4001 rx_op (exp, 2, type);
4004 else if (rx_intop (exp, 24))
4006 rx_op (exp, 3, type);
4009 else if (rx_intop (exp, 32))
4011 rx_op (exp, 4, type);
4014 else if (type == RXREL_SIGNED)
4016 /* This is a symbolic immediate, we will relax it later. */
4017 rx_relax (RX_RELAX_IMM, pos);
4018 rx_op (exp, linkrelax ? 4 : 1, type);
4023 /* Let the linker deal with it. */
4024 rx_op (exp, 4, type);
4030 displacement (expressionS exp, int msize)
4035 if (exp.X_op == O_symbol
4040 case BFD_RELOC_GPREL16:
4044 exp.X_md = BFD_RELOC_RX_GPRELB;
4047 exp.X_md = BFD_RELOC_RX_GPRELW;
4050 exp.X_md = BFD_RELOC_RX_GPRELL;
4058 if (exp.X_op != O_constant)
4060 rx_error (_("displacements must be constants"));
4063 val = exp.X_add_number;
4074 rx_error (_("word displacement not word-aligned"));
4079 rx_error (_("long displacement not long-aligned"));
4083 as_bad (_("displacement with unknown size (internal bug?)\n"));
4088 exp.X_add_number = val;
4090 if (0 <= val && val <= 255 )
4096 if (0 <= val && val <= 65535)
4102 rx_error (_("negative displacements not allowed"));
4104 rx_error (_("displacement too large"));
4109 rtsd_immediate (expressionS exp)
4113 if (exp.X_op != O_constant)
4115 rx_error (_("rtsd size must be constant"));
4118 val = exp.X_add_number;
4120 rx_error (_("rtsd size must be multiple of 4"));
4122 if (val < 0 || val > 1020)
4123 rx_error (_("rtsd size must be 0..1020"));
4126 exp.X_add_number = val;
projects / external / binutils.git / blob