1 /* A Bison parser, made by GNU Bison 3.5. */
2
3 /* Bison implementation for Yacc-like parsers in C
4
5 Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2019 Free Software Foundation,
6 Inc.
7
8 This program is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20
21 /* As a special exception, you may create a larger work that contains
22 part or all of the Bison parser skeleton and distribute that work
23 under terms of your choice, so long as that work isn't itself a
24 parser generator using the skeleton or a modified version thereof
25 as a parser skeleton. Alternatively, if you modify or redistribute
26 the parser skeleton itself, you may (at your option) remove this
27 special exception, which will cause the skeleton and the resulting
28 Bison output files to be licensed under the GNU General Public
29 License without this special exception.
30
31 This special exception was added by the Free Software Foundation in
32 version 2.2 of Bison. */
33
34 /* C LALR(1) parser skeleton written by Richard Stallman, by
35 simplifying the original so-called "semantic" parser. */
36
37 /* All symbols defined below should begin with yy or YY, to avoid
38 infringing on user name space. This should be done even for local
39 variables, as they might otherwise be expanded by user macros.
40 There are some unavoidable exceptions within include files to
41 define necessary library symbols; they are noted "INFRINGES ON
42 USER NAME SPACE" below. */
43
44 /* Undocumented macros, especially those whose name start with YY_,
45 are private implementation details. Do not rely on them. */
46
47 /* Identify Bison output. */
48 #define YYBISON 1
49
50 /* Bison version. */
51 #define YYBISON_VERSION "3.5"
52
53 /* Skeleton name. */
54 #define YYSKELETON_NAME "yacc.c"
55
56 /* Pure parsers. */
57 #define YYPURE 0
58
59 /* Push parsers. */
60 #define YYPUSH 0
61
62 /* Pull parsers. */
63 #define YYPULL 1
64
65
66 /* Substitute the variable and function names. */
67 #define yyparse rx_parse
68 #define yylex rx_lex
69 #define yyerror rx_error
70 #define yydebug rx_debug
71 #define yynerrs rx_nerrs
72 #define yylval rx_lval
73 #define yychar rx_char
74
75 /* First part of user prologue. */
76 #line 20 "./config/rx-parse.y"
77
78
79 #include "as.h"
80 #include "safe-ctype.h"
81 #include "rx-defs.h"
82
83 static int rx_lex (void);
84
85 #define COND_EQ 0
86 #define COND_NE 1
87
88 #define MEMEX 0x06
89
90 #define BSIZE 0
91 #define WSIZE 1
92 #define LSIZE 2
93 #define DSIZE 3
94
95 /* .sb .sw .l .uw */
96 static int sizemap[] = { BSIZE, WSIZE, LSIZE, WSIZE };
97
98 /* Ok, here are the rules for using these macros...
99
100 B*() is used to specify the base opcode bytes. Fields to be filled
101 in later, leave zero. Call this first.
102
103 F() and FE() are used to fill in fields within the base opcode bytes. You MUST
104 call B*() before any F() or FE().
105
106 [UN]*O*(), PC*() appends operands to the end of the opcode. You
107 must call P() and B*() before any of these, so that the fixups
108 have the right byte location.
109 O = signed, UO = unsigned, NO = negated, PC = pcrel
110
111 IMM() adds an immediate and fills in the field for it.
112 NIMM() same, but negates the immediate.
113 NBIMM() same, but negates the immediate, for sbb.
114 DSP() adds a displacement, and fills in the field for it.
115
116 Note that order is significant for the O, IMM, and DSP macros, as
117 they append their data to the operand buffer in the order that you
118 call them.
119
120 Use "disp" for displacements whenever possible; this handles the
121 "0" case properly. */
122
123 #define B1(b1) rx_base1 (b1)
124 #define B2(b1, b2) rx_base2 (b1, b2)
125 #define B3(b1, b2, b3) rx_base3 (b1, b2, b3)
126 #define B4(b1, b2, b3, b4) rx_base4 (b1, b2, b3, b4)
127
128 /* POS is bits from the MSB of the first byte to the LSB of the last byte. */
129 #define F(val,pos,sz) rx_field (val, pos, sz)
130 #define FE(exp,pos,sz) rx_field (exp_val (exp), pos, sz);
131
132 #define O1(v) rx_op (v, 1, RXREL_SIGNED); rx_range (v, -128, 255)
133 #define O2(v) rx_op (v, 2, RXREL_SIGNED); rx_range (v, -32768, 65536)
134 #define O3(v) rx_op (v, 3, RXREL_SIGNED); rx_range (v, -8388608, 16777216)
135 #define O4(v) rx_op (v, 4, RXREL_SIGNED)
136
137 #define UO1(v) rx_op (v, 1, RXREL_UNSIGNED); rx_range (v, 0, 255)
138 #define UO2(v) rx_op (v, 2, RXREL_UNSIGNED); rx_range (v, 0, 65536)
139 #define UO3(v) rx_op (v, 3, RXREL_UNSIGNED); rx_range (v, 0, 16777216)
140 #define UO4(v) rx_op (v, 4, RXREL_UNSIGNED)
141
142 #define NO1(v) rx_op (v, 1, RXREL_NEGATIVE)
143 #define NO2(v) rx_op (v, 2, RXREL_NEGATIVE)
144 #define NO3(v) rx_op (v, 3, RXREL_NEGATIVE)
145 #define NO4(v) rx_op (v, 4, RXREL_NEGATIVE)
146
147 #define PC1(v) rx_op (v, 1, RXREL_PCREL)
148 #define PC2(v) rx_op (v, 2, RXREL_PCREL)
149 #define PC3(v) rx_op (v, 3, RXREL_PCREL)
150
151 #define POST(v) rx_post (v)
152
153 #define IMM_(v,pos,size) F (immediate (v, RXREL_SIGNED, pos, size), pos, 2); \
154 if (v.X_op != O_constant && v.X_op != O_big) rx_linkrelax_imm (pos)
155 #define IMM(v,pos) IMM_ (v, pos, 32)
156 #define IMMW(v,pos) IMM_ (v, pos, 16); rx_range (v, -32768, 65536)
157 #define IMMB(v,pos) IMM_ (v, pos, 8); rx_range (v, -128, 255)
158 #define NIMM(v,pos) F (immediate (v, RXREL_NEGATIVE, pos, 32), pos, 2)
159 #define NBIMM(v,pos) F (immediate (v, RXREL_NEGATIVE_BORROW, pos, 32), pos, 2)
160 #define DSP(v,pos,msz) if (!v.X_md) rx_relax (RX_RELAX_DISP, pos); \
161 else rx_linkrelax_dsp (pos); \
162 F (displacement (v, msz), pos, 2)
163
164 #define id24(a,b2,b3) B3 (0xfb + a, b2, b3)
165
166 static void rx_check_float_support (void);
167 static int rx_intop (expressionS, int, int);
168 static int rx_uintop (expressionS, int);
169 static int rx_disp3op (expressionS);
170 static int rx_disp5op (expressionS *, int);
171 static int rx_disp5op0 (expressionS *, int);
172 static int exp_val (expressionS exp);
173 static expressionS zero_expr (void);
174 static int immediate (expressionS, int, int, int);
175 static int displacement (expressionS, int);
176 static void rtsd_immediate (expressionS);
177 static void rx_range (expressionS, int, int);
178 static void rx_check_v2 (void);
179 static void rx_check_v3 (void);
180 static void rx_check_dfpu (void);
181
182 static int need_flag = 0;
183 static int rx_in_brackets = 0;
184 static int rx_last_token = 0;
185 static char * rx_init_start;
186 static char * rx_last_exp_start = 0;
187 static int sub_op;
188 static int sub_op2;
189
190 #define YYDEBUG 1
191 #define YYERROR_VERBOSE 1
192
193
194 #line 195 "config/rx-parse.c"
195
196 # ifndef YY_CAST
197 # ifdef __cplusplus
198 # define YY_CAST(Type, Val) static_cast<Type> (Val)
199 # define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
200 # else
201 # define YY_CAST(Type, Val) ((Type) (Val))
202 # define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
203 # endif
204 # endif
205 # ifndef YY_NULLPTR
206 # if defined __cplusplus
207 # if 201103L <= __cplusplus
208 # define YY_NULLPTR nullptr
209 # else
210 # define YY_NULLPTR 0
211 # endif
212 # else
213 # define YY_NULLPTR ((void*)0)
214 # endif
215 # endif
216
217 /* Enabling verbose error messages. */
218 #ifdef YYERROR_VERBOSE
219 # undef YYERROR_VERBOSE
220 # define YYERROR_VERBOSE 1
221 #else
222 # define YYERROR_VERBOSE 0
223 #endif
224
225 /* Use api.header.include to #include this header
226 instead of duplicating it here. */
227 #ifndef YY_RX_CONFIG_RX_PARSE_H_INCLUDED
228 # define YY_RX_CONFIG_RX_PARSE_H_INCLUDED
229 /* Debug traces. */
230 #ifndef YYDEBUG
231 # define YYDEBUG 0
232 #endif
233 #if YYDEBUG
234 extern int rx_debug;
235 #endif
236
237 /* Token type. */
238 #ifndef YYTOKENTYPE
239 # define YYTOKENTYPE
240 enum yytokentype
241 {
242 REG = 258,
243 FLAG = 259,
244 CREG = 260,
245 ACC = 261,
246 DREG = 262,
247 DREGH = 263,
248 DREGL = 264,
249 DCREG = 265,
250 EXPR = 266,
251 UNKNOWN_OPCODE = 267,
252 IS_OPCODE = 268,
253 DOT_S = 269,
254 DOT_B = 270,
255 DOT_W = 271,
256 DOT_L = 272,
257 DOT_A = 273,
258 DOT_UB = 274,
259 DOT_UW = 275,
260 DOT_D = 276,
261 ABS = 277,
262 ADC = 278,
263 ADD = 279,
264 AND_ = 280,
265 BCLR = 281,
266 BCND = 282,
267 BFMOV = 283,
268 BFMOVZ = 284,
269 BMCND = 285,
270 BNOT = 286,
271 BRA = 287,
272 BRK = 288,
273 BSET = 289,
274 BSR = 290,
275 BTST = 291,
276 CLRPSW = 292,
277 CMP = 293,
278 DABS = 294,
279 DADD = 295,
280 DBT = 296,
281 DCMP = 297,
282 DDIV = 298,
283 DIV = 299,
284 DIVU = 300,
285 DMOV = 301,
286 DMUL = 302,
287 DNEG = 303,
288 DPOPM = 304,
289 DPUSHM = 305,
290 DROUND = 306,
291 DSQRT = 307,
292 DSUB = 308,
293 DTOF = 309,
294 DTOI = 310,
295 DTOU = 311,
296 EDIV = 312,
297 EDIVU = 313,
298 EMACA = 314,
299 EMSBA = 315,
300 EMUL = 316,
301 EMULA = 317,
302 EMULU = 318,
303 FADD = 319,
304 FCMP = 320,
305 FDIV = 321,
306 FMUL = 322,
307 FREIT = 323,
308 FSUB = 324,
309 FSQRT = 325,
310 FTOD = 326,
311 FTOI = 327,
312 FTOU = 328,
313 INT = 329,
314 ITOD = 330,
315 ITOF = 331,
316 JMP = 332,
317 JSR = 333,
318 MACHI = 334,
319 MACLH = 335,
320 MACLO = 336,
321 MAX = 337,
322 MIN = 338,
323 MOV = 339,
324 MOVCO = 340,
325 MOVLI = 341,
326 MOVU = 342,
327 MSBHI = 343,
328 MSBLH = 344,
329 MSBLO = 345,
330 MUL = 346,
331 MULHI = 347,
332 MULLH = 348,
333 MULLO = 349,
334 MULU = 350,
335 MVFACHI = 351,
336 MVFACGU = 352,
337 MVFACMI = 353,
338 MVFACLO = 354,
339 MVFC = 355,
340 MVFDC = 356,
341 MVFDR = 357,
342 MVTACGU = 358,
343 MVTACHI = 359,
344 MVTACLO = 360,
345 MVTC = 361,
346 MVTDC = 362,
347 MVTIPL = 363,
348 NEG = 364,
349 NOP = 365,
350 NOT = 366,
351 OR = 367,
352 POP = 368,
353 POPC = 369,
354 POPM = 370,
355 PUSH = 371,
356 PUSHA = 372,
357 PUSHC = 373,
358 PUSHM = 374,
359 RACL = 375,
360 RACW = 376,
361 RDACL = 377,
362 RDACW = 378,
363 REIT = 379,
364 REVL = 380,
365 REVW = 381,
366 RMPA = 382,
367 ROLC = 383,
368 RORC = 384,
369 ROTL = 385,
370 ROTR = 386,
371 ROUND = 387,
372 RSTR = 388,
373 RTE = 389,
374 RTFI = 390,
375 RTS = 391,
376 RTSD = 392,
377 SAT = 393,
378 SATR = 394,
379 SAVE = 395,
380 SBB = 396,
381 SCCND = 397,
382 SCMPU = 398,
383 SETPSW = 399,
384 SHAR = 400,
385 SHLL = 401,
386 SHLR = 402,
387 SMOVB = 403,
388 SMOVF = 404,
389 SMOVU = 405,
390 SSTR = 406,
391 STNZ = 407,
392 STOP = 408,
393 STZ = 409,
394 SUB = 410,
395 SUNTIL = 411,
396 SWHILE = 412,
397 TST = 413,
398 UTOD = 414,
399 UTOF = 415,
400 WAIT = 416,
401 XCHG = 417,
402 XOR = 418
403 };
404 #endif
405 /* Tokens. */
406 #define REG 258
407 #define FLAG 259
408 #define CREG 260
409 #define ACC 261
410 #define DREG 262
411 #define DREGH 263
412 #define DREGL 264
413 #define DCREG 265
414 #define EXPR 266
415 #define UNKNOWN_OPCODE 267
416 #define IS_OPCODE 268
417 #define DOT_S 269
418 #define DOT_B 270
419 #define DOT_W 271
420 #define DOT_L 272
421 #define DOT_A 273
422 #define DOT_UB 274
423 #define DOT_UW 275
424 #define DOT_D 276
425 #define ABS 277
426 #define ADC 278
427 #define ADD 279
428 #define AND_ 280
429 #define BCLR 281
430 #define BCND 282
431 #define BFMOV 283
432 #define BFMOVZ 284
433 #define BMCND 285
434 #define BNOT 286
435 #define BRA 287
436 #define BRK 288
437 #define BSET 289
438 #define BSR 290
439 #define BTST 291
440 #define CLRPSW 292
441 #define CMP 293
442 #define DABS 294
443 #define DADD 295
444 #define DBT 296
445 #define DCMP 297
446 #define DDIV 298
447 #define DIV 299
448 #define DIVU 300
449 #define DMOV 301
450 #define DMUL 302
451 #define DNEG 303
452 #define DPOPM 304
453 #define DPUSHM 305
454 #define DROUND 306
455 #define DSQRT 307
456 #define DSUB 308
457 #define DTOF 309
458 #define DTOI 310
459 #define DTOU 311
460 #define EDIV 312
461 #define EDIVU 313
462 #define EMACA 314
463 #define EMSBA 315
464 #define EMUL 316
465 #define EMULA 317
466 #define EMULU 318
467 #define FADD 319
468 #define FCMP 320
469 #define FDIV 321
470 #define FMUL 322
471 #define FREIT 323
472 #define FSUB 324
473 #define FSQRT 325
474 #define FTOD 326
475 #define FTOI 327
476 #define FTOU 328
477 #define INT 329
478 #define ITOD 330
479 #define ITOF 331
480 #define JMP 332
481 #define JSR 333
482 #define MACHI 334
483 #define MACLH 335
484 #define MACLO 336
485 #define MAX 337
486 #define MIN 338
487 #define MOV 339
488 #define MOVCO 340
489 #define MOVLI 341
490 #define MOVU 342
491 #define MSBHI 343
492 #define MSBLH 344
493 #define MSBLO 345
494 #define MUL 346
495 #define MULHI 347
496 #define MULLH 348
497 #define MULLO 349
498 #define MULU 350
499 #define MVFACHI 351
500 #define MVFACGU 352
501 #define MVFACMI 353
502 #define MVFACLO 354
503 #define MVFC 355
504 #define MVFDC 356
505 #define MVFDR 357
506 #define MVTACGU 358
507 #define MVTACHI 359
508 #define MVTACLO 360
509 #define MVTC 361
510 #define MVTDC 362
511 #define MVTIPL 363
512 #define NEG 364
513 #define NOP 365
514 #define NOT 366
515 #define OR 367
516 #define POP 368
517 #define POPC 369
518 #define POPM 370
519 #define PUSH 371
520 #define PUSHA 372
521 #define PUSHC 373
522 #define PUSHM 374
523 #define RACL 375
524 #define RACW 376
525 #define RDACL 377
526 #define RDACW 378
527 #define REIT 379
528 #define REVL 380
529 #define REVW 381
530 #define RMPA 382
531 #define ROLC 383
532 #define RORC 384
533 #define ROTL 385
534 #define ROTR 386
535 #define ROUND 387
536 #define RSTR 388
537 #define RTE 389
538 #define RTFI 390
539 #define RTS 391
540 #define RTSD 392
541 #define SAT 393
542 #define SATR 394
543 #define SAVE 395
544 #define SBB 396
545 #define SCCND 397
546 #define SCMPU 398
547 #define SETPSW 399
548 #define SHAR 400
549 #define SHLL 401
550 #define SHLR 402
551 #define SMOVB 403
552 #define SMOVF 404
553 #define SMOVU 405
554 #define SSTR 406
555 #define STNZ 407
556 #define STOP 408
557 #define STZ 409
558 #define SUB 410
559 #define SUNTIL 411
560 #define SWHILE 412
561 #define TST 413
562 #define UTOD 414
563 #define UTOF 415
564 #define WAIT 416
565 #define XCHG 417
566 #define XOR 418
567
568 /* Value type. */
569 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
570 union YYSTYPE
571 {
572 #line 140 "./config/rx-parse.y"
573
574 int regno;
575 expressionS exp;
576
577 #line 578 "config/rx-parse.c"
578
579 };
580 typedef union YYSTYPE YYSTYPE;
581 # define YYSTYPE_IS_TRIVIAL 1
582 # define YYSTYPE_IS_DECLARED 1
583 #endif
584
585
586 extern YYSTYPE rx_lval;
587
588 int rx_parse (void);
589
590 #endif /* !YY_RX_CONFIG_RX_PARSE_H_INCLUDED */
591
592
593
594 #ifdef short
595 # undef short
596 #endif
597
598 /* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
599 <limits.h> and (if available) <stdint.h> are included
600 so that the code can choose integer types of a good width. */
601
602 #ifndef __PTRDIFF_MAX__
603 # include <limits.h> /* INFRINGES ON USER NAME SPACE */
604 # if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
605 # include <stdint.h> /* INFRINGES ON USER NAME SPACE */
606 # define YY_STDINT_H
607 # endif
608 #endif
609
610 /* Narrow types that promote to a signed type and that can represent a
611 signed or unsigned integer of at least N bits. In tables they can
612 save space and decrease cache pressure. Promoting to a signed type
613 helps avoid bugs in integer arithmetic. */
614
615 #ifdef __INT_LEAST8_MAX__
616 typedef __INT_LEAST8_TYPE__ yytype_int8;
617 #elif defined YY_STDINT_H
618 typedef int_least8_t yytype_int8;
619 #else
620 typedef signed char yytype_int8;
621 #endif
622
623 #ifdef __INT_LEAST16_MAX__
624 typedef __INT_LEAST16_TYPE__ yytype_int16;
625 #elif defined YY_STDINT_H
626 typedef int_least16_t yytype_int16;
627 #else
628 typedef short yytype_int16;
629 #endif
630
631 #if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
632 typedef __UINT_LEAST8_TYPE__ yytype_uint8;
633 #elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
634 && UINT_LEAST8_MAX <= INT_MAX)
635 typedef uint_least8_t yytype_uint8;
636 #elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
637 typedef unsigned char yytype_uint8;
638 #else
639 typedef short yytype_uint8;
640 #endif
641
642 #if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
643 typedef __UINT_LEAST16_TYPE__ yytype_uint16;
644 #elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
645 && UINT_LEAST16_MAX <= INT_MAX)
646 typedef uint_least16_t yytype_uint16;
647 #elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
648 typedef unsigned short yytype_uint16;
649 #else
650 typedef int yytype_uint16;
651 #endif
652
653 #ifndef YYPTRDIFF_T
654 # if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
655 # define YYPTRDIFF_T __PTRDIFF_TYPE__
656 # define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
657 # elif defined PTRDIFF_MAX
658 # ifndef ptrdiff_t
659 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
660 # endif
661 # define YYPTRDIFF_T ptrdiff_t
662 # define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
663 # else
664 # define YYPTRDIFF_T long
665 # define YYPTRDIFF_MAXIMUM LONG_MAX
666 # endif
667 #endif
668
669 #ifndef YYSIZE_T
670 # ifdef __SIZE_TYPE__
671 # define YYSIZE_T __SIZE_TYPE__
672 # elif defined size_t
673 # define YYSIZE_T size_t
674 # elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
675 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
676 # define YYSIZE_T size_t
677 # else
678 # define YYSIZE_T unsigned
679 # endif
680 #endif
681
682 #define YYSIZE_MAXIMUM \
683 YY_CAST (YYPTRDIFF_T, \
684 (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \
685 ? YYPTRDIFF_MAXIMUM \
686 : YY_CAST (YYSIZE_T, -1)))
687
688 #define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
689
690 /* Stored state numbers (used for stacks). */
691 typedef yytype_int16 yy_state_t;
692
693 /* State numbers in computations. */
694 typedef int yy_state_fast_t;
695
696 #ifndef YY_
697 # if defined YYENABLE_NLS && YYENABLE_NLS
698 # if ENABLE_NLS
699 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
700 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
701 # endif
702 # endif
703 # ifndef YY_
704 # define YY_(Msgid) Msgid
705 # endif
706 #endif
707
708 #ifndef YY_ATTRIBUTE_PURE
709 # if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
710 # define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
711 # else
712 # define YY_ATTRIBUTE_PURE
713 # endif
714 #endif
715
716 #ifndef YY_ATTRIBUTE_UNUSED
717 # if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
718 # define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
719 # else
720 # define YY_ATTRIBUTE_UNUSED
721 # endif
722 #endif
723
724 /* Suppress unused-variable warnings by "using" E. */
725 #if ! defined lint || defined __GNUC__
726 # define YYUSE(E) ((void) (E))
727 #else
728 # define YYUSE(E) /* empty */
729 #endif
730
731 #if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
732 /* Suppress an incorrect diagnostic about yylval being uninitialized. */
733 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
734 _Pragma ("GCC diagnostic push") \
735 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
736 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
737 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
738 _Pragma ("GCC diagnostic pop")
739 #else
740 # define YY_INITIAL_VALUE(Value) Value
741 #endif
742 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
743 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
744 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
745 #endif
746 #ifndef YY_INITIAL_VALUE
747 # define YY_INITIAL_VALUE(Value) /* Nothing. */
748 #endif
749
750 #if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
751 # define YY_IGNORE_USELESS_CAST_BEGIN \
752 _Pragma ("GCC diagnostic push") \
753 _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
754 # define YY_IGNORE_USELESS_CAST_END \
755 _Pragma ("GCC diagnostic pop")
756 #endif
757 #ifndef YY_IGNORE_USELESS_CAST_BEGIN
758 # define YY_IGNORE_USELESS_CAST_BEGIN
759 # define YY_IGNORE_USELESS_CAST_END
760 #endif
761
762
763 #define YY_ASSERT(E) ((void) (0 && (E)))
764
765 #if ! defined yyoverflow || YYERROR_VERBOSE
766
767 /* The parser invokes alloca or malloc; define the necessary symbols. */
768
769 # ifdef YYSTACK_USE_ALLOCA
770 # if YYSTACK_USE_ALLOCA
771 # ifdef __GNUC__
772 # define YYSTACK_ALLOC __builtin_alloca
773 # elif defined __BUILTIN_VA_ARG_INCR
774 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
775 # elif defined _AIX
776 # define YYSTACK_ALLOC __alloca
777 # elif defined _MSC_VER
778 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
779 # define alloca _alloca
780 # else
781 # define YYSTACK_ALLOC alloca
782 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
783 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
784 /* Use EXIT_SUCCESS as a witness for stdlib.h. */
785 # ifndef EXIT_SUCCESS
786 # define EXIT_SUCCESS 0
787 # endif
788 # endif
789 # endif
790 # endif
791 # endif
792
793 # ifdef YYSTACK_ALLOC
794 /* Pacify GCC's 'empty if-body' warning. */
795 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
796 # ifndef YYSTACK_ALLOC_MAXIMUM
797 /* The OS might guarantee only one guard page at the bottom of the stack,
798 and a page size can be as small as 4096 bytes. So we cannot safely
799 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
800 to allow for a few compiler-allocated temporary stack slots. */
801 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
802 # endif
803 # else
804 # define YYSTACK_ALLOC YYMALLOC
805 # define YYSTACK_FREE YYFREE
806 # ifndef YYSTACK_ALLOC_MAXIMUM
807 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
808 # endif
809 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
810 && ! ((defined YYMALLOC || defined malloc) \
811 && (defined YYFREE || defined free)))
812 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
813 # ifndef EXIT_SUCCESS
814 # define EXIT_SUCCESS 0
815 # endif
816 # endif
817 # ifndef YYMALLOC
818 # define YYMALLOC malloc
819 # if ! defined malloc && ! defined EXIT_SUCCESS
820 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
821 # endif
822 # endif
823 # ifndef YYFREE
824 # define YYFREE free
825 # if ! defined free && ! defined EXIT_SUCCESS
826 void free (void *); /* INFRINGES ON USER NAME SPACE */
827 # endif
828 # endif
829 # endif
830 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
831
832
833 #if (! defined yyoverflow \
834 && (! defined __cplusplus \
835 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
836
837 /* A type that is properly aligned for any stack member. */
838 union yyalloc
839 {
840 yy_state_t yyss_alloc;
841 YYSTYPE yyvs_alloc;
842 };
843
844 /* The size of the maximum gap between one aligned stack and the next. */
845 # define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
846
847 /* The size of an array large to enough to hold all stacks, each with
848 N elements. */
849 # define YYSTACK_BYTES(N) \
850 ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \
851 + YYSTACK_GAP_MAXIMUM)
852
853 # define YYCOPY_NEEDED 1
854
855 /* Relocate STACK from its old location to the new one. The
856 local variables YYSIZE and YYSTACKSIZE give the old and new number of
857 elements in the stack, and YYPTR gives the new location of the
858 stack. Advance YYPTR to a properly aligned location for the next
859 stack. */
860 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
861 do \
862 { \
863 YYPTRDIFF_T yynewbytes; \
864 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
865 Stack = &yyptr->Stack_alloc; \
866 yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
867 yyptr += yynewbytes / YYSIZEOF (*yyptr); \
868 } \
869 while (0)
870
871 #endif
872
873 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
874 /* Copy COUNT objects from SRC to DST. The source and destination do
875 not overlap. */
876 # ifndef YYCOPY
877 # if defined __GNUC__ && 1 < __GNUC__
878 # define YYCOPY(Dst, Src, Count) \
879 __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
880 # else
881 # define YYCOPY(Dst, Src, Count) \
882 do \
883 { \
884 YYPTRDIFF_T yyi; \
885 for (yyi = 0; yyi < (Count); yyi++) \
886 (Dst)[yyi] = (Src)[yyi]; \
887 } \
888 while (0)
889 # endif
890 # endif
891 #endif /* !YYCOPY_NEEDED */
892
893 /* YYFINAL -- State number of the termination state. */
894 #define YYFINAL 307
895 /* YYLAST -- Last index in YYTABLE. */
896 #define YYLAST 967
897
898 /* YYNTOKENS -- Number of terminals. */
899 #define YYNTOKENS 170
900 /* YYNNTS -- Number of nonterminals. */
901 #define YYNNTS 97
902 /* YYNRULES -- Number of rules. */
903 #define YYNRULES 356
904 /* YYNSTATES -- Number of states. */
905 #define YYNSTATES 924
906
907 #define YYUNDEFTOK 2
908 #define YYMAXUTOK 418
909
910
911 /* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
912 as returned by yylex, with out-of-bounds checking. */
913 #define YYTRANSLATE(YYX) \
914 (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
915
916 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
917 as returned by yylex. */
918 static const yytype_uint8 yytranslate[] =
919 {
920 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
921 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
922 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
923 2, 2, 2, 2, 2, 164, 2, 2, 2, 2,
924 2, 2, 2, 169, 165, 168, 2, 2, 2, 2,
925 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
926 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
927 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
928 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
929 2, 166, 2, 167, 2, 2, 2, 2, 2, 2,
930 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
931 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
932 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
933 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
934 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
935 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
936 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
937 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
938 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
939 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
940 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
941 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
942 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
943 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
944 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
945 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
946 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
947 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
948 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
949 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
950 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
951 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
952 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
953 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
954 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
955 95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
956 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
957 115, 116, 117, 118, 119, 120, 121, 122, 123, 124,
958 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
959 135, 136, 137, 138, 139, 140, 141, 142, 143, 144,
960 145, 146, 147, 148, 149, 150, 151, 152, 153, 154,
961 155, 156, 157, 158, 159, 160, 161, 162, 163
962 };
963
964 #if YYDEBUG
965 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
966 static const yytype_int16 yyrline[] =
967 {
968 0, 184, 184, 189, 192, 195, 198, 203, 218, 221,
969 226, 235, 240, 248, 251, 256, 258, 260, 265, 283,
970 286, 289, 292, 300, 306, 314, 323, 328, 331, 336,
971 341, 344, 352, 359, 367, 373, 379, 385, 391, 399,
972 409, 414, 414, 415, 415, 416, 416, 420, 433, 446,
973 451, 456, 458, 463, 468, 470, 472, 477, 482, 487,
974 497, 507, 509, 514, 516, 518, 520, 525, 527, 529,
975 531, 536, 538, 540, 545, 550, 552, 554, 556, 561,
976 567, 575, 589, 594, 599, 604, 609, 614, 616, 618,
977 623, 628, 628, 629, 629, 630, 630, 631, 631, 632,
978 632, 633, 633, 634, 634, 635, 635, 636, 636, 637,
979 637, 638, 638, 639, 639, 640, 640, 641, 641, 642,
980 642, 646, 646, 647, 647, 648, 648, 649, 649, 650,
981 650, 654, 656, 658, 660, 663, 665, 667, 669, 674,
982 674, 675, 675, 676, 676, 677, 677, 678, 678, 679,
983 679, 680, 680, 681, 681, 682, 682, 689, 691, 696,
984 702, 708, 710, 712, 714, 716, 718, 720, 722, 728,
985 730, 732, 734, 736, 738, 738, 739, 741, 741, 742,
986 744, 744, 745, 753, 764, 766, 771, 773, 778, 780,
987 785, 785, 786, 786, 787, 787, 788, 788, 792, 800,
988 807, 809, 814, 821, 827, 832, 835, 838, 843, 843,
989 844, 844, 845, 845, 846, 846, 847, 847, 852, 857,
990 862, 867, 869, 871, 873, 875, 877, 879, 881, 883,
991 883, 884, 886, 894, 902, 912, 912, 913, 913, 916,
992 916, 917, 917, 920, 920, 921, 921, 922, 922, 923,
993 923, 924, 924, 925, 925, 926, 926, 927, 927, 928,
994 928, 929, 929, 930, 930, 931, 933, 936, 939, 942,
995 945, 948, 951, 954, 958, 961, 965, 968, 971, 974,
996 977, 980, 983, 986, 989, 991, 994, 997, 1000, 1011,
997 1013, 1015, 1017, 1024, 1026, 1034, 1036, 1038, 1044, 1049,
998 1050, 1054, 1055, 1059, 1061, 1066, 1071, 1071, 1073, 1078,
999 1080, 1082, 1089, 1093, 1095, 1097, 1101, 1103, 1105, 1107,
1000 1112, 1112, 1115, 1119, 1119, 1122, 1122, 1128, 1128, 1151,
1001 1152, 1157, 1157, 1165, 1167, 1172, 1176, 1181, 1182, 1185,
1002 1185, 1190, 1191, 1192, 1193, 1194, 1197, 1198, 1199, 1200,
1003 1203, 1204, 1205, 1208, 1209, 1212, 1213
1004 };
1005 #endif
1006
1007 #if YYDEBUG || YYERROR_VERBOSE || 0
1008 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1009 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
1010 static const char *const yytname[] =
1011 {
1012 "$end", "error", "$undefined", "REG", "FLAG", "CREG", "ACC", "DREG",
1013 "DREGH", "DREGL", "DCREG", "EXPR", "UNKNOWN_OPCODE", "IS_OPCODE",
1014 "DOT_S", "DOT_B", "DOT_W", "DOT_L", "DOT_A", "DOT_UB", "DOT_UW", "DOT_D",
1015 "ABS", "ADC", "ADD", "AND_", "BCLR", "BCND", "BFMOV", "BFMOVZ", "BMCND",
1016 "BNOT", "BRA", "BRK", "BSET", "BSR", "BTST", "CLRPSW", "CMP", "DABS",
1017 "DADD", "DBT", "DCMP", "DDIV", "DIV", "DIVU", "DMOV", "DMUL", "DNEG",
1018 "DPOPM", "DPUSHM", "DROUND", "DSQRT", "DSUB", "DTOF", "DTOI", "DTOU",
1019 "EDIV", "EDIVU", "EMACA", "EMSBA", "EMUL", "EMULA", "EMULU", "FADD",
1020 "FCMP", "FDIV", "FMUL", "FREIT", "FSUB", "FSQRT", "FTOD", "FTOI", "FTOU",
1021 "INT", "ITOD", "ITOF", "JMP", "JSR", "MACHI", "MACLH", "MACLO", "MAX",
1022 "MIN", "MOV", "MOVCO", "MOVLI", "MOVU", "MSBHI", "MSBLH", "MSBLO", "MUL",
1023 "MULHI", "MULLH", "MULLO", "MULU", "MVFACHI", "MVFACGU", "MVFACMI",
1024 "MVFACLO", "MVFC", "MVFDC", "MVFDR", "MVTACGU", "MVTACHI", "MVTACLO",
1025 "MVTC", "MVTDC", "MVTIPL", "NEG", "NOP", "NOT", "OR", "POP", "POPC",
1026 "POPM", "PUSH", "PUSHA", "PUSHC", "PUSHM", "RACL", "RACW", "RDACL",
1027 "RDACW", "REIT", "REVL", "REVW", "RMPA", "ROLC", "RORC", "ROTL", "ROTR",
1028 "ROUND", "RSTR", "RTE", "RTFI", "RTS", "RTSD", "SAT", "SATR", "SAVE",
1029 "SBB", "SCCND", "SCMPU", "SETPSW", "SHAR", "SHLL", "SHLR", "SMOVB",
1030 "SMOVF", "SMOVU", "SSTR", "STNZ", "STOP", "STZ", "SUB", "SUNTIL",
1031 "SWHILE", "TST", "UTOD", "UTOF", "WAIT", "XCHG", "XOR", "'#'", "','",
1032 "'['", "']'", "'-'", "'+'", "$accept", "statement", "$@1", "$@2", "$@3",
1033 "$@4", "$@5", "$@6", "$@7", "$@8", "$@9", "$@10", "$@11", "$@12", "$@13",
1034 "$@14", "$@15", "$@16", "$@17", "$@18", "$@19", "$@20", "$@21", "$@22",
1035 "$@23", "$@24", "$@25", "$@26", "$@27", "$@28", "$@29", "$@30", "$@31",
1036 "$@32", "$@33", "$@34", "$@35", "$@36", "$@37", "$@38", "$@39", "$@40",
1037 "$@41", "$@42", "$@43", "$@44", "$@45", "$@46", "$@47", "$@48", "$@49",
1038 "$@50", "$@51", "$@52", "$@53", "$@54", "$@55", "$@56", "$@57", "$@58",
1039 "$@59", "$@60", "op_subadd", "op_dp20_rm_l", "op_dp20_rm", "op_dp20_i",
1040 "op_dp20_rim", "op_dp20_rim_l", "op_dp20_rr", "op_dp20_r", "op_dp20_ri",
1041 "$@61", "op_xchg", "op_shift_rot", "op_shift", "float3_op", "float2_op",
1042 "$@62", "float2_op_ni", "$@63", "$@64", "mvfa_op", "$@65", "op_xor",
1043 "op_bfield", "$@66", "op_save_rstr", "double2_op", "double3_op", "disp",
1044 "flag", "$@67", "memex", "bwl", "bw", "opt_l", "opt_b", YY_NULLPTR
1045 };
1046 #endif
1047
1048 # ifdef YYPRINT
1049 /* YYTOKNUM[NUM] -- (External) token number corresponding to the
1050 (internal) symbol number NUM (which must be that of a token). */
1051 static const yytype_int16 yytoknum[] =
1052 {
1053 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
1054 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
1055 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
1056 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
1057 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
1058 305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
1059 315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
1060 325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
1061 335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
1062 345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
1063 355, 356, 357, 358, 359, 360, 361, 362, 363, 364,
1064 365, 366, 367, 368, 369, 370, 371, 372, 373, 374,
1065 375, 376, 377, 378, 379, 380, 381, 382, 383, 384,
1066 385, 386, 387, 388, 389, 390, 391, 392, 393, 394,
1067 395, 396, 397, 398, 399, 400, 401, 402, 403, 404,
1068 405, 406, 407, 408, 409, 410, 411, 412, 413, 414,
1069 415, 416, 417, 418, 35, 44, 91, 93, 45, 43
1070 };
1071 # endif
1072
1073 #define YYPACT_NINF (-728)
1074
1075 #define yypact_value_is_default(Yyn) \
1076 ((Yyn) == YYPACT_NINF)
1077
1078 #define YYTABLE_NINF (-324)
1079
1080 #define yytable_value_is_error(Yyn) \
1081 0
1082
1083 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1084 STATE-NUM. */
1085 static const yytype_int16 yypact[] =
1086 {
1087 323, -728, -728, -728, -136, -129, 2, 116, -728, -728,
1088 -120, 29, 127, -728, 31, 136, 33, -728, 12, -728,
1089 -728, -728, 45, -728, -728, -728, 170, -728, -728, 183,
1090 193, -728, -728, -728, -728, -728, -728, 66, 77, -118,
1091 79, -98, -728, -728, -728, -728, -728, -728, 110, -728,
1092 -728, -30, 143, -728, 155, 158, 191, 210, 221, -728,
1093 -728, 41, 244, 85, 34, 249, 250, 251, 99, 252,
1094 253, 254, 255, -728, 256, 257, 259, 258, -728, 262,
1095 263, 264, 35, 266, 112, -728, -728, -728, 113, 268,
1096 269, 270, 162, 273, 272, 115, 118, 119, 120, -728,
1097 -728, 162, 277, 282, 124, 128, -728, -728, -728, -728,
1098 -728, 129, 286, -728, -728, 130, 227, -728, -728, -728,
1099 -728, -728, -728, -728, -728, 162, -728, -728, 131, 162,
1100 162, -728, 287, -728, -728, -728, -728, 261, 288, 19,
1101 285, 64, 289, 64, 132, 290, -728, 291, 292, 294,
1102 -728, -728, 295, 133, 296, -728, 297, 298, 299, -728,
1103 300, 309, 134, 303, -728, 304, 305, 314, 153, 308,
1104 -728, 317, 157, -728, 312, 160, 320, 321, 159, 321,
1105 22, 22, 18, 6, 321, 320, 319, 324, 322, 326,
1106 320, 320, 321, 320, 320, 320, 165, 169, 172, 91,
1107 173, 172, 91, 26, 37, 37, 26, 26, 334, 174,
1108 334, 334, 329, 176, 91, -728, -728, 177, 178, 179,
1109 22, 22, 216, 276, 283, 380, 5, 311, 415, -728,
1110 -728, 7, 327, 330, 332, 476, 64, 333, 335, 336,
1111 -728, -728, -728, -728, -728, -728, -728, 337, 338, 339,
1112 340, 341, 342, 478, 343, 480, 288, 288, 483, 64,
1113 -728, -728, 344, -728, -728, -728, 92, -728, 346, 498,
1114 499, 500, 504, 513, 513, -728, -728, -728, 506, 513,
1115 507, 513, 334, 38, 508, -728, 38, 509, 93, 518,
1116 511, -728, 39, 39, 39, -728, 172, 172, 512, 64,
1117 -728, -728, 22, 359, 91, 91, 28, -728, 360, -728,
1118 361, 516, -728, -728, -728, 362, 364, 365, -728, 366,
1119 368, -728, 94, 369, -728, -728, -728, -728, 367, -728,
1120 370, 95, 371, -728, -728, -728, -728, -728, 96, 372,
1121 -728, -728, -728, 97, 373, -728, 536, 375, 538, 377,
1122 -728, 378, -728, 537, -728, 381, -728, -728, -728, 379,
1123 -728, 382, 383, 384, 539, 386, 387, 542, 551, 389,
1124 -728, -728, 388, 390, 391, 392, -728, -728, -728, -728,
1125 -728, -728, 554, 558, -728, 397, -728, 398, 560, -728,
1126 -728, 400, 555, -728, 401, -728, 404, -728, 566, 511,
1127 -728, -728, -728, -728, 563, -728, -728, -728, 564, -728,
1128 569, 570, 571, -728, -728, 565, 567, 568, 410, 412,
1129 414, -1, 416, 417, 418, 419, 0, 578, 583, 584,
1130 423, -728, 586, 587, 588, -728, 428, -728, -728, -728,
1131 590, 591, 589, 592, 593, 595, 431, 594, -728, -728,
1132 -728, 432, -728, 598, -728, 436, 600, 440, 441, 442,
1133 443, 444, -728, -728, 445, -728, 446, -728, -728, -728,
1134 601, -728, 448, -728, 449, -728, -728, 450, 604, -728,
1135 -728, -728, -728, -728, -728, 614, -728, 453, -728, -728,
1136 612, -728, -728, 455, -728, -728, 618, 619, 458, 621,
1137 622, 623, 624, 625, -728, 463, 98, 620, 107, -728,
1138 464, 108, -728, 466, 109, -728, 467, 111, -728, 631,
1139 468, 629, 630, -728, 635, 636, 231, 637, 638, 477,
1140 642, 40, 479, 484, 640, 643, 639, 644, 645, 490,
1141 491, 654, 655, 494, 657, 496, 659, 634, 501, 497,
1142 -728, -728, 502, 503, 505, 510, 514, 515, 661, 8,
1143 662, 62, 666, 668, 517, 669, 670, 63, 671, 519,
1144 520, 521, 673, 522, 523, 524, 667, -728, -728, -728,
1145 -728, -728, -728, 672, -728, 678, -728, 680, -728, 684,
1146 685, 686, 687, 691, 692, 693, -728, 695, 696, 697,
1147 540, 541, -728, 698, -728, 699, -728, -728, 700, 543,
1148 544, 546, 545, -728, 701, -728, 547, 549, -728, 550,
1149 704, -728, 552, 705, -728, 553, 712, -728, 556, -728,
1150 140, -728, 559, -728, 561, -728, -728, -728, -728, 237,
1151 -728, -728, 714, 557, 713, 562, 572, -728, -728, -728,
1152 -728, 719, 720, -728, 573, 723, 576, 717, 575, 579,
1153 727, 728, 729, 730, 731, -4, 32, 9, -728, -728,
1154 577, 1, 581, 735, 580, 582, 585, 596, 743, -728,
1155 597, 747, 602, 599, 603, 745, 748, 749, -728, 750,
1156 751, 752, 606, -728, -728, 605, -728, -728, -728, -728,
1157 -728, -728, -728, 607, -728, 609, 756, 757, -728, 608,
1158 -728, 245, 758, 759, 192, 610, 762, 615, 765, 611,
1159 766, 613, 771, 616, 778, -728, -728, -728, 617, -728,
1160 626, 726, 200, -728, -728, 627, 781, -728, 746, 628,
1161 -728, -728, 206, -728, 782, -728, 245, 783, -728, 632,
1162 -728, -728, -728, 784, 641, 785, 646, -728, 786, 647,
1163 787, 68, 789, 633, 648, 125, 649, 651, -728, -728,
1164 652, 653, 792, 656, 658, -728, -728, -728, -728, -728,
1165 -728, 790, -728, 794, -728, 660, -728, 797, 663, -728,
1166 -728, 664, 665, 791, 674, 793, 675, 791, 676, 791,
1167 677, 791, 679, 798, 799, -728, 682, 683, -728, 688,
1168 -728, 801, 689, 694, -728, 702, -728, 245, 690, 802,
1169 703, 806, 706, 807, 707, 815, -728, 708, 709, 126,
1170 715, -728, 711, 816, 819, 821, 716, -728, 823, 824,
1171 718, -728, 828, -728, 829, 830, 831, -728, -728, 820,
1172 721, 791, -728, 791, -728, 822, -728, 825, -728, -728,
1173 833, 835, -728, -728, 836, 842, 846, 722, -728, 724,
1174 -728, 725, -728, 732, -728, 733, -728, -728, -728, 736,
1175 847, 848, -728, -728, -728, 849, -728, -728, 850, -728,
1176 -728, -728, -728, -728, 734, -728, -728, -728, -728, -728,
1177 -728, -728, -728, -728, 853, -728, -728, -728, -728, 855,
1178 -728, 737, -728, -728, 851, -728, 738, -728, 741, -728,
1179 857, 742, 858, -728
1180 };
1181
1182 /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
1183 Performed when YYTABLE does not specify something else to do. Zero
1184 means the default is an error. */
1185 static const yytype_int16 yydefact[] =
1186 {
1187 0, 2, 97, 95, 210, 214, 0, 0, 235, 237,
1188 0, 0, 353, 3, 0, 353, 0, 339, 337, 243,
1189 257, 4, 0, 259, 107, 109, 0, 261, 245, 0,
1190 0, 247, 249, 263, 251, 253, 255, 0, 0, 121,
1191 0, 123, 143, 141, 147, 145, 139, 149, 0, 151,
1192 153, 0, 0, 127, 0, 0, 0, 0, 0, 99,
1193 101, 346, 0, 0, 350, 0, 0, 0, 212, 0,
1194 0, 0, 174, 229, 177, 180, 0, 0, 284, 0,
1195 0, 0, 0, 0, 0, 93, 6, 115, 216, 0,
1196 0, 0, 346, 0, 0, 0, 0, 0, 0, 196,
1197 194, 346, 0, 0, 190, 192, 155, 239, 76, 75,
1198 5, 0, 0, 78, 241, 91, 346, 67, 339, 43,
1199 45, 41, 69, 70, 68, 346, 119, 117, 208, 346,
1200 346, 111, 0, 129, 77, 125, 113, 0, 0, 337,
1201 0, 337, 0, 337, 0, 0, 18, 0, 0, 0,
1202 331, 331, 0, 0, 0, 7, 0, 0, 0, 354,
1203 0, 0, 0, 0, 10, 0, 0, 0, 0, 0,
1204 62, 0, 0, 338, 0, 0, 0, 0, 0, 0,
1205 337, 337, 0, 0, 0, 0, 0, 0, 0, 0,
1206 0, 0, 0, 0, 0, 0, 0, 0, 0, 337,
1207 0, 0, 337, 337, 325, 325, 337, 337, 325, 0,
1208 325, 325, 0, 0, 337, 63, 64, 0, 0, 0,
1209 337, 337, 347, 348, 349, 0, 0, 0, 0, 351,
1210 352, 0, 0, 0, 0, 0, 337, 0, 0, 0,
1211 173, 327, 327, 176, 327, 179, 327, 0, 0, 0,
1212 169, 171, 0, 0, 0, 0, 0, 0, 0, 337,
1213 58, 60, 0, 347, 348, 349, 337, 59, 0, 0,
1214 0, 0, 0, 0, 0, 74, 56, 55, 0, 0,
1215 0, 0, 325, 0, 0, 54, 0, 0, 337, 349,
1216 337, 61, 0, 0, 0, 73, 306, 306, 0, 337,
1217 71, 72, 337, 0, 337, 337, 337, 1, 304, 98,
1218 0, 0, 301, 302, 96, 0, 0, 0, 211, 0,
1219 0, 215, 337, 0, 12, 13, 17, 236, 0, 238,
1220 0, 337, 0, 9, 14, 15, 8, 65, 337, 0,
1221 16, 11, 66, 337, 0, 340, 0, 0, 0, 0,
1222 244, 0, 258, 0, 260, 0, 299, 300, 108, 0,
1223 110, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1224 262, 246, 0, 0, 0, 0, 248, 250, 264, 252,
1225 254, 256, 0, 0, 104, 0, 122, 0, 0, 106,
1226 124, 0, 0, 144, 0, 142, 0, 322, 0, 337,
1227 148, 146, 140, 150, 0, 152, 154, 50, 0, 128,
1228 0, 0, 0, 100, 102, 0, 0, 0, 0, 0,
1229 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1230 0, 213, 0, 0, 0, 175, 0, 230, 178, 181,
1231 0, 0, 0, 0, 0, 0, 0, 0, 79, 94,
1232 116, 0, 217, 0, 57, 0, 0, 0, 182, 0,
1233 0, 0, 197, 195, 0, 191, 0, 193, 156, 334,
1234 0, 240, 40, 242, 0, 92, 157, 0, 0, 315,
1235 44, 46, 42, 308, 120, 0, 118, 0, 209, 112,
1236 0, 130, 126, 0, 329, 114, 0, 0, 0, 0,
1237 0, 0, 0, 0, 132, 0, 337, 0, 337, 134,
1238 0, 337, 131, 0, 337, 133, 0, 337, 26, 0,
1239 0, 0, 0, 265, 0, 0, 0, 0, 0, 0,
1240 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1241 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1242 286, 287, 165, 0, 167, 0, 0, 0, 0, 0,
1243 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1244 0, 0, 0, 161, 0, 163, 0, 199, 283, 231,
1245 170, 172, 198, 0, 285, 0, 48, 0, 47, 0,
1246 0, 0, 0, 0, 0, 0, 333, 0, 0, 0,
1247 0, 0, 307, 0, 288, 0, 303, 293, 0, 0,
1248 34, 289, 0, 36, 0, 52, 0, 0, 203, 0,
1249 0, 204, 0, 0, 51, 0, 0, 53, 0, 33,
1250 343, 335, 0, 295, 0, 267, 268, 269, 270, 0,
1251 266, 271, 0, 0, 0, 0, 0, 280, 279, 282,
1252 281, 0, 0, 309, 0, 0, 317, 0, 0, 0,
1253 0, 0, 0, 0, 0, 0, 0, 0, 39, 85,
1254 0, 0, 0, 0, 0, 0, 0, 0, 0, 29,
1255 0, 0, 0, 0, 0, 0, 0, 0, 35, 0,
1256 0, 0, 0, 202, 37, 0, 232, 183, 233, 234,
1257 312, 200, 201, 0, 218, 0, 0, 0, 32, 295,
1258 298, 353, 0, 0, 343, 0, 0, 0, 0, 0,
1259 0, 0, 0, 0, 0, 341, 342, 344, 0, 345,
1260 0, 0, 343, 277, 278, 0, 0, 276, 0, 0,
1261 221, 222, 343, 223, 0, 316, 353, 0, 324, 0,
1262 166, 224, 168, 0, 0, 0, 0, 38, 0, 0,
1263 0, 0, 0, 0, 0, 337, 0, 0, 219, 220,
1264 0, 0, 0, 0, 0, 225, 226, 227, 162, 228,
1265 164, 0, 90, 0, 158, 313, 305, 0, 0, 49,
1266 292, 0, 0, 355, 0, 0, 0, 355, 0, 355,
1267 0, 355, 0, 0, 0, 336, 0, 0, 272, 0,
1268 274, 0, 0, 0, 319, 0, 321, 353, 0, 0,
1269 0, 0, 0, 0, 0, 0, 82, 0, 0, 337,
1270 0, 86, 0, 0, 0, 0, 0, 30, 0, 0,
1271 0, 25, 0, 330, 0, 0, 0, 356, 136, 0,
1272 0, 355, 138, 355, 135, 0, 137, 0, 27, 28,
1273 0, 0, 273, 275, 0, 0, 0, 0, 19, 0,
1274 20, 0, 21, 0, 80, 0, 184, 185, 81, 0,
1275 0, 0, 186, 187, 31, 0, 188, 189, 0, 314,
1276 294, 290, 291, 88, 0, 159, 160, 87, 89, 296,
1277 297, 310, 311, 318, 0, 22, 23, 24, 205, 0,
1278 206, 0, 207, 328, 0, 326, 0, 83, 0, 84,
1279 0, 0, 0, 332
1280 };
1281
1282 /* YYPGOTO[NTERM-NUM]. */
1283 static const yytype_int16 yypgoto[] =
1284 {
1285 -728, -728, -728, -728, -728, -728, -728, -728, -728, -728,
1286 -728, -728, -728, -728, -728, -728, -728, -728, -728, -728,
1287 -728, -728, -728, -728, -728, -728, -728, -728, -728, -728,
1288 -728, -728, -728, -728, -728, -728, -728, -728, -728, -728,
1289 -728, -728, -728, -728, -728, -728, -728, -728, -728, -728,
1290 -728, -728, -728, -728, -728, -728, -728, -728, -728, -728,
1291 -728, -728, -119, 650, -728, -133, -167, -728, -141, -728,
1292 437, -728, -154, -196, -145, 43, 710, -728, -149, -728,
1293 -728, -8, -728, -728, 739, -728, 681, -104, -108, -18,
1294 753, -728, -669, -37, -728, -14, -727
1295 };
1296
1297 /* YYDEFGOTO[NTERM-NUM]. */
1298 static const yytype_int16 yydefgoto[] =
1299 {
1300 -1, 137, 294, 292, 293, 288, 256, 139, 138, 220,
1301 221, 198, 201, 180, 181, 302, 306, 257, 297, 296,
1302 199, 202, 305, 214, 304, 207, 204, 203, 206, 205,
1303 208, 210, 211, 282, 241, 244, 246, 279, 281, 274,
1304 273, 299, 141, 236, 143, 259, 242, 150, 151, 283,
1305 286, 176, 185, 190, 191, 193, 194, 195, 177, 179,
1306 184, 192, 318, 312, 356, 357, 358, 314, 309, 602,
1307 484, 485, 386, 479, 480, 393, 395, 396, 397, 398,
1308 399, 435, 436, 495, 327, 328, 471, 350, 352, 359,
1309 170, 171, 730, 226, 231, 161, 848
1310 };
1311
1312 /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
1313 positive, shift that token. If negative, reduce the rule whose
1314 number is the opposite. If YYTABLE_NINF, syntax error. */
1315 static const yytype_int16 yytable[] =
1316 {
1317 175, 167, 561, 567, 761, 144, 313, 173, 419, 365,
1318 424, 669, 757, 366, 360, 172, 420, 173, 425, 670,
1319 173, 361, 310, 173, 321, 355, 362, 363, 140, 391,
1320 173, 493, 153, 173, 162, 142, 168, 173, 252, 173,
1321 -323, 469, 461, 173, 152, 792, -103, 641, 390, 229,
1322 230, 173, 178, 413, 414, 266, 222, 223, 224, 403,
1323 409, 405, 406, 807, 275, 384, -105, 317, 389, 196,
1324 852, 354, 854, 813, 856, 173, 370, 462, 463, 290,
1325 197, 371, 200, 465, 378, 467, 376, 377, 295, 379,
1326 380, 381, 300, 301, 385, 454, 310, 504, 509, 512,
1327 515, 615, 173, 173, 173, 173, 173, 173, 173, 173,
1328 618, 621, 624, 209, 627, 449, 450, 431, 173, 173,
1329 173, 315, 173, 319, 895, 319, 896, 146, 831, 878,
1330 147, 148, 149, 468, 212, 489, 173, 173, 155, 494,
1331 452, 156, 157, 158, 159, 160, 213, 164, 481, 482,
1332 491, 492, 165, 159, 166, 725, 726, 727, 215, 728,
1333 729, 216, 753, 483, 483, 369, 145, 562, 568, 762,
1334 367, 421, 368, 426, 671, 758, 174, 263, 264, 265,
1335 488, 387, 364, 311, 387, 394, 311, 182, 394, 394,
1336 392, 183, 311, 154, 217, 163, 387, 169, 755, 253,
1337 186, -320, 470, 478, 187, 225, 642, 725, 726, 727,
1338 188, 791, 729, 218, 189, 725, 726, 727, 319, 806,
1339 729, 725, 726, 727, 219, 812, 729, 673, 681, 674,
1340 682, 675, 683, 825, 437, 826, 438, 827, 439, 635,
1341 636, 319, 263, 264, 289, 733, 734, 227, 455, 401,
1342 402, 228, 232, 233, 234, 237, 238, 239, 240, 243,
1343 245, 307, 159, 235, 247, 249, 250, 251, 248, 254,
1344 315, 260, 477, 262, 261, 268, 255, 258, 267, 269,
1345 276, 319, 270, 271, 272, 277, 387, 387, 278, 285,
1346 303, 308, 280, 284, 287, 298, 316, 322, 331, 338,
1347 320, 323, 324, 325, 505, 326, 330, 332, 333, 334,
1348 335, 336, 337, 510, 339, 340, 341, 342, 343, 344,
1349 513, 345, 346, 347, 353, 516, 348, 349, 351, 372,
1350 382, 373, 374, 375, 383, 1, 311, -323, 388, 404,
1351 407, 408, 410, 411, 412, 2, 3, 4, 5, 6,
1352 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
1353 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
1354 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
1355 415, 549, 37, 38, 39, 40, 41, 42, 43, 44,
1356 45, 418, 46, 47, 48, 49, 50, 51, 52, 53,
1357 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1358 64, 65, 66, 67, 68, 69, 70, 71, 423, 72,
1359 73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
1360 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
1361 416, 93, 94, 95, 96, 97, 98, 417, 99, 100,
1362 101, 102, 103, 104, 105, 106, 107, 108, 109, 110,
1363 111, 112, 113, 114, 115, 116, 117, 118, 119, 120,
1364 121, 122, 123, 124, 125, 126, 422, 127, 128, 129,
1365 130, 131, 132, 133, 134, 135, 136, 430, 616, 446,
1366 619, 448, 427, 622, 451, 428, 625, 429, 432, 628,
1367 433, 434, 440, 441, 442, 443, 444, 445, 447, 457,
1368 458, 459, 453, 643, 456, 460, 461, 464, 466, 472,
1369 474, 476, 173, 487, 490, 496, 497, 498, 499, 500,
1370 501, 507, 502, 503, 506, 508, 511, 514, 517, 518,
1371 519, 520, 521, 522, 523, 525, 524, 526, 527, 528,
1372 529, 530, 531, 532, 533, 534, 535, 539, 536, 537,
1373 538, 540, 541, 543, 542, 544, 545, 546, 547, 548,
1374 550, 551, 552, 553, 554, 558, 555, 559, 556, 557,
1375 560, 569, 563, 565, 564, 566, 570, 571, 572, 573,
1376 574, 575, 576, 577, 578, 579, 583, 585, 580, 581,
1377 582, 586, 587, 588, 584, 589, 590, 591, 592, 593,
1378 594, 595, 596, 597, 598, 600, 599, 601, 603, 604,
1379 605, 606, 607, 608, 609, 610, 611, 612, 613, 614,
1380 620, 617, 623, 626, 629, 630, 631, 632, 633, 634,
1381 637, 638, 639, 646, 644, 659, 648, 754, 756, 759,
1382 640, 645, 650, 647, 649, 651, 652, 653, 654, 655,
1383 656, 657, 658, 661, 668, 672, 660, 662, 663, 676,
1384 664, 677, 679, 680, 684, 665, 688, 693, 692, 666,
1385 667, 694, 678, 695, 685, 686, 687, 689, 690, 691,
1386 696, 697, 698, 699, 700, 701, 702, 788, 703, 704,
1387 705, 708, 709, 710, 715, 706, 707, 719, 721, 712,
1388 711, 713, 714, 716, 717, 723, 718, 735, 720, 722,
1389 745, 737, 724, 736, 731, 740, 741, 738, 732, 743,
1390 748, 749, 815, 805, 486, 750, 751, 752, 764, 739,
1391 742, 744, 746, 760, 747, 765, 769, 832, 763, 766,
1392 771, 775, 767, 810, 776, 777, 778, 779, 780, 785,
1393 786, 789, 790, 768, 770, 794, 773, 772, 796, 798,
1394 774, 781, 782, 787, 800, 783, 784, 793, 797, 795,
1395 799, 802, 803, 801, 809, 814, 816, 818, 820, 822,
1396 824, 804, 828, 811, 808, 837, 840, 841, 829, 817,
1397 843, 858, 859, 867, 850, 869, 847, 819, 863, 871,
1398 873, 879, 821, 823, 833, 830, 834, 835, 875, 882,
1399 836, 838, 883, 839, 884, 842, 886, 887, 844, 845,
1400 846, 889, 890, 891, 892, 893, 899, 897, 900, 901,
1401 898, 849, 851, 853, 855, 902, 857, 860, 861, 903,
1402 910, 911, 912, 913, 864, 862, 915, 868, 916, 865,
1403 921, 923, 918, 0, 0, 0, 0, 866, 0, 0,
1404 870, 291, 0, 872, 874, 876, 877, 881, 0, 0,
1405 880, 885, 0, 888, 0, 0, 894, 904, 0, 0,
1406 329, 905, 906, 0, 0, 0, 0, 0, 914, 907,
1407 908, 0, 909, 0, 917, 919, 920, 922, 0, 0,
1408 0, 0, 0, 0, 0, 400, 0, 0, 0, 0,
1409 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1410 0, 0, 0, 0, 0, 0, 0, 0, 475, 0,
1411 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1412 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1413 0, 0, 0, 0, 0, 0, 0, 473
1414 };
1415
1416 static const yytype_int16 yycheck[] =
1417 {
1418 18, 15, 3, 3, 3, 3, 139, 11, 3, 3,
1419 3, 3, 3, 7, 181, 3, 11, 11, 11, 11,
1420 11, 3, 3, 11, 143, 3, 8, 9, 164, 3,
1421 11, 3, 3, 11, 3, 164, 3, 11, 3, 11,
1422 3, 3, 3, 11, 164, 714, 164, 7, 202, 15,
1423 16, 11, 7, 220, 221, 92, 15, 16, 17, 208,
1424 214, 210, 211, 732, 101, 198, 164, 3, 201, 3,
1425 797, 179, 799, 742, 801, 11, 184, 273, 274, 116,
1426 3, 185, 3, 279, 192, 281, 190, 191, 125, 193,
1427 194, 195, 129, 130, 3, 3, 3, 3, 3, 3,
1428 3, 3, 11, 11, 11, 11, 11, 11, 11, 11,
1429 3, 3, 3, 3, 3, 256, 257, 236, 11, 11,
1430 11, 139, 11, 141, 851, 143, 853, 11, 3, 3,
1431 14, 15, 16, 282, 164, 302, 11, 11, 11, 306,
1432 259, 14, 15, 16, 17, 18, 3, 11, 293, 294,
1433 304, 305, 16, 17, 18, 15, 16, 17, 3, 19,
1434 20, 3, 166, 296, 297, 183, 164, 168, 168, 168,
1435 164, 166, 166, 166, 166, 166, 164, 15, 16, 17,
1436 299, 199, 164, 164, 202, 203, 164, 17, 206, 207,
1437 164, 21, 164, 164, 3, 164, 214, 164, 166, 164,
1438 17, 164, 164, 164, 21, 164, 166, 15, 16, 17,
1439 17, 19, 20, 3, 21, 15, 16, 17, 236, 19,
1440 20, 15, 16, 17, 3, 19, 20, 165, 165, 167,
1441 167, 169, 169, 165, 242, 167, 244, 169, 246, 8,
1442 9, 259, 15, 16, 17, 8, 9, 3, 266, 206,
1443 207, 166, 3, 3, 3, 3, 3, 3, 3, 3,
1444 3, 0, 17, 164, 5, 3, 3, 3, 10, 3,
1445 288, 3, 290, 3, 5, 3, 164, 164, 5, 164,
1446 3, 299, 164, 164, 164, 3, 304, 305, 164, 3,
1447 3, 3, 164, 164, 164, 164, 11, 165, 165, 165,
1448 11, 11, 11, 11, 322, 11, 11, 11, 11, 11,
1449 11, 11, 3, 331, 11, 11, 11, 3, 165, 11,
1450 338, 4, 165, 11, 165, 343, 166, 7, 7, 10,
1451 165, 7, 10, 7, 165, 12, 164, 3, 165, 165,
1452 11, 165, 165, 165, 165, 22, 23, 24, 25, 26,
1453 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
1454 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
1455 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
1456 164, 399, 59, 60, 61, 62, 63, 64, 65, 66,
1457 67, 11, 69, 70, 71, 72, 73, 74, 75, 76,
1458 77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
1459 87, 88, 89, 90, 91, 92, 93, 94, 3, 96,
1460 97, 98, 99, 100, 101, 102, 103, 104, 105, 106,
1461 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
1462 164, 118, 119, 120, 121, 122, 123, 164, 125, 126,
1463 127, 128, 129, 130, 131, 132, 133, 134, 135, 136,
1464 137, 138, 139, 140, 141, 142, 143, 144, 145, 146,
1465 147, 148, 149, 150, 151, 152, 165, 154, 155, 156,
1466 157, 158, 159, 160, 161, 162, 163, 11, 506, 11,
1467 508, 11, 165, 511, 11, 165, 514, 165, 165, 517,
1468 165, 165, 165, 165, 165, 165, 165, 165, 165, 11,
1469 11, 11, 168, 531, 168, 11, 3, 11, 11, 11,
1470 11, 3, 11, 11, 165, 165, 165, 11, 166, 165,
1471 165, 164, 166, 165, 165, 165, 165, 165, 165, 3,
1472 165, 3, 165, 165, 7, 166, 165, 165, 165, 165,
1473 11, 165, 165, 11, 3, 166, 168, 3, 168, 168,
1474 168, 3, 165, 3, 166, 165, 11, 166, 164, 3,
1475 7, 7, 3, 3, 3, 165, 11, 165, 11, 11,
1476 166, 3, 166, 165, 167, 166, 3, 3, 165, 3,
1477 3, 3, 164, 3, 3, 6, 165, 165, 6, 6,
1478 5, 3, 166, 3, 10, 165, 165, 165, 165, 165,
1479 165, 165, 11, 165, 165, 11, 166, 3, 165, 7,
1480 165, 3, 3, 165, 3, 3, 3, 3, 3, 166,
1481 166, 11, 166, 166, 3, 167, 7, 7, 3, 3,
1482 3, 3, 165, 3, 165, 11, 7, 665, 666, 667,
1483 8, 167, 7, 10, 10, 165, 165, 3, 3, 165,
1484 3, 165, 3, 166, 3, 3, 165, 165, 165, 3,
1485 165, 3, 3, 3, 3, 165, 3, 5, 11, 165,
1486 165, 3, 165, 3, 165, 165, 165, 165, 165, 165,
1487 6, 6, 6, 6, 3, 3, 3, 711, 3, 3,
1488 3, 3, 3, 3, 3, 165, 165, 3, 3, 165,
1489 167, 165, 167, 166, 165, 3, 166, 3, 166, 166,
1490 3, 8, 166, 166, 165, 6, 6, 165, 167, 6,
1491 3, 3, 746, 7, 297, 6, 6, 6, 3, 167,
1492 167, 165, 167, 166, 165, 165, 3, 765, 167, 167,
1493 3, 6, 167, 7, 6, 6, 6, 6, 6, 3,
1494 3, 3, 3, 167, 167, 3, 167, 165, 3, 3,
1495 167, 165, 167, 165, 3, 168, 167, 167, 167, 164,
1496 167, 3, 165, 167, 3, 3, 3, 3, 3, 3,
1497 3, 165, 3, 165, 167, 3, 6, 3, 165, 167,
1498 3, 3, 3, 817, 11, 3, 15, 166, 7, 3,
1499 3, 829, 166, 166, 165, 167, 165, 165, 3, 3,
1500 167, 165, 3, 165, 3, 165, 3, 3, 165, 165,
1501 165, 3, 3, 3, 3, 15, 3, 15, 3, 3,
1502 15, 167, 167, 167, 167, 3, 167, 165, 165, 3,
1503 3, 3, 3, 3, 165, 167, 3, 167, 3, 165,
1504 3, 3, 11, -1, -1, -1, -1, 165, -1, -1,
1505 167, 118, -1, 167, 167, 167, 167, 166, -1, -1,
1506 165, 165, -1, 165, -1, -1, 165, 165, -1, -1,
1507 151, 167, 167, -1, -1, -1, -1, -1, 164, 167,
1508 167, -1, 166, -1, 167, 167, 165, 165, -1, -1,
1509 -1, -1, -1, -1, -1, 205, -1, -1, -1, -1,
1510 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1511 -1, -1, -1, -1, -1, -1, -1, -1, 288, -1,
1512 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1513 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1514 -1, -1, -1, -1, -1, -1, -1, 286
1515 };
1516
1517 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1518 symbol of state STATE-NUM. */
1519 static const yytype_int16 yystos[] =
1520 {
1521 0, 12, 22, 23, 24, 25, 26, 27, 28, 29,
1522 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
1523 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
1524 50, 51, 52, 53, 54, 55, 56, 59, 60, 61,
1525 62, 63, 64, 65, 66, 67, 69, 70, 71, 72,
1526 73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
1527 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
1528 93, 94, 96, 97, 98, 99, 100, 101, 102, 103,
1529 104, 105, 106, 107, 108, 109, 110, 111, 112, 113,
1530 114, 115, 116, 118, 119, 120, 121, 122, 123, 125,
1531 126, 127, 128, 129, 130, 131, 132, 133, 134, 135,
1532 136, 137, 138, 139, 140, 141, 142, 143, 144, 145,
1533 146, 147, 148, 149, 150, 151, 152, 154, 155, 156,
1534 157, 158, 159, 160, 161, 162, 163, 171, 178, 177,
1535 164, 212, 164, 214, 3, 164, 11, 14, 15, 16,
1536 217, 218, 164, 3, 164, 11, 14, 15, 16, 17,
1537 18, 265, 3, 164, 11, 16, 18, 265, 3, 164,
1538 260, 261, 3, 11, 164, 259, 221, 228, 7, 229,
1539 183, 184, 17, 21, 230, 222, 17, 21, 17, 21,
1540 223, 224, 231, 225, 226, 227, 3, 3, 181, 190,
1541 3, 182, 191, 197, 196, 199, 198, 195, 200, 3,
1542 201, 202, 164, 3, 193, 3, 3, 3, 3, 3,
1543 179, 180, 15, 16, 17, 164, 263, 3, 166, 15,
1544 16, 264, 3, 3, 3, 164, 213, 3, 3, 3,
1545 3, 204, 216, 3, 205, 3, 206, 5, 10, 3,
1546 3, 3, 3, 164, 3, 164, 176, 187, 164, 215,
1547 3, 5, 3, 15, 16, 17, 263, 5, 3, 164,
1548 164, 164, 164, 210, 209, 263, 3, 3, 164, 207,
1549 164, 208, 203, 219, 164, 3, 220, 164, 175, 17,
1550 263, 260, 173, 174, 172, 263, 189, 188, 164, 211,
1551 263, 263, 185, 3, 194, 192, 186, 0, 3, 238,
1552 3, 164, 233, 235, 237, 259, 11, 3, 232, 259,
1553 11, 232, 165, 11, 11, 11, 11, 254, 255, 254,
1554 11, 165, 11, 11, 11, 11, 11, 3, 165, 11,
1555 11, 11, 3, 165, 11, 4, 165, 11, 166, 7,
1556 257, 7, 258, 165, 258, 3, 234, 235, 236, 259,
1557 236, 3, 8, 9, 164, 3, 7, 164, 166, 259,
1558 258, 257, 10, 7, 10, 7, 257, 257, 258, 257,
1559 257, 257, 165, 165, 235, 3, 242, 259, 165, 235,
1560 242, 3, 164, 245, 259, 246, 247, 248, 249, 250,
1561 246, 245, 245, 248, 165, 248, 248, 11, 165, 242,
1562 165, 165, 165, 236, 236, 164, 164, 164, 11, 3,
1563 11, 166, 165, 3, 3, 11, 166, 165, 165, 165,
1564 11, 232, 165, 165, 165, 251, 252, 251, 251, 251,
1565 165, 165, 165, 165, 165, 165, 11, 165, 11, 238,
1566 238, 11, 232, 168, 3, 259, 168, 11, 11, 11,
1567 11, 3, 243, 243, 11, 243, 11, 243, 248, 3,
1568 164, 256, 11, 256, 11, 233, 3, 259, 164, 243,
1569 244, 244, 244, 235, 240, 241, 240, 11, 232, 236,
1570 165, 242, 242, 3, 236, 253, 165, 165, 11, 166,
1571 165, 165, 166, 165, 3, 259, 165, 164, 165, 3,
1572 259, 165, 3, 259, 165, 3, 259, 165, 3, 165,
1573 3, 165, 165, 7, 165, 166, 165, 165, 165, 11,
1574 165, 165, 11, 3, 166, 168, 168, 168, 168, 3,
1575 3, 165, 166, 3, 165, 11, 166, 164, 3, 259,
1576 7, 7, 3, 3, 3, 11, 11, 11, 165, 165,
1577 166, 3, 168, 166, 167, 165, 166, 3, 168, 3,
1578 3, 3, 165, 3, 3, 3, 164, 3, 3, 6,
1579 6, 6, 5, 165, 10, 165, 3, 166, 3, 165,
1580 165, 165, 165, 165, 165, 165, 11, 165, 165, 166,
1581 11, 3, 239, 165, 7, 165, 3, 3, 165, 3,
1582 3, 3, 3, 3, 166, 3, 259, 11, 3, 259,
1583 166, 3, 259, 166, 3, 259, 166, 3, 259, 3,
1584 167, 7, 7, 3, 3, 8, 9, 3, 3, 165,
1585 8, 7, 166, 259, 165, 167, 3, 10, 7, 10,
1586 7, 165, 165, 3, 3, 165, 3, 165, 3, 11,
1587 165, 166, 165, 165, 165, 165, 165, 165, 3, 3,
1588 11, 166, 3, 165, 167, 169, 3, 3, 165, 3,
1589 3, 165, 167, 169, 3, 165, 165, 165, 3, 165,
1590 165, 165, 11, 5, 3, 3, 6, 6, 6, 6,
1591 3, 3, 3, 3, 3, 3, 165, 165, 3, 3,
1592 3, 167, 165, 165, 167, 3, 166, 165, 166, 3,
1593 166, 3, 166, 3, 166, 15, 16, 17, 19, 20,
1594 262, 165, 167, 8, 9, 3, 166, 8, 165, 167,
1595 6, 6, 167, 6, 165, 3, 167, 165, 3, 3,
1596 6, 6, 6, 166, 259, 166, 259, 3, 166, 259,
1597 166, 3, 168, 167, 3, 165, 167, 167, 167, 3,
1598 167, 3, 165, 167, 167, 6, 6, 6, 6, 6,
1599 6, 165, 167, 168, 167, 3, 3, 165, 265, 3,
1600 3, 19, 262, 167, 3, 164, 3, 167, 3, 167,
1601 3, 167, 3, 165, 165, 7, 19, 262, 167, 3,
1602 7, 165, 19, 262, 3, 265, 3, 167, 3, 166,
1603 3, 166, 3, 166, 3, 165, 167, 169, 3, 165,
1604 167, 3, 259, 165, 165, 165, 167, 3, 165, 165,
1605 6, 3, 165, 3, 165, 165, 165, 15, 266, 167,
1606 11, 167, 266, 167, 266, 167, 266, 167, 3, 3,
1607 165, 165, 167, 7, 165, 165, 165, 265, 167, 3,
1608 167, 3, 167, 3, 167, 3, 167, 167, 3, 259,
1609 165, 166, 3, 3, 3, 165, 3, 3, 165, 3,
1610 3, 3, 3, 15, 165, 266, 266, 15, 15, 3,
1611 3, 3, 3, 3, 165, 167, 167, 167, 167, 166,
1612 3, 3, 3, 3, 164, 3, 3, 167, 11, 167,
1613 165, 3, 165, 3
1614 };
1615
1616 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1617 static const yytype_int16 yyr1[] =
1618 {
1619 0, 170, 171, 171, 171, 171, 171, 171, 171, 171,
1620 171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
1621 171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
1622 171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
1623 171, 172, 171, 173, 171, 174, 171, 171, 171, 171,
1624 171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
1625 171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
1626 171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
1627 171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
1628 171, 175, 171, 176, 171, 177, 171, 178, 171, 179,
1629 171, 180, 171, 181, 171, 182, 171, 183, 171, 184,
1630 171, 185, 171, 186, 171, 187, 171, 188, 171, 189,
1631 171, 190, 171, 191, 171, 192, 171, 193, 171, 194,
1632 171, 171, 171, 171, 171, 171, 171, 171, 171, 195,
1633 171, 196, 171, 197, 171, 198, 171, 199, 171, 200,
1634 171, 201, 171, 202, 171, 203, 171, 171, 171, 171,
1635 171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
1636 171, 171, 171, 171, 204, 171, 171, 205, 171, 171,
1637 206, 171, 171, 171, 171, 171, 171, 171, 171, 171,
1638 207, 171, 208, 171, 209, 171, 210, 171, 171, 171,
1639 171, 171, 171, 171, 171, 171, 171, 171, 211, 171,
1640 212, 171, 213, 171, 214, 171, 215, 171, 171, 171,
1641 171, 171, 171, 171, 171, 171, 171, 171, 171, 216,
1642 171, 171, 171, 171, 171, 217, 171, 218, 171, 219,
1643 171, 220, 171, 221, 171, 222, 171, 223, 171, 224,
1644 171, 225, 171, 226, 171, 227, 171, 228, 171, 229,
1645 171, 230, 171, 231, 171, 171, 171, 171, 171, 171,
1646 171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
1647 171, 171, 171, 171, 171, 171, 171, 171, 171, 232,
1648 232, 232, 232, 233, 233, 234, 234, 234, 235, 236,
1649 236, 237, 237, 238, 238, 239, 241, 240, 240, 242,
1650 242, 242, 243, 244, 244, 244, 245, 245, 245, 245,
1651 247, 246, 246, 249, 248, 250, 248, 252, 251, 253,
1652 253, 255, 254, 256, 256, 257, 258, 259, 259, 261,
1653 260, 262, 262, 262, 262, 262, 263, 263, 263, 263,
1654 264, 264, 264, 265, 265, 266, 266
1655 };
1656
1657 /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
1658 static const yytype_int8 yyr2[] =
1659 {
1660 0, 2, 1, 1, 1, 1, 1, 2, 3, 3,
1661 2, 3, 3, 3, 3, 3, 3, 3, 2, 8,
1662 8, 8, 9, 9, 9, 7, 4, 8, 8, 5,
1663 7, 8, 5, 5, 5, 5, 5, 5, 6, 5,
1664 3, 0, 3, 0, 3, 0, 3, 4, 4, 7,
1665 3, 5, 5, 5, 2, 2, 2, 3, 2, 2,
1666 2, 2, 2, 2, 2, 3, 3, 1, 1, 1,
1667 1, 2, 2, 2, 2, 1, 1, 1, 1, 3,
1668 8, 8, 7, 10, 11, 5, 7, 9, 9, 9,
1669 6, 0, 3, 0, 3, 0, 3, 0, 3, 0,
1670 3, 0, 3, 0, 3, 0, 3, 0, 3, 0,
1671 3, 0, 3, 0, 3, 0, 3, 0, 3, 0,
1672 3, 0, 3, 0, 3, 0, 3, 0, 3, 0,
1673 3, 4, 4, 4, 4, 8, 8, 8, 8, 0,
1674 3, 0, 3, 0, 3, 0, 3, 0, 3, 0,
1675 3, 0, 3, 0, 3, 0, 3, 3, 6, 9,
1676 9, 4, 6, 4, 6, 4, 6, 4, 6, 2,
1677 4, 2, 4, 2, 0, 3, 2, 0, 3, 2,
1678 0, 3, 3, 5, 8, 8, 8, 8, 8, 8,
1679 0, 3, 0, 3, 0, 3, 0, 3, 4, 4,
1680 5, 5, 5, 5, 5, 9, 9, 9, 0, 3,
1681 0, 3, 0, 3, 0, 3, 0, 3, 5, 6,
1682 6, 6, 6, 6, 6, 6, 6, 6, 6, 0,
1683 3, 4, 5, 5, 5, 0, 3, 0, 3, 0,
1684 3, 0, 3, 0, 3, 0, 3, 0, 3, 0,
1685 3, 0, 3, 0, 3, 0, 3, 0, 3, 0,
1686 3, 0, 3, 0, 3, 4, 5, 5, 5, 5,
1687 5, 5, 7, 8, 7, 8, 6, 6, 6, 5,
1688 5, 5, 5, 4, 1, 4, 4, 4, 4, 3,
1689 7, 7, 5, 3, 7, 3, 7, 7, 4, 1,
1690 1, 1, 1, 3, 1, 3, 0, 2, 1, 3,
1691 7, 7, 3, 4, 6, 1, 4, 3, 7, 5,
1692 0, 5, 1, 0, 4, 0, 8, 0, 7, 1,
1693 5, 0, 13, 2, 1, 3, 5, 0, 1, 0,
1694 2, 1, 1, 0, 1, 1, 0, 1, 1, 1,
1695 0, 1, 1, 0, 1, 0, 1
1696 };
1697
1698
1699 #define yyerrok (yyerrstatus = 0)
1700 #define yyclearin (yychar = YYEMPTY)
1701 #define YYEMPTY (-2)
1702 #define YYEOF 0
1703
1704 #define YYACCEPT goto yyacceptlab
1705 #define YYABORT goto yyabortlab
1706 #define YYERROR goto yyerrorlab
1707
1708
1709 #define YYRECOVERING() (!!yyerrstatus)
1710
1711 #define YYBACKUP(Token, Value) \
1712 do \
1713 if (yychar == YYEMPTY) \
1714 { \
1715 yychar = (Token); \
1716 yylval = (Value); \
1717 YYPOPSTACK (yylen); \
1718 yystate = *yyssp; \
1719 goto yybackup; \
1720 } \
1721 else \
1722 { \
1723 yyerror (YY_("syntax error: cannot back up")); \
1724 YYERROR; \
1725 } \
1726 while (0)
1727
1728 /* Error token number */
1729 #define YYTERROR 1
1730 #define YYERRCODE 256
1731
1732
1733
1734 /* Enable debugging if requested. */
1735 #if YYDEBUG
1736
1737 # ifndef YYFPRINTF
1738 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1739 # define YYFPRINTF fprintf
1740 # endif
1741
1742 # define YYDPRINTF(Args) \
1743 do { \
1744 if (yydebug) \
1745 YYFPRINTF Args; \
1746 } while (0)
1747
1748 /* This macro is provided for backward compatibility. */
1749 #ifndef YY_LOCATION_PRINT
1750 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1751 #endif
1752
1753
1754 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
1755 do { \
1756 if (yydebug) \
1757 { \
1758 YYFPRINTF (stderr, "%s ", Title); \
1759 yy_symbol_print (stderr, \
1760 Type, Value); \
1761 YYFPRINTF (stderr, "\n"); \
1762 } \
1763 } while (0)
1764
1765
1766 /*-----------------------------------.
1767 | Print this symbol's value on YYO. |
1768 `-----------------------------------*/
1769
1770 static void
yy_symbol_value_print(FILE * yyo,int yytype,YYSTYPE const * const yyvaluep)1771 yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep)
1772 {
1773 FILE *yyoutput = yyo;
1774 YYUSE (yyoutput);
1775 if (!yyvaluep)
1776 return;
1777 # ifdef YYPRINT
1778 if (yytype < YYNTOKENS)
1779 YYPRINT (yyo, yytoknum[yytype], *yyvaluep);
1780 # endif
1781 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1782 YYUSE (yytype);
1783 YY_IGNORE_MAYBE_UNINITIALIZED_END
1784 }
1785
1786
1787 /*---------------------------.
1788 | Print this symbol on YYO. |
1789 `---------------------------*/
1790
1791 static void
yy_symbol_print(FILE * yyo,int yytype,YYSTYPE const * const yyvaluep)1792 yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep)
1793 {
1794 YYFPRINTF (yyo, "%s %s (",
1795 yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
1796
1797 yy_symbol_value_print (yyo, yytype, yyvaluep);
1798 YYFPRINTF (yyo, ")");
1799 }
1800
1801 /*------------------------------------------------------------------.
1802 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1803 | TOP (included). |
1804 `------------------------------------------------------------------*/
1805
1806 static void
yy_stack_print(yy_state_t * yybottom,yy_state_t * yytop)1807 yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
1808 {
1809 YYFPRINTF (stderr, "Stack now");
1810 for (; yybottom <= yytop; yybottom++)
1811 {
1812 int yybot = *yybottom;
1813 YYFPRINTF (stderr, " %d", yybot);
1814 }
1815 YYFPRINTF (stderr, "\n");
1816 }
1817
1818 # define YY_STACK_PRINT(Bottom, Top) \
1819 do { \
1820 if (yydebug) \
1821 yy_stack_print ((Bottom), (Top)); \
1822 } while (0)
1823
1824
1825 /*------------------------------------------------.
1826 | Report that the YYRULE is going to be reduced. |
1827 `------------------------------------------------*/
1828
1829 static void
yy_reduce_print(yy_state_t * yyssp,YYSTYPE * yyvsp,int yyrule)1830 yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, int yyrule)
1831 {
1832 int yylno = yyrline[yyrule];
1833 int yynrhs = yyr2[yyrule];
1834 int yyi;
1835 YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
1836 yyrule - 1, yylno);
1837 /* The symbols being reduced. */
1838 for (yyi = 0; yyi < yynrhs; yyi++)
1839 {
1840 YYFPRINTF (stderr, " $%d = ", yyi + 1);
1841 yy_symbol_print (stderr,
1842 yystos[yyssp[yyi + 1 - yynrhs]],
1843 &yyvsp[(yyi + 1) - (yynrhs)]
1844 );
1845 YYFPRINTF (stderr, "\n");
1846 }
1847 }
1848
1849 # define YY_REDUCE_PRINT(Rule) \
1850 do { \
1851 if (yydebug) \
1852 yy_reduce_print (yyssp, yyvsp, Rule); \
1853 } while (0)
1854
1855 /* Nonzero means print parse trace. It is left uninitialized so that
1856 multiple parsers can coexist. */
1857 int yydebug;
1858 #else /* !YYDEBUG */
1859 # define YYDPRINTF(Args)
1860 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1861 # define YY_STACK_PRINT(Bottom, Top)
1862 # define YY_REDUCE_PRINT(Rule)
1863 #endif /* !YYDEBUG */
1864
1865
1866 /* YYINITDEPTH -- initial size of the parser's stacks. */
1867 #ifndef YYINITDEPTH
1868 # define YYINITDEPTH 200
1869 #endif
1870
1871 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1872 if the built-in stack extension method is used).
1873
1874 Do not make this value too large; the results are undefined if
1875 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1876 evaluated with infinite-precision integer arithmetic. */
1877
1878 #ifndef YYMAXDEPTH
1879 # define YYMAXDEPTH 10000
1880 #endif
1881
1882
1883 #if YYERROR_VERBOSE
1884
1885 # ifndef yystrlen
1886 # if defined __GLIBC__ && defined _STRING_H
1887 # define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S)))
1888 # else
1889 /* Return the length of YYSTR. */
1890 static YYPTRDIFF_T
yystrlen(const char * yystr)1891 yystrlen (const char *yystr)
1892 {
1893 YYPTRDIFF_T yylen;
1894 for (yylen = 0; yystr[yylen]; yylen++)
1895 continue;
1896 return yylen;
1897 }
1898 # endif
1899 # endif
1900
1901 # ifndef yystpcpy
1902 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1903 # define yystpcpy stpcpy
1904 # else
1905 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1906 YYDEST. */
1907 static char *
yystpcpy(char * yydest,const char * yysrc)1908 yystpcpy (char *yydest, const char *yysrc)
1909 {
1910 char *yyd = yydest;
1911 const char *yys = yysrc;
1912
1913 while ((*yyd++ = *yys++) != '\0')
1914 continue;
1915
1916 return yyd - 1;
1917 }
1918 # endif
1919 # endif
1920
1921 # ifndef yytnamerr
1922 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1923 quotes and backslashes, so that it's suitable for yyerror. The
1924 heuristic is that double-quoting is unnecessary unless the string
1925 contains an apostrophe, a comma, or backslash (other than
1926 backslash-backslash). YYSTR is taken from yytname. If YYRES is
1927 null, do not copy; instead, return the length of what the result
1928 would have been. */
1929 static YYPTRDIFF_T
yytnamerr(char * yyres,const char * yystr)1930 yytnamerr (char *yyres, const char *yystr)
1931 {
1932 if (*yystr == '"')
1933 {
1934 YYPTRDIFF_T yyn = 0;
1935 char const *yyp = yystr;
1936
1937 for (;;)
1938 switch (*++yyp)
1939 {
1940 case '\'':
1941 case ',':
1942 goto do_not_strip_quotes;
1943
1944 case '\\':
1945 if (*++yyp != '\\')
1946 goto do_not_strip_quotes;
1947 else
1948 goto append;
1949
1950 append:
1951 default:
1952 if (yyres)
1953 yyres[yyn] = *yyp;
1954 yyn++;
1955 break;
1956
1957 case '"':
1958 if (yyres)
1959 yyres[yyn] = '\0';
1960 return yyn;
1961 }
1962 do_not_strip_quotes: ;
1963 }
1964
1965 if (yyres)
1966 return yystpcpy (yyres, yystr) - yyres;
1967 else
1968 return yystrlen (yystr);
1969 }
1970 # endif
1971
1972 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1973 about the unexpected token YYTOKEN for the state stack whose top is
1974 YYSSP.
1975
1976 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
1977 not large enough to hold the message. In that case, also set
1978 *YYMSG_ALLOC to the required number of bytes. Return 2 if the
1979 required number of bytes is too large to store. */
1980 static int
yysyntax_error(YYPTRDIFF_T * yymsg_alloc,char ** yymsg,yy_state_t * yyssp,int yytoken)1981 yysyntax_error (YYPTRDIFF_T *yymsg_alloc, char **yymsg,
1982 yy_state_t *yyssp, int yytoken)
1983 {
1984 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1985 /* Internationalized format string. */
1986 const char *yyformat = YY_NULLPTR;
1987 /* Arguments of yyformat: reported tokens (one for the "unexpected",
1988 one per "expected"). */
1989 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1990 /* Actual size of YYARG. */
1991 int yycount = 0;
1992 /* Cumulated lengths of YYARG. */
1993 YYPTRDIFF_T yysize = 0;
1994
1995 /* There are many possibilities here to consider:
1996 - If this state is a consistent state with a default action, then
1997 the only way this function was invoked is if the default action
1998 is an error action. In that case, don't check for expected
1999 tokens because there are none.
2000 - The only way there can be no lookahead present (in yychar) is if
2001 this state is a consistent state with a default action. Thus,
2002 detecting the absence of a lookahead is sufficient to determine
2003 that there is no unexpected or expected token to report. In that
2004 case, just report a simple "syntax error".
2005 - Don't assume there isn't a lookahead just because this state is a
2006 consistent state with a default action. There might have been a
2007 previous inconsistent state, consistent state with a non-default
2008 action, or user semantic action that manipulated yychar.
2009 - Of course, the expected token list depends on states to have
2010 correct lookahead information, and it depends on the parser not
2011 to perform extra reductions after fetching a lookahead from the
2012 scanner and before detecting a syntax error. Thus, state merging
2013 (from LALR or IELR) and default reductions corrupt the expected
2014 token list. However, the list is correct for canonical LR with
2015 one exception: it will still contain any token that will not be
2016 accepted due to an error action in a later state.
2017 */
2018 if (yytoken != YYEMPTY)
2019 {
2020 int yyn = yypact[*yyssp];
2021 YYPTRDIFF_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
2022 yysize = yysize0;
2023 yyarg[yycount++] = yytname[yytoken];
2024 if (!yypact_value_is_default (yyn))
2025 {
2026 /* Start YYX at -YYN if negative to avoid negative indexes in
2027 YYCHECK. In other words, skip the first -YYN actions for
2028 this state because they are default actions. */
2029 int yyxbegin = yyn < 0 ? -yyn : 0;
2030 /* Stay within bounds of both yycheck and yytname. */
2031 int yychecklim = YYLAST - yyn + 1;
2032 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
2033 int yyx;
2034
2035 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
2036 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
2037 && !yytable_value_is_error (yytable[yyx + yyn]))
2038 {
2039 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
2040 {
2041 yycount = 1;
2042 yysize = yysize0;
2043 break;
2044 }
2045 yyarg[yycount++] = yytname[yyx];
2046 {
2047 YYPTRDIFF_T yysize1
2048 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
2049 if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
2050 yysize = yysize1;
2051 else
2052 return 2;
2053 }
2054 }
2055 }
2056 }
2057
2058 switch (yycount)
2059 {
2060 # define YYCASE_(N, S) \
2061 case N: \
2062 yyformat = S; \
2063 break
2064 default: /* Avoid compiler warnings. */
2065 YYCASE_(0, YY_("syntax error"));
2066 YYCASE_(1, YY_("syntax error, unexpected %s"));
2067 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
2068 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
2069 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
2070 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
2071 # undef YYCASE_
2072 }
2073
2074 {
2075 /* Don't count the "%s"s in the final size, but reserve room for
2076 the terminator. */
2077 YYPTRDIFF_T yysize1 = yysize + (yystrlen (yyformat) - 2 * yycount) + 1;
2078 if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
2079 yysize = yysize1;
2080 else
2081 return 2;
2082 }
2083
2084 if (*yymsg_alloc < yysize)
2085 {
2086 *yymsg_alloc = 2 * yysize;
2087 if (! (yysize <= *yymsg_alloc
2088 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
2089 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
2090 return 1;
2091 }
2092
2093 /* Avoid sprintf, as that infringes on the user's name space.
2094 Don't have undefined behavior even if the translation
2095 produced a string with the wrong number of "%s"s. */
2096 {
2097 char *yyp = *yymsg;
2098 int yyi = 0;
2099 while ((*yyp = *yyformat) != '\0')
2100 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
2101 {
2102 yyp += yytnamerr (yyp, yyarg[yyi++]);
2103 yyformat += 2;
2104 }
2105 else
2106 {
2107 ++yyp;
2108 ++yyformat;
2109 }
2110 }
2111 return 0;
2112 }
2113 #endif /* YYERROR_VERBOSE */
2114
2115 /*-----------------------------------------------.
2116 | Release the memory associated to this symbol. |
2117 `-----------------------------------------------*/
2118
2119 static void
yydestruct(const char * yymsg,int yytype,YYSTYPE * yyvaluep)2120 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
2121 {
2122 YYUSE (yyvaluep);
2123 if (!yymsg)
2124 yymsg = "Deleting";
2125 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
2126
2127 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2128 YYUSE (yytype);
2129 YY_IGNORE_MAYBE_UNINITIALIZED_END
2130 }
2131
2132
2133
2134
2135 /* The lookahead symbol. */
2136 int yychar;
2137
2138 /* The semantic value of the lookahead symbol. */
2139 YYSTYPE yylval;
2140 /* Number of syntax errors so far. */
2141 int yynerrs;
2142
2143
2144 /*----------.
2145 | yyparse. |
2146 `----------*/
2147
2148 int
yyparse(void)2149 yyparse (void)
2150 {
2151 yy_state_fast_t yystate;
2152 /* Number of tokens to shift before error messages enabled. */
2153 int yyerrstatus;
2154
2155 /* The stacks and their tools:
2156 'yyss': related to states.
2157 'yyvs': related to semantic values.
2158
2159 Refer to the stacks through separate pointers, to allow yyoverflow
2160 to reallocate them elsewhere. */
2161
2162 /* The state stack. */
2163 yy_state_t yyssa[YYINITDEPTH];
2164 yy_state_t *yyss;
2165 yy_state_t *yyssp;
2166
2167 /* The semantic value stack. */
2168 YYSTYPE yyvsa[YYINITDEPTH];
2169 YYSTYPE *yyvs;
2170 YYSTYPE *yyvsp;
2171
2172 YYPTRDIFF_T yystacksize;
2173
2174 int yyn;
2175 int yyresult;
2176 /* Lookahead token as an internal (translated) token number. */
2177 int yytoken = 0;
2178 /* The variables used to return semantic value and location from the
2179 action routines. */
2180 YYSTYPE yyval;
2181
2182 #if YYERROR_VERBOSE
2183 /* Buffer for error messages, and its allocated size. */
2184 char yymsgbuf[128];
2185 char *yymsg = yymsgbuf;
2186 YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf;
2187 #endif
2188
2189 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
2190
2191 /* The number of symbols on the RHS of the reduced rule.
2192 Keep to zero when no symbol should be popped. */
2193 int yylen = 0;
2194
2195 yyssp = yyss = yyssa;
2196 yyvsp = yyvs = yyvsa;
2197 yystacksize = YYINITDEPTH;
2198
2199 YYDPRINTF ((stderr, "Starting parse\n"));
2200
2201 yystate = 0;
2202 yyerrstatus = 0;
2203 yynerrs = 0;
2204 yychar = YYEMPTY; /* Cause a token to be read. */
2205 goto yysetstate;
2206
2207
2208 /*------------------------------------------------------------.
2209 | yynewstate -- push a new state, which is found in yystate. |
2210 `------------------------------------------------------------*/
2211 yynewstate:
2212 /* In all cases, when you get here, the value and location stacks
2213 have just been pushed. So pushing a state here evens the stacks. */
2214 yyssp++;
2215
2216
2217 /*--------------------------------------------------------------------.
2218 | yysetstate -- set current state (the top of the stack) to yystate. |
2219 `--------------------------------------------------------------------*/
2220 yysetstate:
2221 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2222 YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
2223 YY_IGNORE_USELESS_CAST_BEGIN
2224 *yyssp = YY_CAST (yy_state_t, yystate);
2225 YY_IGNORE_USELESS_CAST_END
2226
2227 if (yyss + yystacksize - 1 <= yyssp)
2228 #if !defined yyoverflow && !defined YYSTACK_RELOCATE
2229 goto yyexhaustedlab;
2230 #else
2231 {
2232 /* Get the current used size of the three stacks, in elements. */
2233 YYPTRDIFF_T yysize = yyssp - yyss + 1;
2234
2235 # if defined yyoverflow
2236 {
2237 /* Give user a chance to reallocate the stack. Use copies of
2238 these so that the &'s don't force the real ones into
2239 memory. */
2240 yy_state_t *yyss1 = yyss;
2241 YYSTYPE *yyvs1 = yyvs;
2242
2243 /* Each stack pointer address is followed by the size of the
2244 data in use in that stack, in bytes. This used to be a
2245 conditional around just the two extra args, but that might
2246 be undefined if yyoverflow is a macro. */
2247 yyoverflow (YY_("memory exhausted"),
2248 &yyss1, yysize * YYSIZEOF (*yyssp),
2249 &yyvs1, yysize * YYSIZEOF (*yyvsp),
2250 &yystacksize);
2251 yyss = yyss1;
2252 yyvs = yyvs1;
2253 }
2254 # else /* defined YYSTACK_RELOCATE */
2255 /* Extend the stack our own way. */
2256 if (YYMAXDEPTH <= yystacksize)
2257 goto yyexhaustedlab;
2258 yystacksize *= 2;
2259 if (YYMAXDEPTH < yystacksize)
2260 yystacksize = YYMAXDEPTH;
2261
2262 {
2263 yy_state_t *yyss1 = yyss;
2264 union yyalloc *yyptr =
2265 YY_CAST (union yyalloc *,
2266 YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
2267 if (! yyptr)
2268 goto yyexhaustedlab;
2269 YYSTACK_RELOCATE (yyss_alloc, yyss);
2270 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
2271 # undef YYSTACK_RELOCATE
2272 if (yyss1 != yyssa)
2273 YYSTACK_FREE (yyss1);
2274 }
2275 # endif
2276
2277 yyssp = yyss + yysize - 1;
2278 yyvsp = yyvs + yysize - 1;
2279
2280 YY_IGNORE_USELESS_CAST_BEGIN
2281 YYDPRINTF ((stderr, "Stack size increased to %ld\n",
2282 YY_CAST (long, yystacksize)));
2283 YY_IGNORE_USELESS_CAST_END
2284
2285 if (yyss + yystacksize - 1 <= yyssp)
2286 YYABORT;
2287 }
2288 #endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
2289
2290 if (yystate == YYFINAL)
2291 YYACCEPT;
2292
2293 goto yybackup;
2294
2295
2296 /*-----------.
2297 | yybackup. |
2298 `-----------*/
2299 yybackup:
2300 /* Do appropriate processing given the current state. Read a
2301 lookahead token if we need one and don't already have one. */
2302
2303 /* First try to decide what to do without reference to lookahead token. */
2304 yyn = yypact[yystate];
2305 if (yypact_value_is_default (yyn))
2306 goto yydefault;
2307
2308 /* Not known => get a lookahead token if don't already have one. */
2309
2310 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
2311 if (yychar == YYEMPTY)
2312 {
2313 YYDPRINTF ((stderr, "Reading a token: "));
2314 yychar = yylex ();
2315 }
2316
2317 if (yychar <= YYEOF)
2318 {
2319 yychar = yytoken = YYEOF;
2320 YYDPRINTF ((stderr, "Now at end of input.\n"));
2321 }
2322 else
2323 {
2324 yytoken = YYTRANSLATE (yychar);
2325 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2326 }
2327
2328 /* If the proper action on seeing token YYTOKEN is to reduce or to
2329 detect an error, take that action. */
2330 yyn += yytoken;
2331 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
2332 goto yydefault;
2333 yyn = yytable[yyn];
2334 if (yyn <= 0)
2335 {
2336 if (yytable_value_is_error (yyn))
2337 goto yyerrlab;
2338 yyn = -yyn;
2339 goto yyreduce;
2340 }
2341
2342 /* Count tokens shifted since error; after three, turn off error
2343 status. */
2344 if (yyerrstatus)
2345 yyerrstatus--;
2346
2347 /* Shift the lookahead token. */
2348 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2349 yystate = yyn;
2350 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2351 *++yyvsp = yylval;
2352 YY_IGNORE_MAYBE_UNINITIALIZED_END
2353
2354 /* Discard the shifted token. */
2355 yychar = YYEMPTY;
2356 goto yynewstate;
2357
2358
2359 /*-----------------------------------------------------------.
2360 | yydefault -- do the default action for the current state. |
2361 `-----------------------------------------------------------*/
2362 yydefault:
2363 yyn = yydefact[yystate];
2364 if (yyn == 0)
2365 goto yyerrlab;
2366 goto yyreduce;
2367
2368
2369 /*-----------------------------.
2370 | yyreduce -- do a reduction. |
2371 `-----------------------------*/
2372 yyreduce:
2373 /* yyn is the number of a rule to reduce with. */
2374 yylen = yyr2[yyn];
2375
2376 /* If YYLEN is nonzero, implement the default value of the action:
2377 '$$ = $1'.
2378
2379 Otherwise, the following line sets YYVAL to garbage.
2380 This behavior is undocumented and Bison
2381 users should not rely upon it. Assigning to YYVAL
2382 unconditionally makes the parser a bit smaller, and it avoids a
2383 GCC warning that YYVAL may be used uninitialized. */
2384 yyval = yyvsp[1-yylen];
2385
2386
2387 YY_REDUCE_PRINT (yyn);
2388 switch (yyn)
2389 {
2390 case 2:
2391 #line 185 "./config/rx-parse.y"
2392 { as_bad (_("Unknown opcode: %s"), rx_init_start); }
2393 #line 2394 "config/rx-parse.c"
2394 break;
2395
2396 case 3:
2397 #line 190 "./config/rx-parse.y"
2398 { B1 (0x00); }
2399 #line 2400 "config/rx-parse.c"
2400 break;
2401
2402 case 4:
2403 #line 193 "./config/rx-parse.y"
2404 { B1 (0x01); }
2405 #line 2406 "config/rx-parse.c"
2406 break;
2407
2408 case 5:
2409 #line 196 "./config/rx-parse.y"
2410 { B1 (0x02); }
2411 #line 2412 "config/rx-parse.c"
2412 break;
2413
2414 case 6:
2415 #line 199 "./config/rx-parse.y"
2416 { B1 (0x03); }
2417 #line 2418 "config/rx-parse.c"
2418 break;
2419
2420 case 7:
2421 #line 204 "./config/rx-parse.y"
2422 { if (rx_disp3op ((yyvsp[0].exp)))
2423 { B1 (0x08); rx_disp3 ((yyvsp[0].exp), 5); }
2424 else if (rx_intop ((yyvsp[0].exp), 8, 8))
2425 { B1 (0x2e); PC1 ((yyvsp[0].exp)); }
2426 else if (rx_intop ((yyvsp[0].exp), 16, 16))
2427 { B1 (0x38); PC2 ((yyvsp[0].exp)); }
2428 else if (rx_intop ((yyvsp[0].exp), 24, 24))
2429 { B1 (0x04); PC3 ((yyvsp[0].exp)); }
2430 else
2431 { rx_relax (RX_RELAX_BRANCH, 0);
2432 rx_linkrelax_branch ();
2433 /* We'll convert this to a longer one later if needed. */
2434 B1 (0x08); rx_disp3 ((yyvsp[0].exp), 5); } }
2435 #line 2436 "config/rx-parse.c"
2436 break;
2437
2438 case 8:
2439 #line 219 "./config/rx-parse.y"
2440 { B1 (0x04); PC3 ((yyvsp[0].exp)); }
2441 #line 2442 "config/rx-parse.c"
2442 break;
2443
2444 case 9:
2445 #line 222 "./config/rx-parse.y"
2446 { B1 (0x08); rx_disp3 ((yyvsp[0].exp), 5); }
2447 #line 2448 "config/rx-parse.c"
2448 break;
2449
2450 case 10:
2451 #line 227 "./config/rx-parse.y"
2452 { if (rx_intop ((yyvsp[0].exp), 16, 16))
2453 { B1 (0x39); PC2 ((yyvsp[0].exp)); }
2454 else if (rx_intop ((yyvsp[0].exp), 24, 24))
2455 { B1 (0x05); PC3 ((yyvsp[0].exp)); }
2456 else
2457 { rx_relax (RX_RELAX_BRANCH, 0);
2458 rx_linkrelax_branch ();
2459 B1 (0x39); PC2 ((yyvsp[0].exp)); } }
2460 #line 2461 "config/rx-parse.c"
2461 break;
2462
2463 case 11:
2464 #line 236 "./config/rx-parse.y"
2465 { B1 (0x05), PC3 ((yyvsp[0].exp)); }
2466 #line 2467 "config/rx-parse.c"
2467 break;
2468
2469 case 12:
2470 #line 241 "./config/rx-parse.y"
2471 { if ((yyvsp[-2].regno) == COND_EQ || (yyvsp[-2].regno) == COND_NE)
2472 { B1 ((yyvsp[-2].regno) == COND_EQ ? 0x10 : 0x18); rx_disp3 ((yyvsp[0].exp), 5); }
2473 else
2474 as_bad (_("Only BEQ and BNE may have .S")); }
2475 #line 2476 "config/rx-parse.c"
2476 break;
2477
2478 case 13:
2479 #line 249 "./config/rx-parse.y"
2480 { B1 (0x20); F ((yyvsp[-2].regno), 4, 4); PC1 ((yyvsp[0].exp)); }
2481 #line 2482 "config/rx-parse.c"
2482 break;
2483
2484 case 14:
2485 #line 252 "./config/rx-parse.y"
2486 { B1 (0x2e), PC1 ((yyvsp[0].exp)); }
2487 #line 2488 "config/rx-parse.c"
2488 break;
2489
2490 case 15:
2491 #line 257 "./config/rx-parse.y"
2492 { B1 (0x38), PC2 ((yyvsp[0].exp)); }
2493 #line 2494 "config/rx-parse.c"
2494 break;
2495
2496 case 16:
2497 #line 259 "./config/rx-parse.y"
2498 { B1 (0x39), PC2 ((yyvsp[0].exp)); }
2499 #line 2500 "config/rx-parse.c"
2500 break;
2501
2502 case 17:
2503 #line 261 "./config/rx-parse.y"
2504 { if ((yyvsp[-2].regno) == COND_EQ || (yyvsp[-2].regno) == COND_NE)
2505 { B1 ((yyvsp[-2].regno) == COND_EQ ? 0x3a : 0x3b); PC2 ((yyvsp[0].exp)); }
2506 else
2507 as_bad (_("Only BEQ and BNE may have .W")); }
2508 #line 2509 "config/rx-parse.c"
2509 break;
2510
2511 case 18:
2512 #line 266 "./config/rx-parse.y"
2513 { if ((yyvsp[-1].regno) == COND_EQ || (yyvsp[-1].regno) == COND_NE)
2514 {
2515 rx_relax (RX_RELAX_BRANCH, 0);
2516 rx_linkrelax_branch ();
2517 B1 ((yyvsp[-1].regno) == COND_EQ ? 0x10 : 0x18); rx_disp3 ((yyvsp[0].exp), 5);
2518 }
2519 else
2520 {
2521 rx_relax (RX_RELAX_BRANCH, 0);
2522 /* This is because we might turn it into a
2523 jump-over-jump long branch. */
2524 rx_linkrelax_branch ();
2525 B1 (0x20); F ((yyvsp[-1].regno), 4, 4); PC1 ((yyvsp[0].exp));
2526 } }
2527 #line 2528 "config/rx-parse.c"
2528 break;
2529
2530 case 19:
2531 #line 284 "./config/rx-parse.y"
2532 { B2 (0xf8, 0x04); F ((yyvsp[-1].regno), 8, 4); IMMB ((yyvsp[-4].exp), 12);}
2533 #line 2534 "config/rx-parse.c"
2534 break;
2535
2536 case 20:
2537 #line 287 "./config/rx-parse.y"
2538 { B2 (0xf8, 0x01); F ((yyvsp[-1].regno), 8, 4); IMMW ((yyvsp[-4].exp), 12);}
2539 #line 2540 "config/rx-parse.c"
2540 break;
2541
2542 case 21:
2543 #line 290 "./config/rx-parse.y"
2544 { B2 (0xf8, 0x02); F ((yyvsp[-1].regno), 8, 4); IMM ((yyvsp[-4].exp), 12);}
2545 #line 2546 "config/rx-parse.c"
2546 break;
2547
2548 case 22:
2549 #line 294 "./config/rx-parse.y"
2550 { if ((yyvsp[-1].regno) <= 7 && rx_uintop ((yyvsp[-5].exp), 8) && rx_disp5op0 (&(yyvsp[-3].exp), BSIZE))
2551 { B2 (0x3c, 0); rx_field5s2 ((yyvsp[-3].exp)); F ((yyvsp[-1].regno), 9, 3); O1 ((yyvsp[-5].exp)); }
2552 else
2553 { B2 (0xf8, 0x04); F ((yyvsp[-1].regno), 8, 4); DSP ((yyvsp[-3].exp), 6, BSIZE); O1 ((yyvsp[-5].exp));
2554 if ((yyvsp[-5].exp).X_op != O_constant && (yyvsp[-5].exp).X_op != O_big) rx_linkrelax_imm (12); } }
2555 #line 2556 "config/rx-parse.c"
2556 break;
2557
2558 case 23:
2559 #line 301 "./config/rx-parse.y"
2560 { if ((yyvsp[-1].regno) <= 7 && rx_uintop ((yyvsp[-5].exp), 8) && rx_disp5op0 (&(yyvsp[-3].exp), WSIZE))
2561 { B2 (0x3d, 0); rx_field5s2 ((yyvsp[-3].exp)); F ((yyvsp[-1].regno), 9, 3); O1 ((yyvsp[-5].exp)); }
2562 else
2563 { B2 (0xf8, 0x01); F ((yyvsp[-1].regno), 8, 4); DSP ((yyvsp[-3].exp), 6, WSIZE); IMMW ((yyvsp[-5].exp), 12); } }
2564 #line 2565 "config/rx-parse.c"
2565 break;
2566
2567 case 24:
2568 #line 307 "./config/rx-parse.y"
2569 { if ((yyvsp[-1].regno) <= 7 && rx_uintop ((yyvsp[-5].exp), 8) && rx_disp5op0 (&(yyvsp[-3].exp), LSIZE))
2570 { B2 (0x3e, 0); rx_field5s2 ((yyvsp[-3].exp)); F ((yyvsp[-1].regno), 9, 3); O1 ((yyvsp[-5].exp)); }
2571 else
2572 { B2 (0xf8, 0x02); F ((yyvsp[-1].regno), 8, 4); DSP ((yyvsp[-3].exp), 6, LSIZE); IMM ((yyvsp[-5].exp), 12); } }
2573 #line 2574 "config/rx-parse.c"
2574 break;
2575
2576 case 25:
2577 #line 315 "./config/rx-parse.y"
2578 { B2 (0x3f, 0); F ((yyvsp[-2].regno), 8, 4); F ((yyvsp[0].regno), 12, 4); rtsd_immediate ((yyvsp[-4].exp));
2579 if ((yyvsp[-2].regno) == 0)
2580 rx_error (_("RTSD cannot pop R0"));
2581 if ((yyvsp[-2].regno) > (yyvsp[0].regno))
2582 rx_error (_("RTSD first reg must be <= second reg")); }
2583 #line 2584 "config/rx-parse.c"
2584 break;
2585
2586 case 26:
2587 #line 324 "./config/rx-parse.y"
2588 { B2 (0x47, 0); F ((yyvsp[-2].regno), 8, 4); F ((yyvsp[0].regno), 12, 4); }
2589 #line 2590 "config/rx-parse.c"
2590 break;
2591
2592 case 27:
2593 #line 329 "./config/rx-parse.y"
2594 { B2 (0x44, 0); F ((yyvsp[-4].regno), 8, 4); F ((yyvsp[0].regno), 12, 4); DSP ((yyvsp[-6].exp), 6, BSIZE); }
2595 #line 2596 "config/rx-parse.c"
2596 break;
2597
2598 case 28:
2599 #line 332 "./config/rx-parse.y"
2600 { B3 (MEMEX, 0x04, 0); F ((yyvsp[-2].regno), 8, 2); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); DSP ((yyvsp[-6].exp), 14, sizemap[(yyvsp[-2].regno)]); }
2601 #line 2602 "config/rx-parse.c"
2602 break;
2603
2604 case 29:
2605 #line 337 "./config/rx-parse.y"
2606 { B2 (0x5b, 0x00); F ((yyvsp[-3].regno), 5, 1); F ((yyvsp[-2].regno), 8, 4); F ((yyvsp[0].regno), 12, 4); }
2607 #line 2608 "config/rx-parse.c"
2608 break;
2609
2610 case 30:
2611 #line 342 "./config/rx-parse.y"
2612 { B2 (0x58, 0x00); F ((yyvsp[-5].regno), 5, 1); F ((yyvsp[-3].regno), 8, 4); F ((yyvsp[0].regno), 12, 4); }
2613 #line 2614 "config/rx-parse.c"
2614 break;
2615
2616 case 31:
2617 #line 345 "./config/rx-parse.y"
2618 { if ((yyvsp[-3].regno) <= 7 && (yyvsp[0].regno) <= 7 && rx_disp5op (&(yyvsp[-5].exp), (yyvsp[-6].regno)))
2619 { B2 (0xb0, 0); F ((yyvsp[-6].regno), 4, 1); F ((yyvsp[-3].regno), 9, 3); F ((yyvsp[0].regno), 13, 3); rx_field5s ((yyvsp[-5].exp)); }
2620 else
2621 { B2 (0x58, 0x00); F ((yyvsp[-6].regno), 5, 1); F ((yyvsp[-3].regno), 8, 4); F ((yyvsp[0].regno), 12, 4); DSP ((yyvsp[-5].exp), 6, (yyvsp[-6].regno)); } }
2622 #line 2623 "config/rx-parse.c"
2623 break;
2624
2625 case 32:
2626 #line 353 "./config/rx-parse.y"
2627 { if (rx_uintop ((yyvsp[-2].exp), 4))
2628 { B2 (0x60, 0); FE ((yyvsp[-2].exp), 8, 4); F ((yyvsp[0].regno), 12, 4); }
2629 else
2630 /* This is really an add, but we negate the immediate. */
2631 { B2 (0x70, 0); F ((yyvsp[0].regno), 8, 4); F ((yyvsp[0].regno), 12, 4); NIMM ((yyvsp[-2].exp), 6); } }
2632 #line 2633 "config/rx-parse.c"
2633 break;
2634
2635 case 33:
2636 #line 360 "./config/rx-parse.y"
2637 { if (rx_uintop ((yyvsp[-2].exp), 4))
2638 { B2 (0x61, 0); FE ((yyvsp[-2].exp), 8, 4); F ((yyvsp[0].regno), 12, 4); }
2639 else if (rx_uintop ((yyvsp[-2].exp), 8))
2640 { B2 (0x75, 0x50); F ((yyvsp[0].regno), 12, 4); UO1 ((yyvsp[-2].exp)); }
2641 else
2642 { B2 (0x74, 0x00); F ((yyvsp[0].regno), 12, 4); IMM ((yyvsp[-2].exp), 6); } }
2643 #line 2644 "config/rx-parse.c"
2644 break;
2645
2646 case 34:
2647 #line 368 "./config/rx-parse.y"
2648 { if (rx_uintop ((yyvsp[-2].exp), 4))
2649 { B2 (0x62, 0); FE ((yyvsp[-2].exp), 8, 4); F ((yyvsp[0].regno), 12, 4); }
2650 else
2651 { B2 (0x70, 0); F ((yyvsp[0].regno), 8, 4); F ((yyvsp[0].regno), 12, 4); IMM ((yyvsp[-2].exp), 6); } }
2652 #line 2653 "config/rx-parse.c"
2653 break;
2654
2655 case 35:
2656 #line 374 "./config/rx-parse.y"
2657 { if (rx_uintop ((yyvsp[-2].exp), 4))
2658 { B2 (0x63, 0); FE ((yyvsp[-2].exp), 8, 4); F ((yyvsp[0].regno), 12, 4); }
2659 else
2660 { B2 (0x74, 0x10); F ((yyvsp[0].regno), 12, 4); IMM ((yyvsp[-2].exp), 6); } }
2661 #line 2662 "config/rx-parse.c"
2662 break;
2663
2664 case 36:
2665 #line 380 "./config/rx-parse.y"
2666 { if (rx_uintop ((yyvsp[-2].exp), 4))
2667 { B2 (0x64, 0); FE ((yyvsp[-2].exp), 8, 4); F ((yyvsp[0].regno), 12, 4); }
2668 else
2669 { B2 (0x74, 0x20); F ((yyvsp[0].regno), 12, 4); IMM ((yyvsp[-2].exp), 6); } }
2670 #line 2671 "config/rx-parse.c"
2671 break;
2672
2673 case 37:
2674 #line 386 "./config/rx-parse.y"
2675 { if (rx_uintop ((yyvsp[-2].exp), 4))
2676 { B2 (0x65, 0); FE ((yyvsp[-2].exp), 8, 4); F ((yyvsp[0].regno), 12, 4); }
2677 else
2678 { B2 (0x74, 0x30); F ((yyvsp[0].regno), 12, 4); IMM ((yyvsp[-2].exp), 6); } }
2679 #line 2680 "config/rx-parse.c"
2680 break;
2681
2682 case 38:
2683 #line 392 "./config/rx-parse.y"
2684 { if (rx_uintop ((yyvsp[-2].exp), 4))
2685 { B2 (0x66, 0); FE ((yyvsp[-2].exp), 8, 4); F ((yyvsp[0].regno), 12, 4); }
2686 else if (rx_uintop ((yyvsp[-2].exp), 8))
2687 { B2 (0x75, 0x40); F ((yyvsp[0].regno), 12, 4); UO1 ((yyvsp[-2].exp)); }
2688 else
2689 { B2 (0xfb, 0x02); F ((yyvsp[0].regno), 8, 4); IMM ((yyvsp[-2].exp), 12); } }
2690 #line 2691 "config/rx-parse.c"
2691 break;
2692
2693 case 39:
2694 #line 400 "./config/rx-parse.y"
2695 { if (rx_uintop ((yyvsp[-2].exp), 4))
2696 { B2 (0x66, 0); FE ((yyvsp[-2].exp), 8, 4); F ((yyvsp[0].regno), 12, 4); }
2697 else if (rx_uintop ((yyvsp[-2].exp), 8))
2698 { B2 (0x75, 0x40); F ((yyvsp[0].regno), 12, 4); UO1 ((yyvsp[-2].exp)); }
2699 else
2700 { B2 (0xfb, 0x02); F ((yyvsp[0].regno), 8, 4); IMM ((yyvsp[-2].exp), 12); } }
2701 #line 2702 "config/rx-parse.c"
2702 break;
2703
2704 case 40:
2705 #line 410 "./config/rx-parse.y"
2706 { B1 (0x67); rtsd_immediate ((yyvsp[0].exp)); }
2707 #line 2708 "config/rx-parse.c"
2708 break;
2709
2710 case 41:
2711 #line 414 "./config/rx-parse.y"
2712 { sub_op = 0; }
2713 #line 2714 "config/rx-parse.c"
2714 break;
2715
2716 case 43:
2717 #line 415 "./config/rx-parse.y"
2718 { sub_op = 1; }
2719 #line 2720 "config/rx-parse.c"
2720 break;
2721
2722 case 45:
2723 #line 416 "./config/rx-parse.y"
2724 { sub_op = 2; }
2725 #line 2726 "config/rx-parse.c"
2726 break;
2727
2728 case 47:
2729 #line 421 "./config/rx-parse.y"
2730 {
2731 if ((yyvsp[-2].regno) == (yyvsp[0].regno))
2732 { B2 (0x7e, 0x80); F (LSIZE, 10, 2); F ((yyvsp[-2].regno), 12, 4); }
2733 else
2734 { B2 (0x6e, 0); F ((yyvsp[-2].regno), 8, 4); F ((yyvsp[0].regno), 12, 4); }
2735 if ((yyvsp[-2].regno) == 0)
2736 rx_error (_("PUSHM cannot push R0"));
2737 if ((yyvsp[-2].regno) > (yyvsp[0].regno))
2738 rx_error (_("PUSHM first reg must be <= second reg")); }
2739 #line 2740 "config/rx-parse.c"
2740 break;
2741
2742 case 48:
2743 #line 434 "./config/rx-parse.y"
2744 {
2745 if ((yyvsp[-2].regno) == (yyvsp[0].regno))
2746 { B2 (0x7e, 0xb0); F ((yyvsp[-2].regno), 12, 4); }
2747 else
2748 { B2 (0x6f, 0); F ((yyvsp[-2].regno), 8, 4); F ((yyvsp[0].regno), 12, 4); }
2749 if ((yyvsp[-2].regno) == 0)
2750 rx_error (_("POPM cannot pop R0"));
2751 if ((yyvsp[-2].regno) > (yyvsp[0].regno))
2752 rx_error (_("POPM first reg must be <= second reg")); }
2753 #line 2754 "config/rx-parse.c"
2754 break;
2755
2756 case 49:
2757 #line 447 "./config/rx-parse.y"
2758 { B2 (0x70, 0x00); F ((yyvsp[-2].regno), 8, 4); F ((yyvsp[0].regno), 12, 4); IMM ((yyvsp[-4].exp), 6); }
2759 #line 2760 "config/rx-parse.c"
2760 break;
2761
2762 case 50:
2763 #line 452 "./config/rx-parse.y"
2764 { B2(0x75, 0x60), UO1 ((yyvsp[0].exp)); }
2765 #line 2766 "config/rx-parse.c"
2766 break;
2767
2768 case 51:
2769 #line 457 "./config/rx-parse.y"
2770 { B2 (0x78, 0); FE ((yyvsp[-2].exp), 7, 5); F ((yyvsp[0].regno), 12, 4); }
2771 #line 2772 "config/rx-parse.c"
2772 break;
2773
2774 case 52:
2775 #line 459 "./config/rx-parse.y"
2776 { B2 (0x7a, 0); FE ((yyvsp[-2].exp), 7, 5); F ((yyvsp[0].regno), 12, 4); }
2777 #line 2778 "config/rx-parse.c"
2778 break;
2779
2780 case 53:
2781 #line 464 "./config/rx-parse.y"
2782 { B2 (0x7c, 0x00); FE ((yyvsp[-2].exp), 7, 5); F ((yyvsp[0].regno), 12, 4); }
2783 #line 2784 "config/rx-parse.c"
2784 break;
2785
2786 case 54:
2787 #line 469 "./config/rx-parse.y"
2788 { B2 (0x7e, 0x30); F ((yyvsp[0].regno), 12, 4); }
2789 #line 2790 "config/rx-parse.c"
2790 break;
2791
2792 case 55:
2793 #line 471 "./config/rx-parse.y"
2794 { B2 (0x7e, 0x40); F ((yyvsp[0].regno), 12, 4); }
2795 #line 2796 "config/rx-parse.c"
2796 break;
2797
2798 case 56:
2799 #line 473 "./config/rx-parse.y"
2800 { B2 (0x7e, 0x50); F ((yyvsp[0].regno), 12, 4); }
2801 #line 2802 "config/rx-parse.c"
2802 break;
2803
2804 case 57:
2805 #line 478 "./config/rx-parse.y"
2806 { B2 (0x7e, 0x80); F ((yyvsp[-1].regno), 10, 2); F ((yyvsp[0].regno), 12, 4); }
2807 #line 2808 "config/rx-parse.c"
2808 break;
2809
2810 case 58:
2811 #line 483 "./config/rx-parse.y"
2812 { B2 (0x7e, 0xb0); F ((yyvsp[0].regno), 12, 4); }
2813 #line 2814 "config/rx-parse.c"
2814 break;
2815
2816 case 59:
2817 #line 488 "./config/rx-parse.y"
2818 { if ((yyvsp[0].regno) == 13)
2819 { rx_check_v2 (); }
2820 if ((yyvsp[0].regno) < 16)
2821 { B2 (0x7e, 0xc0); F ((yyvsp[0].regno), 12, 4); }
2822 else
2823 as_bad (_("PUSHC can only push the first 16 control registers")); }
2824 #line 2825 "config/rx-parse.c"
2825 break;
2826
2827 case 60:
2828 #line 498 "./config/rx-parse.y"
2829 { if ((yyvsp[0].regno) == 13)
2830 { rx_check_v2 (); }
2831 if ((yyvsp[0].regno) < 16)
2832 { B2 (0x7e, 0xe0); F ((yyvsp[0].regno), 12, 4); }
2833 else
2834 as_bad (_("POPC can only pop the first 16 control registers")); }
2835 #line 2836 "config/rx-parse.c"
2836 break;
2837
2838 case 61:
2839 #line 508 "./config/rx-parse.y"
2840 { B2 (0x7f, 0xa0); F ((yyvsp[0].regno), 12, 4); }
2841 #line 2842 "config/rx-parse.c"
2842 break;
2843
2844 case 62:
2845 #line 510 "./config/rx-parse.y"
2846 { B2 (0x7f, 0xb0); F ((yyvsp[0].regno), 12, 4); }
2847 #line 2848 "config/rx-parse.c"
2848 break;
2849
2850 case 63:
2851 #line 515 "./config/rx-parse.y"
2852 { B2 (0x7f, 0x00); F ((yyvsp[0].regno), 12, 4); }
2853 #line 2854 "config/rx-parse.c"
2854 break;
2855
2856 case 64:
2857 #line 517 "./config/rx-parse.y"
2858 { B2 (0x7f, 0x10); F ((yyvsp[0].regno), 12, 4); }
2859 #line 2860 "config/rx-parse.c"
2860 break;
2861
2862 case 65:
2863 #line 519 "./config/rx-parse.y"
2864 { B2 (0x7f, 0x40); F ((yyvsp[0].regno), 12, 4); }
2865 #line 2866 "config/rx-parse.c"
2866 break;
2867
2868 case 66:
2869 #line 521 "./config/rx-parse.y"
2870 { B2 (0x7f, 0x50); F ((yyvsp[0].regno), 12, 4); }
2871 #line 2872 "config/rx-parse.c"
2872 break;
2873
2874 case 67:
2875 #line 526 "./config/rx-parse.y"
2876 { B2 (0x7f, 0x83); rx_note_string_insn_use (); }
2877 #line 2878 "config/rx-parse.c"
2878 break;
2879
2880 case 68:
2881 #line 528 "./config/rx-parse.y"
2882 { B2 (0x7f, 0x87); rx_note_string_insn_use (); }
2883 #line 2884 "config/rx-parse.c"
2884 break;
2885
2886 case 69:
2887 #line 530 "./config/rx-parse.y"
2888 { B2 (0x7f, 0x8b); rx_note_string_insn_use (); }
2889 #line 2890 "config/rx-parse.c"
2890 break;
2891
2892 case 70:
2893 #line 532 "./config/rx-parse.y"
2894 { B2 (0x7f, 0x8f); rx_note_string_insn_use (); }
2895 #line 2896 "config/rx-parse.c"
2896 break;
2897
2898 case 71:
2899 #line 537 "./config/rx-parse.y"
2900 { B2 (0x7f, 0x80); F ((yyvsp[0].regno), 14, 2); rx_note_string_insn_use (); }
2901 #line 2902 "config/rx-parse.c"
2902 break;
2903
2904 case 72:
2905 #line 539 "./config/rx-parse.y"
2906 { B2 (0x7f, 0x84); F ((yyvsp[0].regno), 14, 2); rx_note_string_insn_use (); }
2907 #line 2908 "config/rx-parse.c"
2908 break;
2909
2910 case 73:
2911 #line 541 "./config/rx-parse.y"
2912 { B2 (0x7f, 0x88); F ((yyvsp[0].regno), 14, 2); }
2913 #line 2914 "config/rx-parse.c"
2914 break;
2915
2916 case 74:
2917 #line 546 "./config/rx-parse.y"
2918 { B2 (0x7f, 0x8c); F ((yyvsp[0].regno), 14, 2); rx_note_string_insn_use (); }
2919 #line 2920 "config/rx-parse.c"
2920 break;
2921
2922 case 75:
2923 #line 551 "./config/rx-parse.y"
2924 { B2 (0x7f, 0x94); }
2925 #line 2926 "config/rx-parse.c"
2926 break;
2927
2928 case 76:
2929 #line 553 "./config/rx-parse.y"
2930 { B2 (0x7f, 0x95); }
2931 #line 2932 "config/rx-parse.c"
2932 break;
2933
2934 case 77:
2935 #line 555 "./config/rx-parse.y"
2936 { B2 (0x7f, 0x96); }
2937 #line 2938 "config/rx-parse.c"
2938 break;
2939
2940 case 78:
2941 #line 557 "./config/rx-parse.y"
2942 { B2 (0x7f, 0x93); }
2943 #line 2944 "config/rx-parse.c"
2944 break;
2945
2946 case 79:
2947 #line 562 "./config/rx-parse.y"
2948 { B3 (0x75, 0x70, 0x00); FE ((yyvsp[0].exp), 20, 4); }
2949 #line 2950 "config/rx-parse.c"
2950 break;
2951
2952 case 80:
2953 #line 568 "./config/rx-parse.y"
2954 { if ((yyvsp[-5].regno) <= 7 && (yyvsp[-1].regno) <= 7 && rx_disp5op (&(yyvsp[-3].exp), (yyvsp[-6].regno)))
2955 { B2 (0x80, 0); F ((yyvsp[-6].regno), 2, 2); F ((yyvsp[-1].regno), 9, 3); F ((yyvsp[-5].regno), 13, 3); rx_field5s ((yyvsp[-3].exp)); }
2956 else
2957 { B2 (0xc3, 0x00); F ((yyvsp[-6].regno), 2, 2); F ((yyvsp[-1].regno), 8, 4); F ((yyvsp[-5].regno), 12, 4); DSP ((yyvsp[-3].exp), 4, (yyvsp[-6].regno)); }}
2958 #line 2959 "config/rx-parse.c"
2959 break;
2960
2961 case 81:
2962 #line 576 "./config/rx-parse.y"
2963 { if ((yyvsp[-3].regno) <= 7 && (yyvsp[0].regno) <= 7 && rx_disp5op (&(yyvsp[-5].exp), (yyvsp[-6].regno)))
2964 { B2 (0x88, 0); F ((yyvsp[-6].regno), 2, 2); F ((yyvsp[-3].regno), 9, 3); F ((yyvsp[0].regno), 13, 3); rx_field5s ((yyvsp[-5].exp)); }
2965 else
2966 { B2 (0xcc, 0x00); F ((yyvsp[-6].regno), 2, 2); F ((yyvsp[-3].regno), 8, 4); F ((yyvsp[0].regno), 12, 4); DSP ((yyvsp[-5].exp), 6, (yyvsp[-6].regno)); } }
2967 #line 2968 "config/rx-parse.c"
2968 break;
2969
2970 case 82:
2971 #line 590 "./config/rx-parse.y"
2972 { B2 (0xc3, 0x00); F ((yyvsp[-5].regno), 2, 2); F ((yyvsp[-1].regno), 8, 4); F ((yyvsp[-4].regno), 12, 4); }
2973 #line 2974 "config/rx-parse.c"
2974 break;
2975
2976 case 83:
2977 #line 595 "./config/rx-parse.y"
2978 { B2 (0xc0, 0); F ((yyvsp[-8].regno), 2, 2); F ((yyvsp[-6].regno), 8, 4); F ((yyvsp[-1].regno), 12, 4); DSP ((yyvsp[-3].exp), 4, (yyvsp[-8].regno)); }
2979 #line 2980 "config/rx-parse.c"
2980 break;
2981
2982 case 84:
2983 #line 600 "./config/rx-parse.y"
2984 { B2 (0xc0, 0x00); F ((yyvsp[-9].regno), 2, 2); F ((yyvsp[-6].regno), 8, 4); F ((yyvsp[-1].regno), 12, 4); DSP ((yyvsp[-8].exp), 6, (yyvsp[-9].regno)); DSP ((yyvsp[-3].exp), 4, (yyvsp[-9].regno)); }
2985 #line 2986 "config/rx-parse.c"
2986 break;
2987
2988 case 85:
2989 #line 605 "./config/rx-parse.y"
2990 { B2 (0xcf, 0x00); F ((yyvsp[-3].regno), 2, 2); F ((yyvsp[-2].regno), 8, 4); F ((yyvsp[0].regno), 12, 4); }
2991 #line 2992 "config/rx-parse.c"
2992 break;
2993
2994 case 86:
2995 #line 610 "./config/rx-parse.y"
2996 { B2 (0xcc, 0x00); F ((yyvsp[-5].regno), 2, 2); F ((yyvsp[-3].regno), 8, 4); F ((yyvsp[0].regno), 12, 4); }
2997 #line 2998 "config/rx-parse.c"
2998 break;
2999
3000 case 87:
3001 #line 615 "./config/rx-parse.y"
3002 { B2 (0xf0, 0x00); F ((yyvsp[-2].regno), 8, 4); FE ((yyvsp[-6].exp), 13, 3); DSP ((yyvsp[-4].exp), 6, BSIZE); }
3003 #line 3004 "config/rx-parse.c"
3004 break;
3005
3006 case 88:
3007 #line 617 "./config/rx-parse.y"
3008 { B2 (0xf0, 0x08); F ((yyvsp[-2].regno), 8, 4); FE ((yyvsp[-6].exp), 13, 3); DSP ((yyvsp[-4].exp), 6, BSIZE); }
3009 #line 3010 "config/rx-parse.c"
3010 break;
3011
3012 case 89:
3013 #line 619 "./config/rx-parse.y"
3014 { B2 (0xf4, 0x00); F ((yyvsp[-2].regno), 8, 4); FE ((yyvsp[-6].exp), 13, 3); DSP ((yyvsp[-4].exp), 6, BSIZE); }
3015 #line 3016 "config/rx-parse.c"
3016 break;
3017
3018 case 90:
3019 #line 624 "./config/rx-parse.y"
3020 { B2 (0xf4, 0x08); F ((yyvsp[-4].regno), 14, 2); F ((yyvsp[-1].regno), 8, 4); DSP ((yyvsp[-3].exp), 6, (yyvsp[-4].regno)); }
3021 #line 3022 "config/rx-parse.c"
3022 break;
3023
3024 case 91:
3025 #line 628 "./config/rx-parse.y"
3026 { sub_op = 0; }
3027 #line 3028 "config/rx-parse.c"
3028 break;
3029
3030 case 93:
3031 #line 629 "./config/rx-parse.y"
3032 { sub_op = 1; sub_op2 = 1; }
3033 #line 3034 "config/rx-parse.c"
3034 break;
3035
3036 case 95:
3037 #line 630 "./config/rx-parse.y"
3038 { sub_op = 2; }
3039 #line 3040 "config/rx-parse.c"
3040 break;
3041
3042 case 97:
3043 #line 631 "./config/rx-parse.y"
3044 { sub_op = 3; sub_op2 = 2; }
3045 #line 3046 "config/rx-parse.c"
3046 break;
3047
3048 case 99:
3049 #line 632 "./config/rx-parse.y"
3050 { sub_op = 4; }
3051 #line 3052 "config/rx-parse.c"
3052 break;
3053
3054 case 101:
3055 #line 633 "./config/rx-parse.y"
3056 { sub_op = 5; }
3057 #line 3058 "config/rx-parse.c"
3058 break;
3059
3060 case 103:
3061 #line 634 "./config/rx-parse.y"
3062 { sub_op = 6; }
3063 #line 3064 "config/rx-parse.c"
3064 break;
3065
3066 case 105:
3067 #line 635 "./config/rx-parse.y"
3068 { sub_op = 7; }
3069 #line 3070 "config/rx-parse.c"
3070 break;
3071
3072 case 107:
3073 #line 636 "./config/rx-parse.y"
3074 { sub_op = 8; }
3075 #line 3076 "config/rx-parse.c"
3076 break;
3077
3078 case 109:
3079 #line 637 "./config/rx-parse.y"
3080 { sub_op = 9; }
3081 #line 3082 "config/rx-parse.c"
3082 break;
3083
3084 case 111:
3085 #line 638 "./config/rx-parse.y"
3086 { sub_op = 12; }
3087 #line 3088 "config/rx-parse.c"
3088 break;
3089
3090 case 113:
3091 #line 639 "./config/rx-parse.y"
3092 { sub_op = 13; }
3093 #line 3094 "config/rx-parse.c"
3094 break;
3095
3096 case 115:
3097 #line 640 "./config/rx-parse.y"
3098 { sub_op = 14; sub_op2 = 0; }
3099 #line 3100 "config/rx-parse.c"
3100 break;
3101
3102 case 117:
3103 #line 641 "./config/rx-parse.y"
3104 { sub_op = 14; sub_op2 = 0; }
3105 #line 3106 "config/rx-parse.c"
3106 break;
3107
3108 case 119:
3109 #line 642 "./config/rx-parse.y"
3110 { sub_op = 15; sub_op2 = 1; }
3111 #line 3112 "config/rx-parse.c"
3112 break;
3113
3114 case 121:
3115 #line 646 "./config/rx-parse.y"
3116 { sub_op = 6; }
3117 #line 3118 "config/rx-parse.c"
3118 break;
3119
3120 case 123:
3121 #line 647 "./config/rx-parse.y"
3122 { sub_op = 7; }
3123 #line 3124 "config/rx-parse.c"
3124 break;
3125
3126 case 125:
3127 #line 648 "./config/rx-parse.y"
3128 { sub_op = 16; }
3129 #line 3130 "config/rx-parse.c"
3130 break;
3131
3132 case 127:
3133 #line 649 "./config/rx-parse.y"
3134 { sub_op = 17; }
3135 #line 3136 "config/rx-parse.c"
3136 break;
3137
3138 case 129:
3139 #line 650 "./config/rx-parse.y"
3140 { sub_op = 21; }
3141 #line 3142 "config/rx-parse.c"
3142 break;
3143
3144 case 131:
3145 #line 655 "./config/rx-parse.y"
3146 { id24 (1, 0x63, 0x00); F ((yyvsp[0].regno), 16, 4); F ((yyvsp[-2].regno), 20, 4); }
3147 #line 3148 "config/rx-parse.c"
3148 break;
3149
3150 case 132:
3151 #line 657 "./config/rx-parse.y"
3152 { id24 (1, 0x67, 0x00); F ((yyvsp[0].regno), 16, 4); F ((yyvsp[-2].regno), 20, 4); }
3153 #line 3154 "config/rx-parse.c"
3154 break;
3155
3156 case 133:
3157 #line 659 "./config/rx-parse.y"
3158 { id24 (1, 0x6b, 0x00); F ((yyvsp[0].regno), 16, 4); F ((yyvsp[-2].regno), 20, 4); }
3159 #line 3160 "config/rx-parse.c"
3160 break;
3161
3162 case 134:
3163 #line 661 "./config/rx-parse.y"
3164 { id24 (1, 0x6f, 0x00); F ((yyvsp[0].regno), 16, 4); F ((yyvsp[-2].regno), 20, 4); }
3165 #line 3166 "config/rx-parse.c"
3166 break;
3167
3168 case 135:
3169 #line 664 "./config/rx-parse.y"
3170 { id24 (1, 0x60, 0x00); F ((yyvsp[-2].regno), 16, 4); F ((yyvsp[-6].regno), 20, 4); DSP ((yyvsp[-4].exp), 14, BSIZE); }
3171 #line 3172 "config/rx-parse.c"
3172 break;
3173
3174 case 136:
3175 #line 666 "./config/rx-parse.y"
3176 { id24 (1, 0x64, 0x00); F ((yyvsp[-2].regno), 16, 4); F ((yyvsp[-6].regno), 20, 4); DSP ((yyvsp[-4].exp), 14, BSIZE); }
3177 #line 3178 "config/rx-parse.c"
3178 break;
3179
3180 case 137:
3181 #line 668 "./config/rx-parse.y"
3182 { id24 (1, 0x68, 0x00); F ((yyvsp[-2].regno), 16, 4); F ((yyvsp[-6].regno), 20, 4); DSP ((yyvsp[-4].exp), 14, BSIZE); }
3183 #line 3184 "config/rx-parse.c"
3184 break;
3185
3186 case 138:
3187 #line 670 "./config/rx-parse.y"
3188 { id24 (1, 0x6c, 0x00); F ((yyvsp[-2].regno), 16, 4); F ((yyvsp[-6].regno), 20, 4); DSP ((yyvsp[-4].exp), 14, BSIZE); }
3189 #line 3190 "config/rx-parse.c"
3190 break;
3191
3192 case 139:
3193 #line 674 "./config/rx-parse.y"
3194 { sub_op = 0; }
3195 #line 3196 "config/rx-parse.c"
3196 break;
3197
3198 case 141:
3199 #line 675 "./config/rx-parse.y"
3200 { sub_op = 1; }
3201 #line 3202 "config/rx-parse.c"
3202 break;
3203
3204 case 143:
3205 #line 676 "./config/rx-parse.y"
3206 { sub_op = 2; }
3207 #line 3208 "config/rx-parse.c"
3208 break;
3209
3210 case 145:
3211 #line 677 "./config/rx-parse.y"
3212 { sub_op = 3; }
3213 #line 3214 "config/rx-parse.c"
3214 break;
3215
3216 case 147:
3217 #line 678 "./config/rx-parse.y"
3218 { sub_op = 4; }
3219 #line 3220 "config/rx-parse.c"
3220 break;
3221
3222 case 149:
3223 #line 679 "./config/rx-parse.y"
3224 { sub_op = 8; }
3225 #line 3226 "config/rx-parse.c"
3226 break;
3227
3228 case 151:
3229 #line 680 "./config/rx-parse.y"
3230 { sub_op = 5; }
3231 #line 3232 "config/rx-parse.c"
3232 break;
3233
3234 case 153:
3235 #line 681 "./config/rx-parse.y"
3236 { sub_op = 9; }
3237 #line 3238 "config/rx-parse.c"
3238 break;
3239
3240 case 155:
3241 #line 682 "./config/rx-parse.y"
3242 { sub_op = 6; }
3243 #line 3244 "config/rx-parse.c"
3244 break;
3245
3246 case 157:
3247 #line 690 "./config/rx-parse.y"
3248 { id24 (1, 0xdb, 0x00); F ((yyvsp[-2].regno), 20, 4); F ((yyvsp[0].regno), 16, 4); }
3249 #line 3250 "config/rx-parse.c"
3250 break;
3251
3252 case 158:
3253 #line 692 "./config/rx-parse.y"
3254 { id24 (1, 0xd0, 0x00); F ((yyvsp[-5].regno), 20, 4); F ((yyvsp[-4].regno), 12, 2); F ((yyvsp[-1].regno), 16, 4); DSP ((yyvsp[-3].exp), 14, (yyvsp[-4].regno)); }
3255 #line 3256 "config/rx-parse.c"
3256 break;
3257
3258 case 159:
3259 #line 697 "./config/rx-parse.y"
3260 { id24 (1, 0xe0, 0x00); F ((yyvsp[-8].regno), 20, 4); FE ((yyvsp[-6].exp), 11, 3);
3261 F ((yyvsp[-2].regno), 16, 4); DSP ((yyvsp[-4].exp), 14, BSIZE); }
3262 #line 3263 "config/rx-parse.c"
3263 break;
3264
3265 case 160:
3266 #line 703 "./config/rx-parse.y"
3267 { id24 (1, 0xe0, 0x0f); FE ((yyvsp[-6].exp), 11, 3); F ((yyvsp[-2].regno), 16, 4);
3268 DSP ((yyvsp[-4].exp), 14, BSIZE); }
3269 #line 3270 "config/rx-parse.c"
3270 break;
3271
3272 case 161:
3273 #line 709 "./config/rx-parse.y"
3274 { id24 (2, 0x00, 0x00); F ((yyvsp[-2].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); }
3275 #line 3276 "config/rx-parse.c"
3276 break;
3277
3278 case 162:
3279 #line 711 "./config/rx-parse.y"
3280 { rx_check_v2 (); id24 (2, 0x00, 0x00); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[-2].regno), 20, 4); F ((yyvsp[0].regno), 12, 1); }
3281 #line 3282 "config/rx-parse.c"
3282 break;
3283
3284 case 163:
3285 #line 713 "./config/rx-parse.y"
3286 { id24 (2, 0x01, 0x00); F ((yyvsp[-2].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); }
3287 #line 3288 "config/rx-parse.c"
3288 break;
3289
3290 case 164:
3291 #line 715 "./config/rx-parse.y"
3292 { rx_check_v2 (); id24 (2, 0x01, 0x00); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[-2].regno), 20, 4); F ((yyvsp[0].regno), 12, 1); }
3293 #line 3294 "config/rx-parse.c"
3294 break;
3295
3296 case 165:
3297 #line 717 "./config/rx-parse.y"
3298 { id24 (2, 0x04, 0x00); F ((yyvsp[-2].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); }
3299 #line 3300 "config/rx-parse.c"
3300 break;
3301
3302 case 166:
3303 #line 719 "./config/rx-parse.y"
3304 { rx_check_v2 (); id24 (2, 0x04, 0x00); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[-2].regno), 20, 4); F ((yyvsp[0].regno), 12, 1); }
3305 #line 3306 "config/rx-parse.c"
3306 break;
3307
3308 case 167:
3309 #line 721 "./config/rx-parse.y"
3310 { id24 (2, 0x05, 0x00); F ((yyvsp[-2].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); }
3311 #line 3312 "config/rx-parse.c"
3312 break;
3313
3314 case 168:
3315 #line 723 "./config/rx-parse.y"
3316 { rx_check_v2 (); id24 (2, 0x05, 0x00); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[-2].regno), 20, 4); F ((yyvsp[0].regno), 12, 1); }
3317 #line 3318 "config/rx-parse.c"
3318 break;
3319
3320 case 169:
3321 #line 729 "./config/rx-parse.y"
3322 { id24 (2, 0x17, 0x00); F ((yyvsp[0].regno), 20, 4); }
3323 #line 3324 "config/rx-parse.c"
3324 break;
3325
3326 case 170:
3327 #line 731 "./config/rx-parse.y"
3328 { rx_check_v2 (); id24 (2, 0x17, 0x00); F ((yyvsp[-2].regno), 20, 4); F ((yyvsp[0].regno), 16, 1); }
3329 #line 3330 "config/rx-parse.c"
3330 break;
3331
3332 case 171:
3333 #line 733 "./config/rx-parse.y"
3334 { id24 (2, 0x17, 0x10); F ((yyvsp[0].regno), 20, 4); }
3335 #line 3336 "config/rx-parse.c"
3336 break;
3337
3338 case 172:
3339 #line 735 "./config/rx-parse.y"
3340 { rx_check_v2 (); id24 (2, 0x17, 0x10); F ((yyvsp[-2].regno), 20, 4); F ((yyvsp[0].regno), 16, 1); }
3341 #line 3342 "config/rx-parse.c"
3342 break;
3343
3344 case 173:
3345 #line 737 "./config/rx-parse.y"
3346 { id24 (2, 0x1f, 0x00); F ((yyvsp[0].regno), 20, 4); }
3347 #line 3348 "config/rx-parse.c"
3348 break;
3349
3350 case 174:
3351 #line 738 "./config/rx-parse.y"
3352 { sub_op = 0; }
3353 #line 3354 "config/rx-parse.c"
3354 break;
3355
3356 case 176:
3357 #line 740 "./config/rx-parse.y"
3358 { id24 (2, 0x1f, 0x20); F ((yyvsp[0].regno), 20, 4); }
3359 #line 3360 "config/rx-parse.c"
3360 break;
3361
3362 case 177:
3363 #line 741 "./config/rx-parse.y"
3364 { sub_op = 2; }
3365 #line 3366 "config/rx-parse.c"
3366 break;
3367
3368 case 179:
3369 #line 743 "./config/rx-parse.y"
3370 { id24 (2, 0x1f, 0x10); F ((yyvsp[0].regno), 20, 4); }
3371 #line 3372 "config/rx-parse.c"
3372 break;
3373
3374 case 180:
3375 #line 744 "./config/rx-parse.y"
3376 { sub_op = 1; }
3377 #line 3378 "config/rx-parse.c"
3378 break;
3379
3380 case 182:
3381 #line 746 "./config/rx-parse.y"
3382 { id24 (2, 0x18, 0x00);
3383 if (rx_uintop ((yyvsp[0].exp), 4) && exp_val((yyvsp[0].exp)) == 1)
3384 ;
3385 else if (rx_uintop ((yyvsp[0].exp), 4) && exp_val((yyvsp[0].exp)) == 2)
3386 F (1, 19, 1);
3387 else
3388 as_bad (_("RACW expects #1 or #2"));}
3389 #line 3390 "config/rx-parse.c"
3390 break;
3391
3392 case 183:
3393 #line 754 "./config/rx-parse.y"
3394 { rx_check_v2 (); id24 (2, 0x18, 0x00); F ((yyvsp[0].regno), 16, 1);
3395 if (rx_uintop ((yyvsp[-2].exp), 4) && exp_val((yyvsp[-2].exp)) == 1)
3396 ;
3397 else if (rx_uintop ((yyvsp[-2].exp), 4) && exp_val((yyvsp[-2].exp)) == 2)
3398 F (1, 19, 1);
3399 else
3400 as_bad (_("RACW expects #1 or #2"));}
3401 #line 3402 "config/rx-parse.c"
3402 break;
3403
3404 case 184:
3405 #line 765 "./config/rx-parse.y"
3406 { id24 (2, 0x20, 0); F ((yyvsp[-6].regno), 14, 2); F ((yyvsp[-2].regno), 16, 4); F ((yyvsp[-5].regno), 20, 4); }
3407 #line 3408 "config/rx-parse.c"
3408 break;
3409
3410 case 185:
3411 #line 767 "./config/rx-parse.y"
3412 { id24 (2, 0x24, 0); F ((yyvsp[-6].regno), 14, 2); F ((yyvsp[-1].regno), 16, 4); F ((yyvsp[-5].regno), 20, 4); }
3413 #line 3414 "config/rx-parse.c"
3414 break;
3415
3416 case 186:
3417 #line 772 "./config/rx-parse.y"
3418 { id24 (2, 0x28, 0); F ((yyvsp[-6].regno), 14, 2); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); }
3419 #line 3420 "config/rx-parse.c"
3420 break;
3421
3422 case 187:
3423 #line 774 "./config/rx-parse.y"
3424 { id24 (2, 0x2c, 0); F ((yyvsp[-6].regno), 14, 2); F ((yyvsp[-3].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); }
3425 #line 3426 "config/rx-parse.c"
3426 break;
3427
3428 case 188:
3429 #line 779 "./config/rx-parse.y"
3430 { id24 (2, 0x38, 0); F ((yyvsp[-6].regno), 15, 1); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); }
3431 #line 3432 "config/rx-parse.c"
3432 break;
3433
3434 case 189:
3435 #line 781 "./config/rx-parse.y"
3436 { id24 (2, 0x3c, 0); F ((yyvsp[-6].regno), 15, 1); F ((yyvsp[-3].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); }
3437 #line 3438 "config/rx-parse.c"
3438 break;
3439
3440 case 190:
3441 #line 785 "./config/rx-parse.y"
3442 { sub_op = 6; }
3443 #line 3444 "config/rx-parse.c"
3444 break;
3445
3446 case 192:
3447 #line 786 "./config/rx-parse.y"
3448 { sub_op = 4; }
3449 #line 3450 "config/rx-parse.c"
3450 break;
3451
3452 case 194:
3453 #line 787 "./config/rx-parse.y"
3454 { sub_op = 5; }
3455 #line 3456 "config/rx-parse.c"
3456 break;
3457
3458 case 196:
3459 #line 788 "./config/rx-parse.y"
3460 { sub_op = 7; }
3461 #line 3462 "config/rx-parse.c"
3462 break;
3463
3464 case 198:
3465 #line 793 "./config/rx-parse.y"
3466 { if ((yyvsp[0].regno) == 13)
3467 rx_check_v2 ();
3468 id24 (2, 0x68, 0x00); F ((yyvsp[0].regno) % 16, 20, 4); F ((yyvsp[0].regno) / 16, 15, 1);
3469 F ((yyvsp[-2].regno), 16, 4); }
3470 #line 3471 "config/rx-parse.c"
3471 break;
3472
3473 case 199:
3474 #line 801 "./config/rx-parse.y"
3475 { if ((yyvsp[-2].regno) == 13)
3476 rx_check_v2 ();
3477 id24 (2, 0x6a, 0); F ((yyvsp[-2].regno), 15, 5); F ((yyvsp[0].regno), 20, 4); }
3478 #line 3479 "config/rx-parse.c"
3479 break;
3480
3481 case 200:
3482 #line 808 "./config/rx-parse.y"
3483 { id24 (2, 0x6e, 0); FE ((yyvsp[-2].exp), 15, 5); F ((yyvsp[0].regno), 20, 4); }
3484 #line 3485 "config/rx-parse.c"
3485 break;
3486
3487 case 201:
3488 #line 810 "./config/rx-parse.y"
3489 { id24 (2, 0x6c, 0); FE ((yyvsp[-2].exp), 15, 5); F ((yyvsp[0].regno), 20, 4); }
3490 #line 3491 "config/rx-parse.c"
3491 break;
3492
3493 case 202:
3494 #line 815 "./config/rx-parse.y"
3495 { if ((yyvsp[0].regno) == 13)
3496 rx_check_v2 ();
3497 id24 (2, 0x73, 0x00); F ((yyvsp[0].regno), 19, 5); IMM ((yyvsp[-2].exp), 12); }
3498 #line 3499 "config/rx-parse.c"
3499 break;
3500
3501 case 203:
3502 #line 822 "./config/rx-parse.y"
3503 { id24 (2, 0xe0, 0x00); F ((yyvsp[-4].regno), 16, 4); FE ((yyvsp[-2].exp), 11, 5);
3504 F ((yyvsp[0].regno), 20, 4); }
3505 #line 3506 "config/rx-parse.c"
3506 break;
3507
3508 case 204:
3509 #line 828 "./config/rx-parse.y"
3510 { id24 (2, 0xe0, 0xf0); FE ((yyvsp[-2].exp), 11, 5); F ((yyvsp[0].regno), 20, 4); }
3511 #line 3512 "config/rx-parse.c"
3512 break;
3513
3514 case 205:
3515 #line 833 "./config/rx-parse.y"
3516 { id24 (3, 0x00, 0); F ((yyvsp[-7].regno), 10, 2); F ((yyvsp[-3].regno), 12, 4); F ((yyvsp[-1].regno), 16, 4); F ((yyvsp[-6].regno), 20, 4); }
3517 #line 3518 "config/rx-parse.c"
3518 break;
3519
3520 case 206:
3521 #line 836 "./config/rx-parse.y"
3522 { id24 (3, 0x40, 0); F ((yyvsp[-7].regno), 10, 2); F ((yyvsp[-5].regno), 12, 4); F ((yyvsp[-3].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); }
3523 #line 3524 "config/rx-parse.c"
3524 break;
3525
3526 case 207:
3527 #line 839 "./config/rx-parse.y"
3528 { id24 (3, 0xc0, 0); F ((yyvsp[-7].regno), 10, 2); F ((yyvsp[-5].regno), 12, 4); F ((yyvsp[-3].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); }
3529 #line 3530 "config/rx-parse.c"
3530 break;
3531
3532 case 208:
3533 #line 843 "./config/rx-parse.y"
3534 { sub_op = 0; }
3535 #line 3536 "config/rx-parse.c"
3536 break;
3537
3538 case 210:
3539 #line 844 "./config/rx-parse.y"
3540 { sub_op = 2; }
3541 #line 3542 "config/rx-parse.c"
3542 break;
3543
3544 case 212:
3545 #line 845 "./config/rx-parse.y"
3546 { sub_op = 3; }
3547 #line 3548 "config/rx-parse.c"
3548 break;
3549
3550 case 214:
3551 #line 846 "./config/rx-parse.y"
3552 { sub_op = 4; }
3553 #line 3554 "config/rx-parse.c"
3554 break;
3555
3556 case 216:
3557 #line 847 "./config/rx-parse.y"
3558 { sub_op = 5; }
3559 #line 3560 "config/rx-parse.c"
3560 break;
3561
3562 case 218:
3563 #line 853 "./config/rx-parse.y"
3564 { id24 (2, 0x70, 0x20); F ((yyvsp[0].regno), 20, 4); NBIMM ((yyvsp[-2].exp), 12); }
3565 #line 3566 "config/rx-parse.c"
3566 break;
3567
3568 case 219:
3569 #line 858 "./config/rx-parse.y"
3570 { rx_check_v2 (); B3 (0xfd, 0x27, 0x00); F ((yyvsp[-1].regno), 16, 4); F ((yyvsp[-4].regno), 20, 4); }
3571 #line 3572 "config/rx-parse.c"
3572 break;
3573
3574 case 220:
3575 #line 863 "./config/rx-parse.y"
3576 { rx_check_v2 (); B3 (0xfd, 0x2f, 0x00); F ((yyvsp[-3].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); }
3577 #line 3578 "config/rx-parse.c"
3578 break;
3579
3580 case 221:
3581 #line 868 "./config/rx-parse.y"
3582 { rx_check_v2 (); id24 (2, 0x07, 0x00); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[-2].regno), 20, 4); F ((yyvsp[0].regno), 12, 1); }
3583 #line 3584 "config/rx-parse.c"
3584 break;
3585
3586 case 222:
3587 #line 870 "./config/rx-parse.y"
3588 { rx_check_v2 (); id24 (2, 0x47, 0x00); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[-2].regno), 20, 4); F ((yyvsp[0].regno), 12, 1); }
3589 #line 3590 "config/rx-parse.c"
3590 break;
3591
3592 case 223:
3593 #line 872 "./config/rx-parse.y"
3594 { rx_check_v2 (); id24 (2, 0x03, 0x00); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[-2].regno), 20, 4); F ((yyvsp[0].regno), 12, 1); }
3595 #line 3596 "config/rx-parse.c"
3596 break;
3597
3598 case 224:
3599 #line 874 "./config/rx-parse.y"
3600 { rx_check_v2 (); id24 (2, 0x06, 0x00); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[-2].regno), 20, 4); F ((yyvsp[0].regno), 12, 1); }
3601 #line 3602 "config/rx-parse.c"
3602 break;
3603
3604 case 225:
3605 #line 876 "./config/rx-parse.y"
3606 { rx_check_v2 (); id24 (2, 0x44, 0x00); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[-2].regno), 20, 4); F ((yyvsp[0].regno), 12, 1); }
3607 #line 3608 "config/rx-parse.c"
3608 break;
3609
3610 case 226:
3611 #line 878 "./config/rx-parse.y"
3612 { rx_check_v2 (); id24 (2, 0x46, 0x00); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[-2].regno), 20, 4); F ((yyvsp[0].regno), 12, 1); }
3613 #line 3614 "config/rx-parse.c"
3614 break;
3615
3616 case 227:
3617 #line 880 "./config/rx-parse.y"
3618 { rx_check_v2 (); id24 (2, 0x45, 0x00); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[-2].regno), 20, 4); F ((yyvsp[0].regno), 12, 1); }
3619 #line 3620 "config/rx-parse.c"
3620 break;
3621
3622 case 228:
3623 #line 882 "./config/rx-parse.y"
3624 { rx_check_v2 (); id24 (2, 0x02, 0x00); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[-2].regno), 20, 4); F ((yyvsp[0].regno), 12, 1); }
3625 #line 3626 "config/rx-parse.c"
3626 break;
3627
3628 case 229:
3629 #line 883 "./config/rx-parse.y"
3630 { sub_op = 3; }
3631 #line 3632 "config/rx-parse.c"
3632 break;
3633
3634 case 231:
3635 #line 885 "./config/rx-parse.y"
3636 { rx_check_v2 (); id24 (2, 0x17, 0x30); F ((yyvsp[0].regno), 16, 1); F ((yyvsp[-2].regno), 20, 4); }
3637 #line 3638 "config/rx-parse.c"
3638 break;
3639
3640 case 232:
3641 #line 887 "./config/rx-parse.y"
3642 { rx_check_v2 (); id24 (2, 0x19, 0x00); F ((yyvsp[0].regno), 16, 1);
3643 if (rx_uintop ((yyvsp[-2].exp), 4) && (yyvsp[-2].exp).X_add_number == 1)
3644 ;
3645 else if (rx_uintop ((yyvsp[-2].exp), 4) && (yyvsp[-2].exp).X_add_number == 2)
3646 F (1, 19, 1);
3647 else
3648 as_bad (_("RACL expects #1 or #2"));}
3649 #line 3650 "config/rx-parse.c"
3650 break;
3651
3652 case 233:
3653 #line 895 "./config/rx-parse.y"
3654 { rx_check_v2 (); id24 (2, 0x19, 0x40); F ((yyvsp[0].regno), 16, 1);
3655 if (rx_uintop ((yyvsp[-2].exp), 4) && (yyvsp[-2].exp).X_add_number == 1)
3656 ;
3657 else if (rx_uintop ((yyvsp[-2].exp), 4) && (yyvsp[-2].exp).X_add_number == 2)
3658 F (1, 19, 1);
3659 else
3660 as_bad (_("RDACL expects #1 or #2"));}
3661 #line 3662 "config/rx-parse.c"
3662 break;
3663
3664 case 234:
3665 #line 903 "./config/rx-parse.y"
3666 { rx_check_v2 (); id24 (2, 0x18, 0x40); F ((yyvsp[0].regno), 16, 1);
3667 if (rx_uintop ((yyvsp[-2].exp), 4) && (yyvsp[-2].exp).X_add_number == 1)
3668 ;
3669 else if (rx_uintop ((yyvsp[-2].exp), 4) && (yyvsp[-2].exp).X_add_number == 2)
3670 F (1, 19, 1);
3671 else
3672 as_bad (_("RDACW expects #1 or #2"));}
3673 #line 3674 "config/rx-parse.c"
3674 break;
3675
3676 case 235:
3677 #line 912 "./config/rx-parse.y"
3678 { rx_check_v3(); sub_op = 1; }
3679 #line 3680 "config/rx-parse.c"
3680 break;
3681
3682 case 237:
3683 #line 913 "./config/rx-parse.y"
3684 { rx_check_v3(); sub_op = 0; }
3685 #line 3686 "config/rx-parse.c"
3686 break;
3687
3688 case 239:
3689 #line 916 "./config/rx-parse.y"
3690 { rx_check_v3(); sub_op = 1; }
3691 #line 3692 "config/rx-parse.c"
3692 break;
3693
3694 case 241:
3695 #line 917 "./config/rx-parse.y"
3696 { rx_check_v3(); sub_op = 0; }
3697 #line 3698 "config/rx-parse.c"
3698 break;
3699
3700 case 243:
3701 #line 920 "./config/rx-parse.y"
3702 { rx_check_dfpu(); sub_op = 0x0c; sub_op2 = 0x01; }
3703 #line 3704 "config/rx-parse.c"
3704 break;
3705
3706 case 245:
3707 #line 921 "./config/rx-parse.y"
3708 { rx_check_dfpu(); sub_op = 0x0c; sub_op2 = 0x02; }
3709 #line 3710 "config/rx-parse.c"
3710 break;
3711
3712 case 247:
3713 #line 922 "./config/rx-parse.y"
3714 { rx_check_dfpu(); sub_op = 0x0d; sub_op2 = 0x0d; }
3715 #line 3716 "config/rx-parse.c"
3716 break;
3717
3718 case 249:
3719 #line 923 "./config/rx-parse.y"
3720 { rx_check_dfpu(); sub_op = 0x0d; sub_op2 = 0x00; }
3721 #line 3722 "config/rx-parse.c"
3722 break;
3723
3724 case 251:
3725 #line 924 "./config/rx-parse.y"
3726 { rx_check_dfpu(); sub_op = 0x0d; sub_op2 = 0x0c; }
3727 #line 3728 "config/rx-parse.c"
3728 break;
3729
3730 case 253:
3731 #line 925 "./config/rx-parse.y"
3732 { rx_check_dfpu(); sub_op = 0x0d; sub_op2 = 0x08;}
3733 #line 3734 "config/rx-parse.c"
3734 break;
3735
3736 case 255:
3737 #line 926 "./config/rx-parse.y"
3738 { rx_check_dfpu(); sub_op = 0x0d; sub_op2 = 0x09; }
3739 #line 3740 "config/rx-parse.c"
3740 break;
3741
3742 case 257:
3743 #line 927 "./config/rx-parse.y"
3744 { rx_check_dfpu(); sub_op = 0x00; }
3745 #line 3746 "config/rx-parse.c"
3746 break;
3747
3748 case 259:
3749 #line 928 "./config/rx-parse.y"
3750 { rx_check_dfpu(); sub_op = 0x05; }
3751 #line 3752 "config/rx-parse.c"
3752 break;
3753
3754 case 261:
3755 #line 929 "./config/rx-parse.y"
3756 { rx_check_dfpu(); sub_op = 0x02; }
3757 #line 3758 "config/rx-parse.c"
3758 break;
3759
3760 case 263:
3761 #line 930 "./config/rx-parse.y"
3762 { rx_check_dfpu(); sub_op = 0x01; }
3763 #line 3764 "config/rx-parse.c"
3764 break;
3765
3766 case 265:
3767 #line 931 "./config/rx-parse.y"
3768 { rx_check_dfpu();
3769 B4(0x76, 0x90, 0x08, 0x00); F((yyvsp[-3].regno), 24, 4); F((yyvsp[-2].regno), 28, 4); F((yyvsp[0].regno), 16, 4); }
3770 #line 3771 "config/rx-parse.c"
3771 break;
3772
3773 case 266:
3774 #line 934 "./config/rx-parse.y"
3775 { rx_check_dfpu();
3776 B4(0xfd, 0x77, 0x80, 0x03); F((yyvsp[-2].regno), 20, 4); F((yyvsp[0].regno), 24, 4); }
3777 #line 3778 "config/rx-parse.c"
3778 break;
3779
3780 case 267:
3781 #line 937 "./config/rx-parse.y"
3782 { rx_check_dfpu();
3783 B4(0xfd, 0x77, 0x80, 0x02); F((yyvsp[-2].regno), 20, 4); F((yyvsp[0].regno), 24, 4); }
3784 #line 3785 "config/rx-parse.c"
3785 break;
3786
3787 case 268:
3788 #line 940 "./config/rx-parse.y"
3789 { rx_check_dfpu();
3790 B4(0xfd, 0x77, 0x80, 0x00); F((yyvsp[-2].regno), 20, 4); F((yyvsp[0].regno), 24, 4); }
3791 #line 3792 "config/rx-parse.c"
3792 break;
3793
3794 case 269:
3795 #line 943 "./config/rx-parse.y"
3796 { rx_check_dfpu();
3797 B4(0xfd, 0x75, 0x80, 0x02); F((yyvsp[-2].regno), 24, 4); F((yyvsp[0].regno), 20, 4); }
3798 #line 3799 "config/rx-parse.c"
3799 break;
3800
3801 case 270:
3802 #line 946 "./config/rx-parse.y"
3803 { rx_check_dfpu();
3804 B4(0xfd, 0x75, 0x80, 0x00); F((yyvsp[-2].regno), 24, 4); F((yyvsp[0].regno), 20, 4); }
3805 #line 3806 "config/rx-parse.c"
3806 break;
3807
3808 case 271:
3809 #line 949 "./config/rx-parse.y"
3810 { rx_check_dfpu();
3811 B4(0x76, 0x90, 0x0c, 0x00); F((yyvsp[-2].regno), 16, 4); F((yyvsp[0].regno), 24, 4); }
3812 #line 3813 "config/rx-parse.c"
3813 break;
3814
3815 case 272:
3816 #line 952 "./config/rx-parse.y"
3817 { rx_check_dfpu();
3818 B4(0xfc, 0x78, 0x08, 0x00); F((yyvsp[-1].regno), 16, 4); F((yyvsp[-4].regno), 24, 4); }
3819 #line 3820 "config/rx-parse.c"
3820 break;
3821
3822 case 273:
3823 #line 955 "./config/rx-parse.y"
3824 { rx_check_dfpu();
3825 B3(0xfc, 0x78, 0x08); F((yyvsp[-1].regno), 16, 4); DSP((yyvsp[-3].exp), 14, DSIZE);
3826 POST((yyvsp[-5].regno) << 4); }
3827 #line 3828 "config/rx-parse.c"
3828 break;
3829
3830 case 274:
3831 #line 959 "./config/rx-parse.y"
3832 { rx_check_dfpu();
3833 B4(0xfc, 0xc8, 0x08, 0x00); F((yyvsp[-3].regno), 16, 4); F((yyvsp[0].regno), 24, 4); }
3834 #line 3835 "config/rx-parse.c"
3835 break;
3836
3837 case 275:
3838 #line 962 "./config/rx-parse.y"
3839 { rx_check_dfpu();
3840 B3(0xfc, 0xc8, 0x08); F((yyvsp[-3].regno), 16, 4); DSP((yyvsp[-5].exp), 14, DSIZE);
3841 POST((yyvsp[0].regno) << 4); }
3842 #line 3843 "config/rx-parse.c"
3843 break;
3844
3845 case 276:
3846 #line 966 "./config/rx-parse.y"
3847 { rx_check_dfpu();
3848 B3(0xf9, 0x03, 0x03); F((yyvsp[0].regno), 16, 4); IMM((yyvsp[-2].exp), -1); }
3849 #line 3850 "config/rx-parse.c"
3850 break;
3851
3852 case 277:
3853 #line 969 "./config/rx-parse.y"
3854 { rx_check_dfpu();
3855 B3(0xf9, 0x03, 0x02); F((yyvsp[0].regno), 16, 4); IMM((yyvsp[-2].exp), -1); }
3856 #line 3857 "config/rx-parse.c"
3857 break;
3858
3859 case 278:
3860 #line 972 "./config/rx-parse.y"
3861 { rx_check_dfpu();
3862 B3(0xf9, 0x03, 0x00); F((yyvsp[0].regno), 16, 4); IMM((yyvsp[-2].exp), -1); }
3863 #line 3864 "config/rx-parse.c"
3864 break;
3865
3866 case 279:
3867 #line 975 "./config/rx-parse.y"
3868 { rx_check_dfpu();
3869 B3(0x75, 0xb8, 0x00); F((yyvsp[-2].regno), 16, 4); F((yyvsp[0].regno) - (yyvsp[-2].regno), 20, 4); }
3870 #line 3871 "config/rx-parse.c"
3871 break;
3872
3873 case 280:
3874 #line 978 "./config/rx-parse.y"
3875 { rx_check_dfpu();
3876 B3(0x75, 0xa8, 0x00); F((yyvsp[-2].regno), 16, 4); F((yyvsp[0].regno) - (yyvsp[-2].regno), 20, 4); }
3877 #line 3878 "config/rx-parse.c"
3878 break;
3879
3880 case 281:
3881 #line 981 "./config/rx-parse.y"
3882 { rx_check_dfpu();
3883 B3(0x75, 0xb0, 0x00); F((yyvsp[-2].regno), 16, 4); F((yyvsp[0].regno) - (yyvsp[-2].regno), 20, 4); }
3884 #line 3885 "config/rx-parse.c"
3885 break;
3886
3887 case 282:
3888 #line 984 "./config/rx-parse.y"
3889 { rx_check_dfpu();
3890 B3(0x75, 0xa0, 0x00); F((yyvsp[-2].regno), 16, 4); F((yyvsp[0].regno) - (yyvsp[-2].regno), 20, 4); }
3891 #line 3892 "config/rx-parse.c"
3892 break;
3893
3894 case 283:
3895 #line 987 "./config/rx-parse.y"
3896 { rx_check_dfpu();
3897 B4(0xfd, 0x75, 0x80, 0x04); F((yyvsp[-2].regno), 24, 4); F((yyvsp[0].regno), 20, 4); }
3898 #line 3899 "config/rx-parse.c"
3899 break;
3900
3901 case 284:
3902 #line 990 "./config/rx-parse.y"
3903 { rx_check_dfpu(); B3(0x75, 0x90, 0x1b); }
3904 #line 3905 "config/rx-parse.c"
3905 break;
3906
3907 case 285:
3908 #line 992 "./config/rx-parse.y"
3909 { rx_check_dfpu();
3910 B4(0xfd, 0x77, 0x80, 0x04); F((yyvsp[-2].regno), 24, 4); F((yyvsp[0].regno), 20, 4); }
3911 #line 3912 "config/rx-parse.c"
3912 break;
3913
3914 case 286:
3915 #line 995 "./config/rx-parse.y"
3916 { rx_check_dfpu();
3917 B4(0xfd, 0x77, 0x80, 0x0a); F((yyvsp[-2].regno), 24, 4); F((yyvsp[0].regno), 20, 4); }
3918 #line 3919 "config/rx-parse.c"
3919 break;
3920
3921 case 287:
3922 #line 998 "./config/rx-parse.y"
3923 { rx_check_dfpu();
3924 B4(0xfd, 0x77, 0x80, 0x09); F((yyvsp[-2].regno), 24, 4); F((yyvsp[0].regno), 20, 4); }
3925 #line 3926 "config/rx-parse.c"
3926 break;
3927
3928 case 288:
3929 #line 1001 "./config/rx-parse.y"
3930 { rx_check_dfpu();
3931 B4(0xfd, 0x77, 0x80, 0x0d); F((yyvsp[-2].regno), 24, 4); F((yyvsp[0].regno), 20, 4); }
3932 #line 3933 "config/rx-parse.c"
3933 break;
3934
3935 case 289:
3936 #line 1012 "./config/rx-parse.y"
3937 { B2 (0x43 + (sub_op<<2), 0); F ((yyvsp[-2].regno), 8, 4); F ((yyvsp[0].regno), 12, 4); }
3938 #line 3939 "config/rx-parse.c"
3939 break;
3940
3941 case 290:
3942 #line 1014 "./config/rx-parse.y"
3943 { B2 (0x40 + (sub_op<<2), 0); F ((yyvsp[-4].regno), 8, 4); F ((yyvsp[0].regno), 12, 4); DSP ((yyvsp[-6].exp), 6, BSIZE); }
3944 #line 3945 "config/rx-parse.c"
3945 break;
3946
3947 case 291:
3948 #line 1016 "./config/rx-parse.y"
3949 { B3 (MEMEX, sub_op<<2, 0); F ((yyvsp[-2].regno), 8, 2); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); DSP ((yyvsp[-6].exp), 14, sizemap[(yyvsp[-2].regno)]); }
3950 #line 3951 "config/rx-parse.c"
3951 break;
3952
3953 case 292:
3954 #line 1018 "./config/rx-parse.y"
3955 { id24 (4, sub_op<<4, 0), F ((yyvsp[0].regno), 12, 4), F ((yyvsp[-4].regno), 16, 4), F ((yyvsp[-2].regno), 20, 4); }
3956 #line 3957 "config/rx-parse.c"
3957 break;
3958
3959 case 293:
3960 #line 1025 "./config/rx-parse.y"
3961 { id24 (1, 0x03 + (sub_op<<2), 0x00); F ((yyvsp[-2].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); }
3962 #line 3963 "config/rx-parse.c"
3963 break;
3964
3965 case 294:
3966 #line 1027 "./config/rx-parse.y"
3967 { B4 (MEMEX, 0xa0, 0x00 + sub_op, 0x00);
3968 F ((yyvsp[-4].regno), 24, 4); F ((yyvsp[0].regno), 28, 4); DSP ((yyvsp[-6].exp), 14, LSIZE); }
3969 #line 3970 "config/rx-parse.c"
3970 break;
3971
3972 case 295:
3973 #line 1035 "./config/rx-parse.y"
3974 { id24 (1, 0x03 + (sub_op<<2), 0x00); F ((yyvsp[-2].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); }
3975 #line 3976 "config/rx-parse.c"
3976 break;
3977
3978 case 296:
3979 #line 1037 "./config/rx-parse.y"
3980 { id24 (1, 0x00 + (sub_op<<2), 0x00); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); DSP ((yyvsp[-6].exp), 14, BSIZE); }
3981 #line 3982 "config/rx-parse.c"
3982 break;
3983
3984 case 297:
3985 #line 1039 "./config/rx-parse.y"
3986 { B4 (MEMEX, 0x20 + ((yyvsp[-2].regno) << 6), 0x00 + sub_op, 0x00);
3987 F ((yyvsp[-4].regno), 24, 4); F ((yyvsp[0].regno), 28, 4); DSP ((yyvsp[-6].exp), 14, sizemap[(yyvsp[-2].regno)]); }
3988 #line 3989 "config/rx-parse.c"
3989 break;
3990
3991 case 298:
3992 #line 1045 "./config/rx-parse.y"
3993 { id24 (2, 0x70, sub_op<<4); F ((yyvsp[0].regno), 20, 4); IMM ((yyvsp[-2].exp), 12); }
3994 #line 3995 "config/rx-parse.c"
3995 break;
3996
3997 case 303:
3998 #line 1060 "./config/rx-parse.y"
3999 { id24 (1, 0x03 + (sub_op<<2), 0x00); F ((yyvsp[-2].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); }
4000 #line 4001 "config/rx-parse.c"
4001 break;
4002
4003 case 304:
4004 #line 1062 "./config/rx-parse.y"
4005 { B2 (0x7e, sub_op2 << 4); F ((yyvsp[0].regno), 12, 4); }
4006 #line 4007 "config/rx-parse.c"
4007 break;
4008
4009 case 305:
4010 #line 1067 "./config/rx-parse.y"
4011 { id24 (1, 0x4b + (sub_op2<<2), 0x00); F ((yyvsp[-2].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); }
4012 #line 4013 "config/rx-parse.c"
4013 break;
4014
4015 case 306:
4016 #line 1071 "./config/rx-parse.y"
4017 { rx_check_v2 (); }
4018 #line 4019 "config/rx-parse.c"
4019 break;
4020
4021 case 309:
4022 #line 1079 "./config/rx-parse.y"
4023 { id24 (1, 0x03 + (sub_op<<2), 0); F ((yyvsp[-2].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); }
4024 #line 4025 "config/rx-parse.c"
4025 break;
4026
4027 case 310:
4028 #line 1081 "./config/rx-parse.y"
4029 { id24 (1, 0x00 + (sub_op<<2), 0); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); DSP ((yyvsp[-6].exp), 14, BSIZE); }
4030 #line 4031 "config/rx-parse.c"
4031 break;
4032
4033 case 311:
4034 #line 1083 "./config/rx-parse.y"
4035 { B4 (MEMEX, 0x20, 0x00 + sub_op, 0); F ((yyvsp[-2].regno), 8, 2); F ((yyvsp[-4].regno), 24, 4); F ((yyvsp[0].regno), 28, 4);
4036 DSP ((yyvsp[-6].exp), 14, sizemap[(yyvsp[-2].regno)]); }
4037 #line 4038 "config/rx-parse.c"
4038 break;
4039
4040 case 312:
4041 #line 1090 "./config/rx-parse.y"
4042 { id24 (2, 0x60 + sub_op, 0); F ((yyvsp[-2].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); }
4043 #line 4044 "config/rx-parse.c"
4044 break;
4045
4046 case 313:
4047 #line 1094 "./config/rx-parse.y"
4048 { B2 (0x68 + (sub_op<<1), 0); FE ((yyvsp[-2].exp), 7, 5); F ((yyvsp[0].regno), 12, 4); }
4049 #line 4050 "config/rx-parse.c"
4050 break;
4051
4052 case 314:
4053 #line 1096 "./config/rx-parse.y"
4054 { id24 (2, 0x80 + (sub_op << 5), 0); FE ((yyvsp[-4].exp), 11, 5); F ((yyvsp[-2].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); }
4055 #line 4056 "config/rx-parse.c"
4056 break;
4057
4058 case 316:
4059 #line 1102 "./config/rx-parse.y"
4060 { rx_check_float_support (); id24 (2, 0x72, sub_op << 4); F ((yyvsp[0].regno), 20, 4); O4 ((yyvsp[-2].exp)); }
4061 #line 4062 "config/rx-parse.c"
4062 break;
4063
4064 case 317:
4065 #line 1104 "./config/rx-parse.y"
4066 { rx_check_float_support (); id24 (1, 0x83 + (sub_op << 2), 0); F ((yyvsp[-2].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); }
4067 #line 4068 "config/rx-parse.c"
4068 break;
4069
4070 case 318:
4071 #line 1106 "./config/rx-parse.y"
4072 { rx_check_float_support (); id24 (1, 0x80 + (sub_op << 2), 0); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); DSP ((yyvsp[-6].exp), 14, LSIZE); }
4073 #line 4074 "config/rx-parse.c"
4074 break;
4075
4076 case 319:
4077 #line 1108 "./config/rx-parse.y"
4078 { rx_check_v2 (); id24 (4, 0x80 + (sub_op << 4), 0 ); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[-2].regno), 20, 4); F ((yyvsp[0].regno), 12, 4); }
4079 #line 4080 "config/rx-parse.c"
4080 break;
4081
4082 case 320:
4083 #line 1112 "./config/rx-parse.y"
4084 { rx_check_float_support (); }
4085 #line 4086 "config/rx-parse.c"
4086 break;
4087
4088 case 321:
4089 #line 1114 "./config/rx-parse.y"
4090 { id24 (2, 0x72, sub_op << 4); F ((yyvsp[0].regno), 20, 4); O4 ((yyvsp[-2].exp)); }
4091 #line 4092 "config/rx-parse.c"
4092 break;
4093
4094 case 323:
4095 #line 1119 "./config/rx-parse.y"
4096 { rx_check_float_support (); }
4097 #line 4098 "config/rx-parse.c"
4098 break;
4099
4100 case 324:
4101 #line 1121 "./config/rx-parse.y"
4102 { id24 (1, 0x83 + (sub_op << 2), 0); F ((yyvsp[-2].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); }
4103 #line 4104 "config/rx-parse.c"
4104 break;
4105
4106 case 325:
4107 #line 1122 "./config/rx-parse.y"
4108 { rx_check_float_support (); }
4109 #line 4110 "config/rx-parse.c"
4110 break;
4111
4112 case 326:
4113 #line 1124 "./config/rx-parse.y"
4114 { id24 (1, 0x80 + (sub_op << 2), 0); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); DSP ((yyvsp[-6].exp), 14, LSIZE); }
4115 #line 4116 "config/rx-parse.c"
4116 break;
4117
4118 case 327:
4119 #line 1128 "./config/rx-parse.y"
4120 { rx_check_v2 (); }
4121 #line 4122 "config/rx-parse.c"
4122 break;
4123
4124 case 328:
4125 #line 1130 "./config/rx-parse.y"
4126 { id24 (2, 0x1e, sub_op << 4); F ((yyvsp[0].regno), 20, 4); F ((yyvsp[-2].regno), 16, 1);
4127 if (rx_uintop ((yyvsp[-4].exp), 4))
4128 {
4129 switch (exp_val ((yyvsp[-4].exp)))
4130 {
4131 case 0:
4132 F (1, 15, 1);
4133 break;
4134 case 1:
4135 F (1, 15, 1);
4136 F (1, 17, 1);
4137 break;
4138 case 2:
4139 break;
4140 default:
4141 as_bad (_("IMM expects #0 to #2"));}
4142 } else
4143 as_bad (_("IMM expects #0 to #2"));}
4144 #line 4145 "config/rx-parse.c"
4145 break;
4146
4147 case 330:
4148 #line 1153 "./config/rx-parse.y"
4149 { rx_check_v3(); B3(0xff,0x60,0x00), F ((yyvsp[0].regno), 12, 4), F ((yyvsp[-4].regno), 16, 4), F ((yyvsp[-2].regno), 20, 4); }
4150 #line 4151 "config/rx-parse.c"
4151 break;
4152
4153 case 331:
4154 #line 1157 "./config/rx-parse.y"
4155 { rx_check_v3(); }
4156 #line 4157 "config/rx-parse.c"
4157 break;
4158
4159 case 332:
4160 #line 1159 "./config/rx-parse.y"
4161 { rx_range((yyvsp[-10].exp), 0, 31); rx_range((yyvsp[-7].exp), 0, 31); rx_range((yyvsp[-4].exp), 1, 31);
4162 B3(0xfc, 0x5a + (sub_op << 2), 0); F((yyvsp[-2].regno), 16, 4); F((yyvsp[0].regno), 20, 4);
4163 rx_bfield((yyvsp[-10].exp), (yyvsp[-7].exp), (yyvsp[-4].exp));}
4164 #line 4165 "config/rx-parse.c"
4165 break;
4166
4167 case 333:
4168 #line 1166 "./config/rx-parse.y"
4169 { B3(0xfd,0x76,0xe0 + (sub_op << 4)); UO1((yyvsp[0].exp)); }
4170 #line 4171 "config/rx-parse.c"
4171 break;
4172
4173 case 334:
4174 #line 1168 "./config/rx-parse.y"
4175 { B4(0xfd,0x76,0xc0 + (sub_op << 4), 0x00); F((yyvsp[0].regno), 20, 4); }
4176 #line 4177 "config/rx-parse.c"
4177 break;
4178
4179 case 335:
4180 #line 1173 "./config/rx-parse.y"
4181 { B4(0x76, 0x90, sub_op, sub_op2); F((yyvsp[-2].regno), 16, 4); F((yyvsp[0].regno), 24, 4);}
4182 #line 4183 "config/rx-parse.c"
4183 break;
4184
4185 case 336:
4186 #line 1177 "./config/rx-parse.y"
4187 { B4(0x76, 0x90, sub_op, 0x00); F((yyvsp[-4].regno), 28, 4); F((yyvsp[-2].regno), 16,4); F((yyvsp[0].regno), 24, 4);}
4188 #line 4189 "config/rx-parse.c"
4189 break;
4190
4191 case 337:
4192 #line 1181 "./config/rx-parse.y"
4193 { (yyval.exp) = zero_expr (); }
4194 #line 4195 "config/rx-parse.c"
4195 break;
4196
4197 case 338:
4198 #line 1182 "./config/rx-parse.y"
4199 { (yyval.exp) = (yyvsp[0].exp); }
4200 #line 4201 "config/rx-parse.c"
4201 break;
4202
4203 case 339:
4204 #line 1185 "./config/rx-parse.y"
4205 { need_flag = 1; }
4206 #line 4207 "config/rx-parse.c"
4207 break;
4208
4209 case 340:
4210 #line 1185 "./config/rx-parse.y"
4211 { need_flag = 0; (yyval.regno) = (yyvsp[0].regno); }
4212 #line 4213 "config/rx-parse.c"
4213 break;
4214
4215 case 341:
4216 #line 1190 "./config/rx-parse.y"
4217 { (yyval.regno) = 0; }
4218 #line 4219 "config/rx-parse.c"
4219 break;
4220
4221 case 342:
4222 #line 1191 "./config/rx-parse.y"
4223 { (yyval.regno) = 1; }
4224 #line 4225 "config/rx-parse.c"
4225 break;
4226
4227 case 343:
4228 #line 1192 "./config/rx-parse.y"
4229 { (yyval.regno) = 2; }
4230 #line 4231 "config/rx-parse.c"
4231 break;
4232
4233 case 344:
4234 #line 1193 "./config/rx-parse.y"
4235 { (yyval.regno) = 2; }
4236 #line 4237 "config/rx-parse.c"
4237 break;
4238
4239 case 345:
4240 #line 1194 "./config/rx-parse.y"
4241 { (yyval.regno) = 3; }
4242 #line 4243 "config/rx-parse.c"
4243 break;
4244
4245 case 346:
4246 #line 1197 "./config/rx-parse.y"
4247 { (yyval.regno) = LSIZE; }
4248 #line 4249 "config/rx-parse.c"
4249 break;
4250
4251 case 347:
4252 #line 1198 "./config/rx-parse.y"
4253 { (yyval.regno) = BSIZE; }
4254 #line 4255 "config/rx-parse.c"
4255 break;
4256
4257 case 348:
4258 #line 1199 "./config/rx-parse.y"
4259 { (yyval.regno) = WSIZE; }
4260 #line 4261 "config/rx-parse.c"
4261 break;
4262
4263 case 349:
4264 #line 1200 "./config/rx-parse.y"
4265 { (yyval.regno) = LSIZE; }
4266 #line 4267 "config/rx-parse.c"
4267 break;
4268
4269 case 350:
4270 #line 1203 "./config/rx-parse.y"
4271 { (yyval.regno) = 1; }
4272 #line 4273 "config/rx-parse.c"
4273 break;
4274
4275 case 351:
4276 #line 1204 "./config/rx-parse.y"
4277 { (yyval.regno) = 0; }
4278 #line 4279 "config/rx-parse.c"
4279 break;
4280
4281 case 352:
4282 #line 1205 "./config/rx-parse.y"
4283 { (yyval.regno) = 1; }
4284 #line 4285 "config/rx-parse.c"
4285 break;
4286
4287 case 353:
4288 #line 1208 "./config/rx-parse.y"
4289 {}
4290 #line 4291 "config/rx-parse.c"
4291 break;
4292
4293 case 354:
4294 #line 1209 "./config/rx-parse.y"
4295 {}
4296 #line 4297 "config/rx-parse.c"
4297 break;
4298
4299 case 355:
4300 #line 1212 "./config/rx-parse.y"
4301 {}
4302 #line 4303 "config/rx-parse.c"
4303 break;
4304
4305 case 356:
4306 #line 1213 "./config/rx-parse.y"
4307 {}
4308 #line 4309 "config/rx-parse.c"
4309 break;
4310
4311
4312 #line 4313 "config/rx-parse.c"
4313
4314 default: break;
4315 }
4316 /* User semantic actions sometimes alter yychar, and that requires
4317 that yytoken be updated with the new translation. We take the
4318 approach of translating immediately before every use of yytoken.
4319 One alternative is translating here after every semantic action,
4320 but that translation would be missed if the semantic action invokes
4321 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
4322 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
4323 incorrect destructor might then be invoked immediately. In the
4324 case of YYERROR or YYBACKUP, subsequent parser actions might lead
4325 to an incorrect destructor call or verbose syntax error message
4326 before the lookahead is translated. */
4327 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
4328
4329 YYPOPSTACK (yylen);
4330 yylen = 0;
4331 YY_STACK_PRINT (yyss, yyssp);
4332
4333 *++yyvsp = yyval;
4334
4335 /* Now 'shift' the result of the reduction. Determine what state
4336 that goes to, based on the state we popped back to and the rule
4337 number reduced by. */
4338 {
4339 const int yylhs = yyr1[yyn] - YYNTOKENS;
4340 const int yyi = yypgoto[yylhs] + *yyssp;
4341 yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
4342 ? yytable[yyi]
4343 : yydefgoto[yylhs]);
4344 }
4345
4346 goto yynewstate;
4347
4348
4349 /*--------------------------------------.
4350 | yyerrlab -- here on detecting error. |
4351 `--------------------------------------*/
4352 yyerrlab:
4353 /* Make sure we have latest lookahead translation. See comments at
4354 user semantic actions for why this is necessary. */
4355 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
4356
4357 /* If not already recovering from an error, report this error. */
4358 if (!yyerrstatus)
4359 {
4360 ++yynerrs;
4361 #if ! YYERROR_VERBOSE
4362 yyerror (YY_("syntax error"));
4363 #else
4364 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
4365 yyssp, yytoken)
4366 {
4367 char const *yymsgp = YY_("syntax error");
4368 int yysyntax_error_status;
4369 yysyntax_error_status = YYSYNTAX_ERROR;
4370 if (yysyntax_error_status == 0)
4371 yymsgp = yymsg;
4372 else if (yysyntax_error_status == 1)
4373 {
4374 if (yymsg != yymsgbuf)
4375 YYSTACK_FREE (yymsg);
4376 yymsg = YY_CAST (char *, YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc)));
4377 if (!yymsg)
4378 {
4379 yymsg = yymsgbuf;
4380 yymsg_alloc = sizeof yymsgbuf;
4381 yysyntax_error_status = 2;
4382 }
4383 else
4384 {
4385 yysyntax_error_status = YYSYNTAX_ERROR;
4386 yymsgp = yymsg;
4387 }
4388 }
4389 yyerror (yymsgp);
4390 if (yysyntax_error_status == 2)
4391 goto yyexhaustedlab;
4392 }
4393 # undef YYSYNTAX_ERROR
4394 #endif
4395 }
4396
4397
4398
4399 if (yyerrstatus == 3)
4400 {
4401 /* If just tried and failed to reuse lookahead token after an
4402 error, discard it. */
4403
4404 if (yychar <= YYEOF)
4405 {
4406 /* Return failure if at end of input. */
4407 if (yychar == YYEOF)
4408 YYABORT;
4409 }
4410 else
4411 {
4412 yydestruct ("Error: discarding",
4413 yytoken, &yylval);
4414 yychar = YYEMPTY;
4415 }
4416 }
4417
4418 /* Else will try to reuse lookahead token after shifting the error
4419 token. */
4420 goto yyerrlab1;
4421
4422
4423 /*---------------------------------------------------.
4424 | yyerrorlab -- error raised explicitly by YYERROR. |
4425 `---------------------------------------------------*/
4426 yyerrorlab:
4427 /* Pacify compilers when the user code never invokes YYERROR and the
4428 label yyerrorlab therefore never appears in user code. */
4429 if (0)
4430 YYERROR;
4431
4432 /* Do not reclaim the symbols of the rule whose action triggered
4433 this YYERROR. */
4434 YYPOPSTACK (yylen);
4435 yylen = 0;
4436 YY_STACK_PRINT (yyss, yyssp);
4437 yystate = *yyssp;
4438 goto yyerrlab1;
4439
4440
4441 /*-------------------------------------------------------------.
4442 | yyerrlab1 -- common code for both syntax error and YYERROR. |
4443 `-------------------------------------------------------------*/
4444 yyerrlab1:
4445 yyerrstatus = 3; /* Each real token shifted decrements this. */
4446
4447 for (;;)
4448 {
4449 yyn = yypact[yystate];
4450 if (!yypact_value_is_default (yyn))
4451 {
4452 yyn += YYTERROR;
4453 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
4454 {
4455 yyn = yytable[yyn];
4456 if (0 < yyn)
4457 break;
4458 }
4459 }
4460
4461 /* Pop the current state because it cannot handle the error token. */
4462 if (yyssp == yyss)
4463 YYABORT;
4464
4465
4466 yydestruct ("Error: popping",
4467 yystos[yystate], yyvsp);
4468 YYPOPSTACK (1);
4469 yystate = *yyssp;
4470 YY_STACK_PRINT (yyss, yyssp);
4471 }
4472
4473 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
4474 *++yyvsp = yylval;
4475 YY_IGNORE_MAYBE_UNINITIALIZED_END
4476
4477
4478 /* Shift the error token. */
4479 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
4480
4481 yystate = yyn;
4482 goto yynewstate;
4483
4484
4485 /*-------------------------------------.
4486 | yyacceptlab -- YYACCEPT comes here. |
4487 `-------------------------------------*/
4488 yyacceptlab:
4489 yyresult = 0;
4490 goto yyreturn;
4491
4492
4493 /*-----------------------------------.
4494 | yyabortlab -- YYABORT comes here. |
4495 `-----------------------------------*/
4496 yyabortlab:
4497 yyresult = 1;
4498 goto yyreturn;
4499
4500
4501 #if !defined yyoverflow || YYERROR_VERBOSE
4502 /*-------------------------------------------------.
4503 | yyexhaustedlab -- memory exhaustion comes here. |
4504 `-------------------------------------------------*/
4505 yyexhaustedlab:
4506 yyerror (YY_("memory exhausted"));
4507 yyresult = 2;
4508 /* Fall through. */
4509 #endif
4510
4511
4512 /*-----------------------------------------------------.
4513 | yyreturn -- parsing is finished, return the result. |
4514 `-----------------------------------------------------*/
4515 yyreturn:
4516 if (yychar != YYEMPTY)
4517 {
4518 /* Make sure we have latest lookahead translation. See comments at
4519 user semantic actions for why this is necessary. */
4520 yytoken = YYTRANSLATE (yychar);
4521 yydestruct ("Cleanup: discarding lookahead",
4522 yytoken, &yylval);
4523 }
4524 /* Do not reclaim the symbols of the rule whose action triggered
4525 this YYABORT or YYACCEPT. */
4526 YYPOPSTACK (yylen);
4527 YY_STACK_PRINT (yyss, yyssp);
4528 while (yyssp != yyss)
4529 {
4530 yydestruct ("Cleanup: popping",
4531 yystos[*yyssp], yyvsp);
4532 YYPOPSTACK (1);
4533 }
4534 #ifndef yyoverflow
4535 if (yyss != yyssa)
4536 YYSTACK_FREE (yyss);
4537 #endif
4538 #if YYERROR_VERBOSE
4539 if (yymsg != yymsgbuf)
4540 YYSTACK_FREE (yymsg);
4541 #endif
4542 return yyresult;
4543 }
4544 #line 1216 "./config/rx-parse.y"
4545
4546 /* ====================================================================== */
4547
4548 static struct
4549 {
4550 const char * string;
4551 int token;
4552 int val;
4553 }
4554 token_table[] =
4555 {
4556 { "r0", REG, 0 },
4557 { "r1", REG, 1 },
4558 { "r2", REG, 2 },
4559 { "r3", REG, 3 },
4560 { "r4", REG, 4 },
4561 { "r5", REG, 5 },
4562 { "r6", REG, 6 },
4563 { "r7", REG, 7 },
4564 { "r8", REG, 8 },
4565 { "r9", REG, 9 },
4566 { "r10", REG, 10 },
4567 { "r11", REG, 11 },
4568 { "r12", REG, 12 },
4569 { "r13", REG, 13 },
4570 { "r14", REG, 14 },
4571 { "r15", REG, 15 },
4572
4573 { "psw", CREG, 0 },
4574 { "pc", CREG, 1 },
4575 { "usp", CREG, 2 },
4576 { "fpsw", CREG, 3 },
4577 /* reserved */
4578 /* reserved */
4579 /* reserved */
4580 { "wr", CREG, 7 },
4581
4582 { "bpsw", CREG, 8 },
4583 { "bpc", CREG, 9 },
4584 { "isp", CREG, 10 },
4585 { "fintv", CREG, 11 },
4586 { "intb", CREG, 12 },
4587 { "extb", CREG, 13 },
4588
4589 { "pbp", CREG, 16 },
4590 { "pben", CREG, 17 },
4591
4592 { "bbpsw", CREG, 24 },
4593 { "bbpc", CREG, 25 },
4594
4595 { "dr0", DREG, 0 },
4596 { "dr1", DREG, 1 },
4597 { "dr2", DREG, 2 },
4598 { "dr3", DREG, 3 },
4599 { "dr4", DREG, 4 },
4600 { "dr5", DREG, 5 },
4601 { "dr6", DREG, 6 },
4602 { "dr7", DREG, 7 },
4603 { "dr8", DREG, 8 },
4604 { "dr9", DREG, 9 },
4605 { "dr10", DREG, 10 },
4606 { "dr11", DREG, 11 },
4607 { "dr12", DREG, 12 },
4608 { "dr13", DREG, 13 },
4609 { "dr14", DREG, 14 },
4610 { "dr15", DREG, 15 },
4611
4612 { "drh0", DREGH, 0 },
4613 { "drh1", DREGH, 1 },
4614 { "drh2", DREGH, 2 },
4615 { "drh3", DREGH, 3 },
4616 { "drh4", DREGH, 4 },
4617 { "drh5", DREGH, 5 },
4618 { "drh6", DREGH, 6 },
4619 { "drh7", DREGH, 7 },
4620 { "drh8", DREGH, 8 },
4621 { "drh9", DREGH, 9 },
4622 { "drh10", DREGH, 10 },
4623 { "drh11", DREGH, 11 },
4624 { "drh12", DREGH, 12 },
4625 { "drh13", DREGH, 13 },
4626 { "drh14", DREGH, 14 },
4627 { "drh15", DREGH, 15 },
4628
4629 { "drl0", DREGL, 0 },
4630 { "drl1", DREGL, 1 },
4631 { "drl2", DREGL, 2 },
4632 { "drl3", DREGL, 3 },
4633 { "drl4", DREGL, 4 },
4634 { "drl5", DREGL, 5 },
4635 { "drl6", DREGL, 6 },
4636 { "drl7", DREGL, 7 },
4637 { "drl8", DREGL, 8 },
4638 { "drl9", DREGL, 9 },
4639 { "drl10", DREGL, 10 },
4640 { "drl11", DREGL, 11 },
4641 { "drl12", DREGL, 12 },
4642 { "drl13", DREGL, 13 },
4643 { "drl14", DREGL, 14 },
4644 { "drl15", DREGL, 15 },
4645
4646 { "DPSW", DCREG, 0 },
4647 { "DCMR", DCREG, 1 },
4648 { "DCENT", DCREG, 2 },
4649 { "DEPC", DCREG, 3 },
4650 { "DCR0", DCREG, 0 },
4651 { "DCR1", DCREG, 1 },
4652 { "DCR2", DCREG, 2 },
4653 { "DCR3", DCREG, 3 },
4654
4655 { ".s", DOT_S, 0 },
4656 { ".b", DOT_B, 0 },
4657 { ".w", DOT_W, 0 },
4658 { ".l", DOT_L, 0 },
4659 { ".a", DOT_A , 0},
4660 { ".ub", DOT_UB, 0 },
4661 { ".uw", DOT_UW , 0},
4662 { ".d", DOT_D , 0},
4663
4664 { "c", FLAG, 0 },
4665 { "z", FLAG, 1 },
4666 { "s", FLAG, 2 },
4667 { "o", FLAG, 3 },
4668 { "i", FLAG, 8 },
4669 { "u", FLAG, 9 },
4670
4671 { "a0", ACC, 0 },
4672 { "a1", ACC, 1 },
4673
4674 #define OPC(x) { #x, x, IS_OPCODE }
4675 OPC(ABS),
4676 OPC(ADC),
4677 OPC(ADD),
4678 { "and", AND_, IS_OPCODE },
4679 OPC(BCLR),
4680 OPC(BCND),
4681 OPC(BFMOV),
4682 OPC(BFMOVZ),
4683 OPC(BMCND),
4684 OPC(BNOT),
4685 OPC(BRA),
4686 OPC(BRK),
4687 OPC(BSET),
4688 OPC(BSR),
4689 OPC(BTST),
4690 OPC(CLRPSW),
4691 OPC(CMP),
4692 OPC(DABS),
4693 OPC(DADD),
4694 OPC(DBT),
4695 OPC(DDIV),
4696 OPC(DIV),
4697 OPC(DIVU),
4698 OPC(DMOV),
4699 OPC(DMUL),
4700 OPC(DNEG),
4701 OPC(DPOPM),
4702 OPC(DPUSHM),
4703 OPC(DROUND),
4704 OPC(DSQRT),
4705 OPC(DSUB),
4706 OPC(DTOF),
4707 OPC(DTOI),
4708 OPC(DTOU),
4709 OPC(EDIV),
4710 OPC(EDIVU),
4711 OPC(EMACA),
4712 OPC(EMSBA),
4713 OPC(EMUL),
4714 OPC(EMULA),
4715 OPC(EMULU),
4716 OPC(FADD),
4717 OPC(FCMP),
4718 OPC(FDIV),
4719 OPC(FMUL),
4720 OPC(FREIT),
4721 OPC(FSQRT),
4722 OPC(FTOD),
4723 OPC(FTOU),
4724 OPC(FSUB),
4725 OPC(FTOI),
4726 OPC(INT),
4727 OPC(ITOD),
4728 OPC(ITOF),
4729 OPC(JMP),
4730 OPC(JSR),
4731 OPC(MVFACGU),
4732 OPC(MVFACHI),
4733 OPC(MVFACMI),
4734 OPC(MVFACLO),
4735 OPC(MVFC),
4736 OPC(MVFDC),
4737 OPC(MVFDR),
4738 OPC(MVTDC),
4739 OPC(MVTACGU),
4740 OPC(MVTACHI),
4741 OPC(MVTACLO),
4742 OPC(MVTC),
4743 OPC(MVTIPL),
4744 OPC(MACHI),
4745 OPC(MACLO),
4746 OPC(MACLH),
4747 OPC(MAX),
4748 OPC(MIN),
4749 OPC(MOV),
4750 OPC(MOVCO),
4751 OPC(MOVLI),
4752 OPC(MOVU),
4753 OPC(MSBHI),
4754 OPC(MSBLH),
4755 OPC(MSBLO),
4756 OPC(MUL),
4757 OPC(MULHI),
4758 OPC(MULLH),
4759 OPC(MULLO),
4760 OPC(MULU),
4761 OPC(NEG),
4762 OPC(NOP),
4763 OPC(NOT),
4764 OPC(OR),
4765 OPC(POP),
4766 OPC(POPC),
4767 OPC(POPM),
4768 OPC(PUSH),
4769 OPC(PUSHA),
4770 OPC(PUSHC),
4771 OPC(PUSHM),
4772 OPC(RACL),
4773 OPC(RACW),
4774 OPC(RDACL),
4775 OPC(RDACW),
4776 OPC(REIT),
4777 OPC(REVL),
4778 OPC(REVW),
4779 OPC(RMPA),
4780 OPC(ROLC),
4781 OPC(RORC),
4782 OPC(ROTL),
4783 OPC(ROTR),
4784 OPC(ROUND),
4785 OPC(RSTR),
4786 OPC(RTE),
4787 OPC(RTFI),
4788 OPC(RTS),
4789 OPC(RTSD),
4790 OPC(SAT),
4791 OPC(SATR),
4792 OPC(SAVE),
4793 OPC(SBB),
4794 OPC(SCCND),
4795 OPC(SCMPU),
4796 OPC(SETPSW),
4797 OPC(SHAR),
4798 OPC(SHLL),
4799 OPC(SHLR),
4800 OPC(SMOVB),
4801 OPC(SMOVF),
4802 OPC(SMOVU),
4803 OPC(SSTR),
4804 OPC(STNZ),
4805 OPC(STOP),
4806 OPC(STZ),
4807 OPC(SUB),
4808 OPC(SUNTIL),
4809 OPC(SWHILE),
4810 OPC(TST),
4811 OPC(UTOD),
4812 OPC(UTOF),
4813 OPC(WAIT),
4814 OPC(XCHG),
4815 OPC(XOR),
4816 };
4817
4818 #define NUM_TOKENS (sizeof (token_table) / sizeof (token_table[0]))
4819
4820 static struct
4821 {
4822 const char * string;
4823 int token;
4824 }
4825 condition_opcode_table[] =
4826 {
4827 { "b", BCND },
4828 { "bm", BMCND },
4829 { "sc", SCCND },
4830 };
4831
4832 #define NUM_CONDITION_OPCODES (sizeof (condition_opcode_table) / sizeof (condition_opcode_table[0]))
4833
4834 struct condition_symbol
4835 {
4836 const char * string;
4837 int val;
4838 };
4839
4840 static struct condition_symbol condition_table[] =
4841 {
4842 { "z", 0 },
4843 { "eq", 0 },
4844 { "geu", 2 },
4845 { "c", 2 },
4846 { "gtu", 4 },
4847 { "pz", 6 },
4848 { "ge", 8 },
4849 { "gt", 10 },
4850 { "o", 12},
4851 /* always = 14 */
4852 { "nz", 1 },
4853 { "ne", 1 },
4854 { "ltu", 3 },
4855 { "nc", 3 },
4856 { "leu", 5 },
4857 { "n", 7 },
4858 { "lt", 9 },
4859 { "le", 11 },
4860 { "no", 13 },
4861 /* never = 15 */
4862 };
4863
4864 static struct condition_symbol double_condition_table[] =
4865 {
4866 { "un", 1 },
4867 { "eq", 2 },
4868 { "lt", 4 },
4869 { "le", 6 },
4870 };
4871
4872 #define NUM_CONDITIONS (sizeof (condition_table) / sizeof (condition_table[0]))
4873 #define NUM_DOUBLE_CONDITIONS (sizeof (double_condition_table) / sizeof (double_condition_table[0]))
4874
4875 void
rx_lex_init(char * beginning,char * ending)4876 rx_lex_init (char * beginning, char * ending)
4877 {
4878 rx_init_start = beginning;
4879 rx_lex_start = beginning;
4880 rx_lex_end = ending;
4881 rx_in_brackets = 0;
4882 rx_last_token = 0;
4883
4884 setbuf (stdout, 0);
4885 }
4886
4887 static int
check_condition(const char * base,struct condition_symbol * t,unsigned int num)4888 check_condition (const char * base, struct condition_symbol *t, unsigned int num)
4889 {
4890 char * cp;
4891 unsigned int i;
4892
4893 if ((unsigned) (rx_lex_end - rx_lex_start) < strlen (base) + 1)
4894 return 0;
4895 if (memcmp (rx_lex_start, base, strlen (base)))
4896 return 0;
4897 cp = rx_lex_start + strlen (base);
4898 for (i = 0; i < num; i ++)
4899 {
4900 if (strcasecmp (cp, t[i].string) == 0)
4901 {
4902 rx_lval.regno = t[i].val;
4903 return 1;
4904 }
4905 }
4906 return 0;
4907 }
4908
4909 static int
rx_lex(void)4910 rx_lex (void)
4911 {
4912 unsigned int ci;
4913 char * save_input_pointer;
4914
4915 while (ISSPACE (*rx_lex_start)
4916 && rx_lex_start != rx_lex_end)
4917 rx_lex_start ++;
4918
4919 rx_last_exp_start = rx_lex_start;
4920
4921 if (rx_lex_start == rx_lex_end)
4922 return 0;
4923
4924 if (ISALPHA (*rx_lex_start)
4925 || (rx_pid_register != -1 && memcmp (rx_lex_start, "%pidreg", 7) == 0)
4926 || (rx_gp_register != -1 && memcmp (rx_lex_start, "%gpreg", 6) == 0)
4927 || (*rx_lex_start == '.' && ISALPHA (rx_lex_start[1])))
4928 {
4929 unsigned int i;
4930 char * e;
4931 char save;
4932
4933 for (e = rx_lex_start + 1;
4934 e < rx_lex_end && ISALNUM (*e);
4935 e ++)
4936 ;
4937 save = *e;
4938 *e = 0;
4939
4940 if (strcmp (rx_lex_start, "%pidreg") == 0)
4941 {
4942 {
4943 rx_lval.regno = rx_pid_register;
4944 *e = save;
4945 rx_lex_start = e;
4946 rx_last_token = REG;
4947 return REG;
4948 }
4949 }
4950
4951 if (strcmp (rx_lex_start, "%gpreg") == 0)
4952 {
4953 {
4954 rx_lval.regno = rx_gp_register;
4955 *e = save;
4956 rx_lex_start = e;
4957 rx_last_token = REG;
4958 return REG;
4959 }
4960 }
4961
4962 if (rx_last_token == 0)
4963 {
4964 for (ci = 0; ci < NUM_CONDITION_OPCODES; ci ++)
4965 if (check_condition (condition_opcode_table[ci].string,
4966 condition_table, NUM_CONDITIONS))
4967 {
4968 *e = save;
4969 rx_lex_start = e;
4970 rx_last_token = condition_opcode_table[ci].token;
4971 return condition_opcode_table[ci].token;
4972 }
4973 if (check_condition ("dcmp", double_condition_table,
4974 NUM_DOUBLE_CONDITIONS))
4975 {
4976 *e = save;
4977 rx_lex_start = e;
4978 rx_last_token = DCMP;
4979 return DCMP;
4980 }
4981 }
4982
4983 for (i = 0; i < NUM_TOKENS; i++)
4984 if (strcasecmp (rx_lex_start, token_table[i].string) == 0
4985 && !(token_table[i].val == IS_OPCODE && rx_last_token != 0)
4986 && !(token_table[i].token == FLAG && !need_flag))
4987 {
4988 rx_lval.regno = token_table[i].val;
4989 *e = save;
4990 rx_lex_start = e;
4991 rx_last_token = token_table[i].token;
4992 return token_table[i].token;
4993 }
4994 *e = save;
4995 }
4996
4997 if (rx_last_token == 0)
4998 {
4999 rx_last_token = UNKNOWN_OPCODE;
5000 return UNKNOWN_OPCODE;
5001 }
5002
5003 if (rx_last_token == UNKNOWN_OPCODE)
5004 return 0;
5005
5006 if (*rx_lex_start == '[')
5007 rx_in_brackets = 1;
5008 if (*rx_lex_start == ']')
5009 rx_in_brackets = 0;
5010
5011 if (rx_in_brackets
5012 || rx_last_token == REG || rx_last_token == DREG || rx_last_token == DCREG
5013 || strchr ("[],#", *rx_lex_start))
5014 {
5015 rx_last_token = *rx_lex_start;
5016 return *rx_lex_start ++;
5017 }
5018
5019 save_input_pointer = input_line_pointer;
5020 input_line_pointer = rx_lex_start;
5021 rx_lval.exp.X_md = 0;
5022 expression (&rx_lval.exp);
5023
5024 /* We parse but ignore any :<size> modifier on expressions. */
5025 if (*input_line_pointer == ':')
5026 {
5027 char *cp;
5028
5029 for (cp = input_line_pointer + 1; *cp && cp < rx_lex_end; cp++)
5030 if (!ISDIGIT (*cp))
5031 break;
5032 if (cp > input_line_pointer+1)
5033 input_line_pointer = cp;
5034 }
5035
5036 rx_lex_start = input_line_pointer;
5037 input_line_pointer = save_input_pointer;
5038 rx_last_token = EXPR;
5039 return EXPR;
5040 }
5041
5042 int
rx_error(const char * str)5043 rx_error (const char * str)
5044 {
5045 int len;
5046
5047 len = rx_last_exp_start - rx_init_start;
5048
5049 as_bad ("%s", rx_init_start);
5050 as_bad ("%*s^ %s", len, "", str);
5051 return 0;
5052 }
5053
5054 static int
rx_intop(expressionS exp,int nbits,int opbits)5055 rx_intop (expressionS exp, int nbits, int opbits)
5056 {
5057 valueT v;
5058 valueT mask, msb;
5059
5060 if (exp.X_op == O_big)
5061 {
5062 if (nbits == 32)
5063 return 1;
5064 if (exp.X_add_number == -1)
5065 return 0;
5066 }
5067 else if (exp.X_op != O_constant)
5068 return 0;
5069 v = exp.X_add_number;
5070
5071 msb = (valueT) 1 << (opbits - 1);
5072 mask = (msb << 1) - 1;
5073
5074 if ((v & msb) && ! (v & ~mask))
5075 v -= mask + 1;
5076
5077 switch (nbits)
5078 {
5079 case 4:
5080 return v + 0x8 <= 0x7 + 0x8;
5081 case 5:
5082 return v + 0x10 <= 0xf + 0x10;
5083 case 8:
5084 return v + 0x80 <= 0x7f + 0x80;
5085 case 16:
5086 return v + 0x8000 <= 0x7fff + 0x8000;
5087 case 24:
5088 return v + 0x800000 <= 0x7fffff + 0x800000;
5089 case 32:
5090 return 1;
5091 default:
5092 printf ("rx_intop passed %d\n", nbits);
5093 abort ();
5094 }
5095 return 1;
5096 }
5097
5098 static int
rx_uintop(expressionS exp,int nbits)5099 rx_uintop (expressionS exp, int nbits)
5100 {
5101 valueT v;
5102
5103 if (exp.X_op != O_constant)
5104 return 0;
5105 v = exp.X_add_number;
5106
5107 switch (nbits)
5108 {
5109 case 4:
5110 return v <= 0xf;
5111 case 8:
5112 return v <= 0xff;
5113 case 16:
5114 return v <= 0xffff;
5115 case 24:
5116 return v <= 0xffffff;
5117 default:
5118 printf ("rx_uintop passed %d\n", nbits);
5119 abort ();
5120 }
5121 return 1;
5122 }
5123
5124 static int
rx_disp3op(expressionS exp)5125 rx_disp3op (expressionS exp)
5126 {
5127 valueT v;
5128
5129 if (exp.X_op != O_constant)
5130 return 0;
5131 v = exp.X_add_number;
5132 if (v < 3 || v > 10)
5133 return 0;
5134 return 1;
5135 }
5136
5137 static int
rx_disp5op(expressionS * exp,int msize)5138 rx_disp5op (expressionS * exp, int msize)
5139 {
5140 valueT v;
5141
5142 if (exp->X_op != O_constant)
5143 return 0;
5144 v = exp->X_add_number;
5145
5146 switch (msize)
5147 {
5148 case BSIZE:
5149 if (v <= 31)
5150 return 1;
5151 break;
5152 case WSIZE:
5153 if (v & 1)
5154 return 0;
5155 if (v <= 63)
5156 {
5157 exp->X_add_number >>= 1;
5158 return 1;
5159 }
5160 break;
5161 case LSIZE:
5162 if (v & 3)
5163 return 0;
5164 if (v <= 127)
5165 {
5166 exp->X_add_number >>= 2;
5167 return 1;
5168 }
5169 break;
5170 }
5171 return 0;
5172 }
5173
5174 /* Just like the above, but allows a zero displacement. */
5175
5176 static int
rx_disp5op0(expressionS * exp,int msize)5177 rx_disp5op0 (expressionS * exp, int msize)
5178 {
5179 if (exp->X_op != O_constant)
5180 return 0;
5181 if (exp->X_add_number == 0)
5182 return 1;
5183 return rx_disp5op (exp, msize);
5184 }
5185
5186 static int
exp_val(expressionS exp)5187 exp_val (expressionS exp)
5188 {
5189 if (exp.X_op != O_constant)
5190 {
5191 rx_error (_("constant expected"));
5192 return 0;
5193 }
5194 return exp.X_add_number;
5195 }
5196
5197 static expressionS
zero_expr(void)5198 zero_expr (void)
5199 {
5200 /* Static, so program load sets it to all zeros, which is what we want. */
5201 static expressionS zero;
5202 zero.X_op = O_constant;
5203 return zero;
5204 }
5205
5206 static int
immediate(expressionS exp,int type,int pos,int bits)5207 immediate (expressionS exp, int type, int pos, int bits)
5208 {
5209 /* We will emit constants ourselves here, so negate them. */
5210 if (type == RXREL_NEGATIVE && exp.X_op == O_constant)
5211 exp.X_add_number = - exp.X_add_number;
5212 if (type == RXREL_NEGATIVE_BORROW)
5213 {
5214 if (exp.X_op == O_constant)
5215 exp.X_add_number = - exp.X_add_number - 1;
5216 else
5217 rx_error (_("sbb cannot use symbolic immediates"));
5218 }
5219
5220 if (pos >= 0 && rx_intop (exp, 8, bits))
5221 {
5222 rx_op (exp, 1, type);
5223 return 1;
5224 }
5225 else if (pos >= 0 && rx_intop (exp, 16, bits))
5226 {
5227 rx_op (exp, 2, type);
5228 return 2;
5229 }
5230 else if (pos >= 0 && rx_uintop (exp, 16) && bits == 16)
5231 {
5232 rx_op (exp, 2, type);
5233 return 2;
5234 }
5235 else if (pos >= 0 && rx_intop (exp, 24, bits))
5236 {
5237 rx_op (exp, 3, type);
5238 return 3;
5239 }
5240 else if (pos < 0 || rx_intop (exp, 32, bits))
5241 {
5242 rx_op (exp, 4, type);
5243 return 0;
5244 }
5245 else if (type == RXREL_SIGNED && pos >= 0)
5246 {
5247 /* This is a symbolic immediate, we will relax it later. */
5248 rx_relax (RX_RELAX_IMM, pos);
5249 rx_op (exp, linkrelax ? 4 : 1, type);
5250 return 1;
5251 }
5252 else
5253 {
5254 /* Let the linker deal with it. */
5255 rx_op (exp, 4, type);
5256 return 0;
5257 }
5258 }
5259
5260 static int
displacement(expressionS exp,int msize)5261 displacement (expressionS exp, int msize)
5262 {
5263 valueT val;
5264 int vshift = 0;
5265
5266 if (exp.X_op == O_symbol
5267 && exp.X_md)
5268 {
5269 switch (exp.X_md)
5270 {
5271 case BFD_RELOC_GPREL16:
5272 switch (msize)
5273 {
5274 case BSIZE:
5275 exp.X_md = BFD_RELOC_RX_GPRELB;
5276 break;
5277 case WSIZE:
5278 exp.X_md = BFD_RELOC_RX_GPRELW;
5279 break;
5280 case LSIZE:
5281 exp.X_md = BFD_RELOC_RX_GPRELL;
5282 break;
5283 }
5284 O2 (exp);
5285 return 2;
5286 }
5287 }
5288
5289 if (exp.X_op == O_subtract)
5290 {
5291 exp.X_md = BFD_RELOC_RX_DIFF;
5292 O2 (exp);
5293 return 2;
5294 }
5295
5296 if (exp.X_op != O_constant)
5297 {
5298 rx_error (_("displacements must be constants"));
5299 return -1;
5300 }
5301 val = exp.X_add_number;
5302
5303 if (val == 0)
5304 return 0;
5305
5306 switch (msize)
5307 {
5308 case BSIZE:
5309 break;
5310 case WSIZE:
5311 if (val & 1)
5312 rx_error (_("word displacement not word-aligned"));
5313 vshift = 1;
5314 break;
5315 case LSIZE:
5316 if (val & 3)
5317 rx_error (_("long displacement not long-aligned"));
5318 vshift = 2;
5319 break;
5320 case DSIZE:
5321 if (val & 7)
5322 rx_error (_("double displacement not double-aligned"));
5323 vshift = 3;
5324 break;
5325 default:
5326 as_bad (_("displacement with unknown size (internal bug?)\n"));
5327 break;
5328 }
5329
5330 val >>= vshift;
5331 exp.X_add_number = val;
5332
5333 if (val <= 255 )
5334 {
5335 O1 (exp);
5336 return 1;
5337 }
5338
5339 if (val <= 65535)
5340 {
5341 O2 (exp);
5342 return 2;
5343 }
5344 if ((offsetT) val < 0)
5345 rx_error (_("negative displacements not allowed"));
5346 else
5347 rx_error (_("displacement too large"));
5348 return -1;
5349 }
5350
5351 static void
rtsd_immediate(expressionS exp)5352 rtsd_immediate (expressionS exp)
5353 {
5354 valueT val;
5355
5356 if (exp.X_op != O_constant)
5357 {
5358 rx_error (_("rtsd size must be constant"));
5359 return;
5360 }
5361 val = exp.X_add_number;
5362 if (val & 3)
5363 rx_error (_("rtsd size must be multiple of 4"));
5364
5365 if (val > 1020)
5366 rx_error (_("rtsd size must be 0..1020"));
5367
5368 val >>= 2;
5369 exp.X_add_number = val;
5370 O1 (exp);
5371 }
5372
5373 static void
rx_range(expressionS exp,int minv,int maxv)5374 rx_range (expressionS exp, int minv, int maxv)
5375 {
5376 offsetT val;
5377
5378 if (exp.X_op != O_constant)
5379 return;
5380
5381 val = exp.X_add_number;
5382 if (val < minv || val > maxv)
5383 as_warn (_("Value %ld out of range %d..%d"), (long) val, minv, maxv);
5384 }
5385
5386 static void
rx_check_float_support(void)5387 rx_check_float_support (void)
5388 {
5389 if (rx_cpu == RX100 || rx_cpu == RX200)
5390 rx_error (_("target CPU type does not support floating point instructions"));
5391 }
5392
5393 static void
rx_check_v2(void)5394 rx_check_v2 (void)
5395 {
5396 if (rx_cpu < RXV2)
5397 rx_error (_("target CPU type does not support v2 instructions"));
5398 }
5399
5400 static void
rx_check_v3(void)5401 rx_check_v3 (void)
5402 {
5403 if (rx_cpu < RXV3)
5404 rx_error (_("target CPU type does not support v3 instructions"));
5405 }
5406
5407 static void
rx_check_dfpu(void)5408 rx_check_dfpu (void)
5409 {
5410 if (rx_cpu != RXV3FPU)
5411 rx_error (_("target CPU type does not support double float instructions"));
5412 }
5413