1 /* A Bison parser, made by GNU Bison 3.8.2. */
2
3 /* Bison implementation for Yacc-like parsers in C
4
5 Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation,
6 Inc.
7
8 This program is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <https://www.gnu.org/licenses/>. */
20
21 /* As a special exception, you may create a larger work that contains
22 part or all of the Bison parser skeleton and distribute that work
23 under terms of your choice, so long as that work isn't itself a
24 parser generator using the skeleton or a modified version thereof
25 as a parser skeleton. Alternatively, if you modify or redistribute
26 the parser skeleton itself, you may (at your option) remove this
27 special exception, which will cause the skeleton and the resulting
28 Bison output files to be licensed under the GNU General Public
29 License without this special exception.
30
31 This special exception was added by the Free Software Foundation in
32 version 2.2 of Bison. */
33
34 /* C LALR(1) parser skeleton written by Richard Stallman, by
35 simplifying the original so-called "semantic" parser. */
36
37 /* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual,
38 especially those whose name start with YY_ or yy_. They are
39 private implementation details that can be changed or removed. */
40
41 /* All symbols defined below should begin with yy or YY, to avoid
42 infringing on user name space. This should be done even for local
43 variables, as they might otherwise be expanded by user macros.
44 There are some unavoidable exceptions within include files to
45 define necessary library symbols; they are noted "INFRINGES ON
46 USER NAME SPACE" below. */
47
48 /* Identify Bison output, and Bison version. */
49 #define YYBISON 30802
50
51 /* Bison version string. */
52 #define YYBISON_VERSION "3.8.2"
53
54 /* Skeleton name. */
55 #define YYSKELETON_NAME "yacc.c"
56
57 /* Pure parsers. */
58 #define YYPURE 0
59
60 /* Push parsers. */
61 #define YYPUSH 0
62
63 /* Pull parsers. */
64 #define YYPULL 1
65
66
67
68
69 /* First part of user prologue. */
70 #line 21 "./itbl-parse.y"
71
72
73 /*
74
75 Yacc grammar for instruction table entries.
76
77 =======================================================================
78 Original Instruction table specification document:
79
80 MIPS Coprocessor Table Specification
81 ====================================
82
83 This document describes the format of the MIPS coprocessor table. The
84 table specifies a list of valid functions, data registers and control
85 registers that can be used in coprocessor instructions. This list,
86 together with the coprocessor instruction classes listed below,
87 specifies the complete list of coprocessor instructions that will
88 be recognized and assembled by the GNU assembler. In effect,
89 this makes the GNU assembler table-driven, where the table is
90 specified by the programmer.
91
92 The table is an ordinary text file that the GNU assembler reads when
93 it starts. Using the information in the table, the assembler
94 generates an internal list of valid coprocessor registers and
95 functions. The assembler uses this internal list in addition to the
96 standard MIPS registers and instructions which are built-in to the
97 assembler during code generation.
98
99 To specify the coprocessor table when invoking the GNU assembler, use
100 the command line option "--itbl file", where file is the
101 complete name of the table, including path and extension.
102
103 Examples:
104
105 gas -t cop.tbl test.s -o test.o
106 gas -t /usr/local/lib/cop.tbl test.s -o test.o
107 gas --itbl d:\gnu\data\cop.tbl test.s -o test.o
108
109 Only one table may be supplied during a single invocation of
110 the assembler.
111
112
113 Instruction classes
114 ===================
115
116 Below is a list of the valid coprocessor instruction classes for
117 any given coprocessor "z". These instructions are already recognized
118 by the assembler, and are listed here only for reference.
119
120 Class format instructions
121 -------------------------------------------------
122 Class1:
123 op base rt offset
124 LWCz rt,offset (base)
125 SWCz rt,offset (base)
126 Class2:
127 COPz sub rt rd 0
128 MTCz rt,rd
129 MFCz rt,rd
130 CTCz rt,rd
131 CFCz rt,rd
132 Class3:
133 COPz CO cofun
134 COPz cofun
135 Class4:
136 COPz BC br offset
137 BCzT offset
138 BCzF offset
139 Class5:
140 COPz sub rt rd 0
141 DMFCz rt,rd
142 DMTCz rt,rd
143 Class6:
144 op base rt offset
145 LDCz rt,offset (base)
146 SDCz rt,offset (base)
147 Class7:
148 COPz BC br offset
149 BCzTL offset
150 BCzFL offset
151
152 The coprocessor table defines coprocessor-specific registers that can
153 be used with all of the above classes of instructions, where
154 appropriate. It also defines additional coprocessor-specific
155 functions for Class3 (COPz cofun) instructions, Thus, the table allows
156 the programmer to use convenient mnemonics and operands for these
157 functions, instead of the COPz mmenmonic and cofun operand.
158
159 The names of the MIPS general registers and their aliases are defined
160 by the assembler and will be recognized as valid register names by the
161 assembler when used (where allowed) in coprocessor instructions.
162 However, the names and values of all coprocessor data and control
163 register mnemonics must be specified in the coprocessor table.
164
165
166 Table Grammar
167 =============
168
169 Here is the grammar for the coprocessor table:
170
171 table -> entry*
172
173 entry -> [z entrydef] [comment] '\n'
174
175 entrydef -> type name val
176 entrydef -> 'insn' name val funcdef ; type of entry (instruction)
177
178 z -> 'p'['0'..'3'] ; processor number
179 type -> ['dreg' | 'creg' | 'greg' ] ; type of entry (register)
180 ; 'dreg', 'creg' or 'greg' specifies a data, control, or general
181 ; register mnemonic, respectively
182 name -> [ltr|dec]* ; mnemonic of register/function
183 val -> [dec|hex] ; register/function number (integer constant)
184
185 funcdef -> frange flags fields
186 ; bitfield range for opcode
187 ; list of fields' formats
188 fields -> field*
189 field -> [','] ftype frange flags
190 flags -> ['*' flagexpr]
191 flagexpr -> '[' flagexpr ']'
192 flagexpr -> val '|' flagexpr
193 ftype -> [ type | 'immed' | 'addr' ]
194 ; 'immed' specifies an immediate value; see grammar for "val" above
195 ; 'addr' specifies a C identifier; name of symbol to be resolved at
196 ; link time
197 frange -> ':' val '-' val ; starting to ending bit positions, where
198 ; where 0 is least significant bit
199 frange -> (null) ; default range of 31-0 will be assumed
200
201 comment -> [';'|'#'] [char]*
202 char -> any printable character
203 ltr -> ['a'..'z'|'A'..'Z']
204 dec -> ['0'..'9']* ; value in decimal
205 hex -> '0x'['0'..'9' | 'a'..'f' | 'A'..'F']* ; value in hexadecimal
206
207
208 Examples
209 ========
210
211 Example 1:
212
213 The table:
214
215 p1 dreg d1 1 ; data register "d1" for COP1 has value 1
216 p1 creg c3 3 ; ctrl register "c3" for COP1 has value 3
217 p3 func fill 0x1f:24-20 ; function "fill" for COP3 has value 31 and
218 ; no fields
219
220 will allow the assembler to accept the following coprocessor instructions:
221
222 LWC1 d1,0x100 ($2)
223 fill
224
225 Here, the general purpose register "$2", and instruction "LWC1", are standard
226 mnemonics built-in to the MIPS assembler.
227
228
229 Example 2:
230
231 The table:
232
233 p3 dreg d3 3 ; data register "d3" for COP3 has value 3
234 p3 creg c2 22 ; control register "c2" for COP3 has value 22
235 p3 func fee 0x1f:24-20 dreg:17-13 creg:12-8 immed:7-0
236 ; function "fee" for COP3 has value 31, and 3 fields
237 ; consisting of a data register, a control register,
238 ; and an immediate value.
239
240 will allow the assembler to accept the following coprocessor instruction:
241
242 fee d3,c2,0x1
243
244 and will emit the object code:
245
246 31-26 25 24-20 19-18 17-13 12-8 7-0
247 COPz CO fun dreg creg immed
248 010011 1 11111 00 00011 10110 00000001
249
250 0x4ff07601
251
252
253 Example 3:
254
255 The table:
256
257 p3 dreg d3 3 ; data register "d3" for COP3 has value 3
258 p3 creg c2 22 ; control register "c2" for COP3 has value 22
259 p3 func fuu 0x01f00001 dreg:17-13 creg:12-8
260
261 will allow the assembler to accept the following coprocessor
262 instruction:
263
264 fuu d3,c2
265
266 and will emit the object code:
267
268 31-26 25 24-20 19-18 17-13 12-8 7-0
269 COPz CO fun dreg creg
270 010011 1 11111 00 00011 10110 00000001
271
272 0x4ff07601
273
274 In this way, the programmer can force arbitrary bits of an instruction
275 to have predefined values.
276
277 =======================================================================
278 Additional notes:
279
280 Encoding of ranges:
281 To handle more than one bit position range within an instruction,
282 use 0s to mask out the ranges which don't apply.
283 May decide to modify the syntax to allow commas separate multiple
284 ranges within an instruction (range','range).
285
286 Changes in grammar:
287 The number of parms argument to the function entry
288 was deleted from the original format such that we now count the fields.
289
290 ----
291 FIXME! should really change lexical analyzer
292 to recognize 'dreg' etc. in context sensitive way.
293 Currently function names or mnemonics may be incorrectly parsed as keywords
294
295 FIXME! hex is ambiguous with any digit
296
297 */
298
299 #include "as.h"
300 #include "itbl-lex.h"
301 #include "itbl-ops.h"
302
303 /* #define DEBUG */
304
305 #ifdef DEBUG
306 #ifndef DBG_LVL
307 #define DBG_LVL 1
308 #endif
309 #else
310 #define DBG_LVL 0
311 #endif
312
313 #if DBG_LVL >= 1
314 #define DBG(x) printf x
315 #else
316 #define DBG(x)
317 #endif
318
319 #if DBG_LVL >= 2
320 #define DBGL2(x) printf x
321 #else
322 #define DBGL2(x)
323 #endif
324
325 static int sbit, ebit;
326 static struct itbl_entry *insn=0;
327 static void yyerror (const char *);
328
329
330 #line 331 "itbl-parse.c"
331
332 # ifndef YY_CAST
333 # ifdef __cplusplus
334 # define YY_CAST(Type, Val) static_cast<Type> (Val)
335 # define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
336 # else
337 # define YY_CAST(Type, Val) ((Type) (Val))
338 # define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
339 # endif
340 # endif
341 # ifndef YY_NULLPTR
342 # if defined __cplusplus
343 # if 201103L <= __cplusplus
344 # define YY_NULLPTR nullptr
345 # else
346 # define YY_NULLPTR 0
347 # endif
348 # else
349 # define YY_NULLPTR ((void*)0)
350 # endif
351 # endif
352
353 /* Use api.header.include to #include this header
354 instead of duplicating it here. */
355 #ifndef YY_YY_ITBL_PARSE_H_INCLUDED
356 # define YY_YY_ITBL_PARSE_H_INCLUDED
357 /* Debug traces. */
358 #ifndef YYDEBUG
359 # define YYDEBUG 0
360 #endif
361 #if YYDEBUG
362 extern int yydebug;
363 #endif
364
365 /* Token kinds. */
366 #ifndef YYTOKENTYPE
367 # define YYTOKENTYPE
368 enum yytokentype
369 {
370 YYEMPTY = -2,
371 YYEOF = 0, /* "end of file" */
372 YYerror = 256, /* error */
373 YYUNDEF = 257, /* "invalid token" */
374 DREG = 258, /* DREG */
375 CREG = 259, /* CREG */
376 GREG = 260, /* GREG */
377 IMMED = 261, /* IMMED */
378 ADDR = 262, /* ADDR */
379 INSN = 263, /* INSN */
380 NUM = 264, /* NUM */
381 ID = 265, /* ID */
382 NL = 266, /* NL */
383 PNUM = 267 /* PNUM */
384 };
385 typedef enum yytokentype yytoken_kind_t;
386 #endif
387 /* Token kinds. */
388 #define YYEMPTY -2
389 #define YYEOF 0
390 #define YYerror 256
391 #define YYUNDEF 257
392 #define DREG 258
393 #define CREG 259
394 #define GREG 260
395 #define IMMED 261
396 #define ADDR 262
397 #define INSN 263
398 #define NUM 264
399 #define ID 265
400 #define NL 266
401 #define PNUM 267
402
403 /* Value type. */
404 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
405 union YYSTYPE
406 {
407 #line 282 "./itbl-parse.y"
408
409 char *str;
410 int num;
411 int processor;
412 unsigned long val;
413
414
415 #line 416 "itbl-parse.c"
416
417 };
418 typedef union YYSTYPE YYSTYPE;
419 # define YYSTYPE_IS_TRIVIAL 1
420 # define YYSTYPE_IS_DECLARED 1
421 #endif
422
423
424 extern YYSTYPE yylval;
425
426
427 int yyparse (void);
428
429
430 #endif /* !YY_YY_ITBL_PARSE_H_INCLUDED */
431 /* Symbol kind. */
432 enum yysymbol_kind_t
433 {
434 YYSYMBOL_YYEMPTY = -2,
435 YYSYMBOL_YYEOF = 0, /* "end of file" */
436 YYSYMBOL_YYerror = 1, /* error */
437 YYSYMBOL_YYUNDEF = 2, /* "invalid token" */
438 YYSYMBOL_DREG = 3, /* DREG */
439 YYSYMBOL_CREG = 4, /* CREG */
440 YYSYMBOL_GREG = 5, /* GREG */
441 YYSYMBOL_IMMED = 6, /* IMMED */
442 YYSYMBOL_ADDR = 7, /* ADDR */
443 YYSYMBOL_INSN = 8, /* INSN */
444 YYSYMBOL_NUM = 9, /* NUM */
445 YYSYMBOL_ID = 10, /* ID */
446 YYSYMBOL_NL = 11, /* NL */
447 YYSYMBOL_PNUM = 12, /* PNUM */
448 YYSYMBOL_13_ = 13, /* ',' */
449 YYSYMBOL_14_ = 14, /* '|' */
450 YYSYMBOL_15_ = 15, /* '[' */
451 YYSYMBOL_16_ = 16, /* ']' */
452 YYSYMBOL_17_ = 17, /* '*' */
453 YYSYMBOL_18_ = 18, /* ':' */
454 YYSYMBOL_19_ = 19, /* '-' */
455 YYSYMBOL_YYACCEPT = 20, /* $accept */
456 YYSYMBOL_insntbl = 21, /* insntbl */
457 YYSYMBOL_entrys = 22, /* entrys */
458 YYSYMBOL_entry = 23, /* entry */
459 YYSYMBOL_24_1 = 24, /* $@1 */
460 YYSYMBOL_fieldspecs = 25, /* fieldspecs */
461 YYSYMBOL_ftype = 26, /* ftype */
462 YYSYMBOL_fieldspec = 27, /* fieldspec */
463 YYSYMBOL_flagexpr = 28, /* flagexpr */
464 YYSYMBOL_flags = 29, /* flags */
465 YYSYMBOL_range = 30, /* range */
466 YYSYMBOL_pnum = 31, /* pnum */
467 YYSYMBOL_regtype = 32, /* regtype */
468 YYSYMBOL_name = 33, /* name */
469 YYSYMBOL_value = 34 /* value */
470 };
471 typedef enum yysymbol_kind_t yysymbol_kind_t;
472
473
474
475
476 #ifdef short
477 # undef short
478 #endif
479
480 /* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
481 <limits.h> and (if available) <stdint.h> are included
482 so that the code can choose integer types of a good width. */
483
484 #ifndef __PTRDIFF_MAX__
485 # include <limits.h> /* INFRINGES ON USER NAME SPACE */
486 # if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
487 # include <stdint.h> /* INFRINGES ON USER NAME SPACE */
488 # define YY_STDINT_H
489 # endif
490 #endif
491
492 /* Narrow types that promote to a signed type and that can represent a
493 signed or unsigned integer of at least N bits. In tables they can
494 save space and decrease cache pressure. Promoting to a signed type
495 helps avoid bugs in integer arithmetic. */
496
497 #ifdef __INT_LEAST8_MAX__
498 typedef __INT_LEAST8_TYPE__ yytype_int8;
499 #elif defined YY_STDINT_H
500 typedef int_least8_t yytype_int8;
501 #else
502 typedef signed char yytype_int8;
503 #endif
504
505 #ifdef __INT_LEAST16_MAX__
506 typedef __INT_LEAST16_TYPE__ yytype_int16;
507 #elif defined YY_STDINT_H
508 typedef int_least16_t yytype_int16;
509 #else
510 typedef short yytype_int16;
511 #endif
512
513 /* Work around bug in HP-UX 11.23, which defines these macros
514 incorrectly for preprocessor constants. This workaround can likely
515 be removed in 2023, as HPE has promised support for HP-UX 11.23
516 (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of
517 <https://h20195.www2.hpe.com/V2/getpdf.aspx/4AA4-7673ENW.pdf>. */
518 #ifdef __hpux
519 # undef UINT_LEAST8_MAX
520 # undef UINT_LEAST16_MAX
521 # define UINT_LEAST8_MAX 255
522 # define UINT_LEAST16_MAX 65535
523 #endif
524
525 #if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
526 typedef __UINT_LEAST8_TYPE__ yytype_uint8;
527 #elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
528 && UINT_LEAST8_MAX <= INT_MAX)
529 typedef uint_least8_t yytype_uint8;
530 #elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
531 typedef unsigned char yytype_uint8;
532 #else
533 typedef short yytype_uint8;
534 #endif
535
536 #if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
537 typedef __UINT_LEAST16_TYPE__ yytype_uint16;
538 #elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
539 && UINT_LEAST16_MAX <= INT_MAX)
540 typedef uint_least16_t yytype_uint16;
541 #elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
542 typedef unsigned short yytype_uint16;
543 #else
544 typedef int yytype_uint16;
545 #endif
546
547 #ifndef YYPTRDIFF_T
548 # if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
549 # define YYPTRDIFF_T __PTRDIFF_TYPE__
550 # define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
551 # elif defined PTRDIFF_MAX
552 # ifndef ptrdiff_t
553 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
554 # endif
555 # define YYPTRDIFF_T ptrdiff_t
556 # define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
557 # else
558 # define YYPTRDIFF_T long
559 # define YYPTRDIFF_MAXIMUM LONG_MAX
560 # endif
561 #endif
562
563 #ifndef YYSIZE_T
564 # ifdef __SIZE_TYPE__
565 # define YYSIZE_T __SIZE_TYPE__
566 # elif defined size_t
567 # define YYSIZE_T size_t
568 # elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
569 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
570 # define YYSIZE_T size_t
571 # else
572 # define YYSIZE_T unsigned
573 # endif
574 #endif
575
576 #define YYSIZE_MAXIMUM \
577 YY_CAST (YYPTRDIFF_T, \
578 (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \
579 ? YYPTRDIFF_MAXIMUM \
580 : YY_CAST (YYSIZE_T, -1)))
581
582 #define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
583
584
585 /* Stored state numbers (used for stacks). */
586 typedef yytype_int8 yy_state_t;
587
588 /* State numbers in computations. */
589 typedef int yy_state_fast_t;
590
591 #ifndef YY_
592 # if defined YYENABLE_NLS && YYENABLE_NLS
593 # if ENABLE_NLS
594 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
595 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
596 # endif
597 # endif
598 # ifndef YY_
599 # define YY_(Msgid) Msgid
600 # endif
601 #endif
602
603
604 #ifndef YY_ATTRIBUTE_PURE
605 # if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
606 # define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
607 # else
608 # define YY_ATTRIBUTE_PURE
609 # endif
610 #endif
611
612 #ifndef YY_ATTRIBUTE_UNUSED
613 # if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
614 # define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
615 # else
616 # define YY_ATTRIBUTE_UNUSED
617 # endif
618 #endif
619
620 /* Suppress unused-variable warnings by "using" E. */
621 #if ! defined lint || defined __GNUC__
622 # define YY_USE(E) ((void) (E))
623 #else
624 # define YY_USE(E) /* empty */
625 #endif
626
627 /* Suppress an incorrect diagnostic about yylval being uninitialized. */
628 #if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__
629 # if __GNUC__ * 100 + __GNUC_MINOR__ < 407
630 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
631 _Pragma ("GCC diagnostic push") \
632 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")
633 # else
634 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
635 _Pragma ("GCC diagnostic push") \
636 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
637 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
638 # endif
639 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
640 _Pragma ("GCC diagnostic pop")
641 #else
642 # define YY_INITIAL_VALUE(Value) Value
643 #endif
644 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
645 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
646 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
647 #endif
648 #ifndef YY_INITIAL_VALUE
649 # define YY_INITIAL_VALUE(Value) /* Nothing. */
650 #endif
651
652 #if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
653 # define YY_IGNORE_USELESS_CAST_BEGIN \
654 _Pragma ("GCC diagnostic push") \
655 _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
656 # define YY_IGNORE_USELESS_CAST_END \
657 _Pragma ("GCC diagnostic pop")
658 #endif
659 #ifndef YY_IGNORE_USELESS_CAST_BEGIN
660 # define YY_IGNORE_USELESS_CAST_BEGIN
661 # define YY_IGNORE_USELESS_CAST_END
662 #endif
663
664
665 #define YY_ASSERT(E) ((void) (0 && (E)))
666
667 #if !defined yyoverflow
668
669 /* The parser invokes alloca or malloc; define the necessary symbols. */
670
671 # ifdef YYSTACK_USE_ALLOCA
672 # if YYSTACK_USE_ALLOCA
673 # ifdef __GNUC__
674 # define YYSTACK_ALLOC __builtin_alloca
675 # elif defined __BUILTIN_VA_ARG_INCR
676 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
677 # elif defined _AIX
678 # define YYSTACK_ALLOC __alloca
679 # elif defined _MSC_VER
680 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
681 # define alloca _alloca
682 # else
683 # define YYSTACK_ALLOC alloca
684 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
685 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
686 /* Use EXIT_SUCCESS as a witness for stdlib.h. */
687 # ifndef EXIT_SUCCESS
688 # define EXIT_SUCCESS 0
689 # endif
690 # endif
691 # endif
692 # endif
693 # endif
694
695 # ifdef YYSTACK_ALLOC
696 /* Pacify GCC's 'empty if-body' warning. */
697 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
698 # ifndef YYSTACK_ALLOC_MAXIMUM
699 /* The OS might guarantee only one guard page at the bottom of the stack,
700 and a page size can be as small as 4096 bytes. So we cannot safely
701 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
702 to allow for a few compiler-allocated temporary stack slots. */
703 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
704 # endif
705 # else
706 # define YYSTACK_ALLOC YYMALLOC
707 # define YYSTACK_FREE YYFREE
708 # ifndef YYSTACK_ALLOC_MAXIMUM
709 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
710 # endif
711 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
712 && ! ((defined YYMALLOC || defined malloc) \
713 && (defined YYFREE || defined free)))
714 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
715 # ifndef EXIT_SUCCESS
716 # define EXIT_SUCCESS 0
717 # endif
718 # endif
719 # ifndef YYMALLOC
720 # define YYMALLOC malloc
721 # if ! defined malloc && ! defined EXIT_SUCCESS
722 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
723 # endif
724 # endif
725 # ifndef YYFREE
726 # define YYFREE free
727 # if ! defined free && ! defined EXIT_SUCCESS
728 void free (void *); /* INFRINGES ON USER NAME SPACE */
729 # endif
730 # endif
731 # endif
732 #endif /* !defined yyoverflow */
733
734 #if (! defined yyoverflow \
735 && (! defined __cplusplus \
736 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
737
738 /* A type that is properly aligned for any stack member. */
739 union yyalloc
740 {
741 yy_state_t yyss_alloc;
742 YYSTYPE yyvs_alloc;
743 };
744
745 /* The size of the maximum gap between one aligned stack and the next. */
746 # define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
747
748 /* The size of an array large to enough to hold all stacks, each with
749 N elements. */
750 # define YYSTACK_BYTES(N) \
751 ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \
752 + YYSTACK_GAP_MAXIMUM)
753
754 # define YYCOPY_NEEDED 1
755
756 /* Relocate STACK from its old location to the new one. The
757 local variables YYSIZE and YYSTACKSIZE give the old and new number of
758 elements in the stack, and YYPTR gives the new location of the
759 stack. Advance YYPTR to a properly aligned location for the next
760 stack. */
761 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
762 do \
763 { \
764 YYPTRDIFF_T yynewbytes; \
765 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
766 Stack = &yyptr->Stack_alloc; \
767 yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
768 yyptr += yynewbytes / YYSIZEOF (*yyptr); \
769 } \
770 while (0)
771
772 #endif
773
774 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
775 /* Copy COUNT objects from SRC to DST. The source and destination do
776 not overlap. */
777 # ifndef YYCOPY
778 # if defined __GNUC__ && 1 < __GNUC__
779 # define YYCOPY(Dst, Src, Count) \
780 __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
781 # else
782 # define YYCOPY(Dst, Src, Count) \
783 do \
784 { \
785 YYPTRDIFF_T yyi; \
786 for (yyi = 0; yyi < (Count); yyi++) \
787 (Dst)[yyi] = (Src)[yyi]; \
788 } \
789 while (0)
790 # endif
791 # endif
792 #endif /* !YYCOPY_NEEDED */
793
794 /* YYFINAL -- State number of the termination state. */
795 #define YYFINAL 9
796 /* YYLAST -- Last index in YYTABLE. */
797 #define YYLAST 46
798
799 /* YYNTOKENS -- Number of terminals. */
800 #define YYNTOKENS 20
801 /* YYNNTS -- Number of nonterminals. */
802 #define YYNNTS 15
803 /* YYNRULES -- Number of rules. */
804 #define YYNRULES 29
805 /* YYNSTATES -- Number of states. */
806 #define YYNSTATES 51
807
808 /* YYMAXUTOK -- Last valid token kind. */
809 #define YYMAXUTOK 267
810
811
812 /* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
813 as returned by yylex, with out-of-bounds checking. */
814 #define YYTRANSLATE(YYX) \
815 (0 <= (YYX) && (YYX) <= YYMAXUTOK \
816 ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \
817 : YYSYMBOL_YYUNDEF)
818
819 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
820 as returned by yylex. */
821 static const yytype_int8 yytranslate[] =
822 {
823 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
824 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
825 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
826 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
827 2, 2, 17, 2, 13, 19, 2, 2, 2, 2,
828 2, 2, 2, 2, 2, 2, 2, 2, 18, 2,
829 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
830 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
831 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
832 2, 15, 2, 16, 2, 2, 2, 2, 2, 2,
833 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
834 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
835 2, 2, 2, 2, 14, 2, 2, 2, 2, 2,
836 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
837 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
838 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
839 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
840 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
841 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
842 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
843 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
844 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
845 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
846 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
847 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
848 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
849 5, 6, 7, 8, 9, 10, 11, 12
850 };
851
852 #if YYDEBUG
853 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
854 static const yytype_int16 yyrline[] =
855 {
856 0, 299, 299, 303, 304, 308, 315, 314, 323, 324,
857 328, 329, 330, 334, 339, 344, 352, 361, 365, 369,
858 376, 382, 388, 395, 402, 410, 415, 420, 428, 444
859 };
860 #endif
861
862 /** Accessing symbol of state STATE. */
863 #define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State])
864
865 #if YYDEBUG || 0
866 /* The user-facing name of the symbol whose (internal) number is
867 YYSYMBOL. No bounds checking. */
868 static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED;
869
870 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
871 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
872 static const char *const yytname[] =
873 {
874 "\"end of file\"", "error", "\"invalid token\"", "DREG", "CREG", "GREG",
875 "IMMED", "ADDR", "INSN", "NUM", "ID", "NL", "PNUM", "','", "'|'", "'['",
876 "']'", "'*'", "':'", "'-'", "$accept", "insntbl", "entrys", "entry",
877 "$@1", "fieldspecs", "ftype", "fieldspec", "flagexpr", "flags", "range",
878 "pnum", "regtype", "name", "value", YY_NULLPTR
879 };
880
881 static const char *
yysymbol_name(yysymbol_kind_t yysymbol)882 yysymbol_name (yysymbol_kind_t yysymbol)
883 {
884 return yytname[yysymbol];
885 }
886 #endif
887
888 #define YYPACT_NINF (-16)
889
890 #define yypact_value_is_default(Yyn) \
891 ((Yyn) == YYPACT_NINF)
892
893 #define YYTABLE_NINF (-5)
894
895 #define yytable_value_is_error(Yyn) \
896 0
897
898 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
899 STATE-NUM. */
900 static const yytype_int8 yypact[] =
901 {
902 0, -9, -16, -16, 10, -16, 0, 12, -16, -16,
903 -16, -16, -16, -16, 3, 3, -16, 9, 9, -16,
904 11, 8, 19, 15, -16, 14, -6, -16, 25, 21,
905 -6, -16, 1, -16, -6, 20, -16, -16, 18, 26,
906 11, 1, -16, -16, -16, 1, -16, 15, -16, -16,
907 -16
908 };
909
910 /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
911 Performed when YYTABLE does not specify something else to do. Zero
912 means the default is an error. */
913 static const yytype_int8 yydefact[] =
914 {
915 0, 0, 8, 24, 0, 2, 0, 0, 9, 1,
916 3, 25, 26, 27, 0, 0, 28, 0, 0, 29,
917 23, 0, 0, 21, 5, 0, 0, 6, 0, 19,
918 0, 20, 12, 22, 0, 0, 15, 14, 0, 0,
919 23, 12, 13, 17, 18, 12, 7, 21, 11, 10,
920 16
921 };
922
923 /* YYPGOTO[NTERM-NUM]. */
924 static const yytype_int8 yypgoto[] =
925 {
926 -16, -16, 32, -16, -16, -15, -16, 2, -3, -8,
927 4, -16, 34, 27, 28
928 };
929
930 /* YYDEFGOTO[NTERM-NUM]. */
931 static const yytype_int8 yydefgoto[] =
932 {
933 0, 4, 5, 6, 32, 39, 40, 41, 31, 27,
934 23, 7, 42, 17, 20
935 };
936
937 /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
938 positive, shift that token. If negative, reduce the rule whose
939 number is the opposite. If YYTABLE_NINF, syntax error. */
940 static const yytype_int8 yytable[] =
941 {
942 -4, 1, 8, 29, 11, 12, 13, 36, 37, 30,
943 9, 2, 3, 16, 38, 11, 12, 13, 19, 24,
944 14, 11, 12, 13, 36, 37, 48, 35, 25, 22,
945 49, 43, 26, 28, 33, 34, 44, 46, 10, 50,
946 45, 15, 18, 0, 47, 0, 21
947 };
948
949 static const yytype_int8 yycheck[] =
950 {
951 0, 1, 11, 9, 3, 4, 5, 6, 7, 15,
952 0, 11, 12, 10, 13, 3, 4, 5, 9, 11,
953 8, 3, 4, 5, 6, 7, 41, 30, 9, 18,
954 45, 34, 17, 19, 9, 14, 16, 11, 6, 47,
955 38, 7, 15, -1, 40, -1, 18
956 };
957
958 /* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of
959 state STATE-NUM. */
960 static const yytype_int8 yystos[] =
961 {
962 0, 1, 11, 12, 21, 22, 23, 31, 11, 0,
963 22, 3, 4, 5, 8, 32, 10, 33, 33, 9,
964 34, 34, 18, 30, 11, 9, 17, 29, 19, 9,
965 15, 28, 24, 9, 14, 28, 6, 7, 13, 25,
966 26, 27, 32, 28, 16, 27, 11, 30, 25, 25,
967 29
968 };
969
970 /* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM. */
971 static const yytype_int8 yyr1[] =
972 {
973 0, 20, 21, 22, 22, 23, 24, 23, 23, 23,
974 25, 25, 25, 26, 26, 26, 27, 28, 28, 28,
975 29, 29, 30, 30, 31, 32, 32, 32, 33, 34
976 };
977
978 /* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM. */
979 static const yytype_int8 yyr2[] =
980 {
981 0, 2, 1, 2, 0, 5, 0, 9, 1, 2,
982 3, 2, 0, 1, 1, 1, 3, 3, 3, 1,
983 2, 0, 4, 0, 1, 1, 1, 1, 1, 1
984 };
985
986
987 enum { YYENOMEM = -2 };
988
989 #define yyerrok (yyerrstatus = 0)
990 #define yyclearin (yychar = YYEMPTY)
991
992 #define YYACCEPT goto yyacceptlab
993 #define YYABORT goto yyabortlab
994 #define YYERROR goto yyerrorlab
995 #define YYNOMEM goto yyexhaustedlab
996
997
998 #define YYRECOVERING() (!!yyerrstatus)
999
1000 #define YYBACKUP(Token, Value) \
1001 do \
1002 if (yychar == YYEMPTY) \
1003 { \
1004 yychar = (Token); \
1005 yylval = (Value); \
1006 YYPOPSTACK (yylen); \
1007 yystate = *yyssp; \
1008 goto yybackup; \
1009 } \
1010 else \
1011 { \
1012 yyerror (YY_("syntax error: cannot back up")); \
1013 YYERROR; \
1014 } \
1015 while (0)
1016
1017 /* Backward compatibility with an undocumented macro.
1018 Use YYerror or YYUNDEF. */
1019 #define YYERRCODE YYUNDEF
1020
1021
1022 /* Enable debugging if requested. */
1023 #if YYDEBUG
1024
1025 # ifndef YYFPRINTF
1026 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1027 # define YYFPRINTF fprintf
1028 # endif
1029
1030 # define YYDPRINTF(Args) \
1031 do { \
1032 if (yydebug) \
1033 YYFPRINTF Args; \
1034 } while (0)
1035
1036
1037
1038
1039 # define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \
1040 do { \
1041 if (yydebug) \
1042 { \
1043 YYFPRINTF (stderr, "%s ", Title); \
1044 yy_symbol_print (stderr, \
1045 Kind, Value); \
1046 YYFPRINTF (stderr, "\n"); \
1047 } \
1048 } while (0)
1049
1050
1051 /*-----------------------------------.
1052 | Print this symbol's value on YYO. |
1053 `-----------------------------------*/
1054
1055 static void
yy_symbol_value_print(FILE * yyo,yysymbol_kind_t yykind,YYSTYPE const * const yyvaluep)1056 yy_symbol_value_print (FILE *yyo,
1057 yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep)
1058 {
1059 FILE *yyoutput = yyo;
1060 YY_USE (yyoutput);
1061 if (!yyvaluep)
1062 return;
1063 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1064 YY_USE (yykind);
1065 YY_IGNORE_MAYBE_UNINITIALIZED_END
1066 }
1067
1068
1069 /*---------------------------.
1070 | Print this symbol on YYO. |
1071 `---------------------------*/
1072
1073 static void
yy_symbol_print(FILE * yyo,yysymbol_kind_t yykind,YYSTYPE const * const yyvaluep)1074 yy_symbol_print (FILE *yyo,
1075 yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep)
1076 {
1077 YYFPRINTF (yyo, "%s %s (",
1078 yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind));
1079
1080 yy_symbol_value_print (yyo, yykind, yyvaluep);
1081 YYFPRINTF (yyo, ")");
1082 }
1083
1084 /*------------------------------------------------------------------.
1085 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1086 | TOP (included). |
1087 `------------------------------------------------------------------*/
1088
1089 static void
yy_stack_print(yy_state_t * yybottom,yy_state_t * yytop)1090 yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
1091 {
1092 YYFPRINTF (stderr, "Stack now");
1093 for (; yybottom <= yytop; yybottom++)
1094 {
1095 int yybot = *yybottom;
1096 YYFPRINTF (stderr, " %d", yybot);
1097 }
1098 YYFPRINTF (stderr, "\n");
1099 }
1100
1101 # define YY_STACK_PRINT(Bottom, Top) \
1102 do { \
1103 if (yydebug) \
1104 yy_stack_print ((Bottom), (Top)); \
1105 } while (0)
1106
1107
1108 /*------------------------------------------------.
1109 | Report that the YYRULE is going to be reduced. |
1110 `------------------------------------------------*/
1111
1112 static void
yy_reduce_print(yy_state_t * yyssp,YYSTYPE * yyvsp,int yyrule)1113 yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp,
1114 int yyrule)
1115 {
1116 int yylno = yyrline[yyrule];
1117 int yynrhs = yyr2[yyrule];
1118 int yyi;
1119 YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
1120 yyrule - 1, yylno);
1121 /* The symbols being reduced. */
1122 for (yyi = 0; yyi < yynrhs; yyi++)
1123 {
1124 YYFPRINTF (stderr, " $%d = ", yyi + 1);
1125 yy_symbol_print (stderr,
1126 YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]),
1127 &yyvsp[(yyi + 1) - (yynrhs)]);
1128 YYFPRINTF (stderr, "\n");
1129 }
1130 }
1131
1132 # define YY_REDUCE_PRINT(Rule) \
1133 do { \
1134 if (yydebug) \
1135 yy_reduce_print (yyssp, yyvsp, Rule); \
1136 } while (0)
1137
1138 /* Nonzero means print parse trace. It is left uninitialized so that
1139 multiple parsers can coexist. */
1140 int yydebug;
1141 #else /* !YYDEBUG */
1142 # define YYDPRINTF(Args) ((void) 0)
1143 # define YY_SYMBOL_PRINT(Title, Kind, Value, Location)
1144 # define YY_STACK_PRINT(Bottom, Top)
1145 # define YY_REDUCE_PRINT(Rule)
1146 #endif /* !YYDEBUG */
1147
1148
1149 /* YYINITDEPTH -- initial size of the parser's stacks. */
1150 #ifndef YYINITDEPTH
1151 # define YYINITDEPTH 200
1152 #endif
1153
1154 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1155 if the built-in stack extension method is used).
1156
1157 Do not make this value too large; the results are undefined if
1158 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1159 evaluated with infinite-precision integer arithmetic. */
1160
1161 #ifndef YYMAXDEPTH
1162 # define YYMAXDEPTH 10000
1163 #endif
1164
1165
1166
1167
1168
1169
1170 /*-----------------------------------------------.
1171 | Release the memory associated to this symbol. |
1172 `-----------------------------------------------*/
1173
1174 static void
yydestruct(const char * yymsg,yysymbol_kind_t yykind,YYSTYPE * yyvaluep)1175 yydestruct (const char *yymsg,
1176 yysymbol_kind_t yykind, YYSTYPE *yyvaluep)
1177 {
1178 YY_USE (yyvaluep);
1179 if (!yymsg)
1180 yymsg = "Deleting";
1181 YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp);
1182
1183 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1184 YY_USE (yykind);
1185 YY_IGNORE_MAYBE_UNINITIALIZED_END
1186 }
1187
1188
1189 /* Lookahead token kind. */
1190 int yychar;
1191
1192 /* The semantic value of the lookahead symbol. */
1193 YYSTYPE yylval;
1194 /* Number of syntax errors so far. */
1195 int yynerrs;
1196
1197
1198
1199
1200 /*----------.
1201 | yyparse. |
1202 `----------*/
1203
1204 int
yyparse(void)1205 yyparse (void)
1206 {
1207 yy_state_fast_t yystate = 0;
1208 /* Number of tokens to shift before error messages enabled. */
1209 int yyerrstatus = 0;
1210
1211 /* Refer to the stacks through separate pointers, to allow yyoverflow
1212 to reallocate them elsewhere. */
1213
1214 /* Their size. */
1215 YYPTRDIFF_T yystacksize = YYINITDEPTH;
1216
1217 /* The state stack: array, bottom, top. */
1218 yy_state_t yyssa[YYINITDEPTH];
1219 yy_state_t *yyss = yyssa;
1220 yy_state_t *yyssp = yyss;
1221
1222 /* The semantic value stack: array, bottom, top. */
1223 YYSTYPE yyvsa[YYINITDEPTH];
1224 YYSTYPE *yyvs = yyvsa;
1225 YYSTYPE *yyvsp = yyvs;
1226
1227 int yyn;
1228 /* The return value of yyparse. */
1229 int yyresult;
1230 /* Lookahead symbol kind. */
1231 yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY;
1232 /* The variables used to return semantic value and location from the
1233 action routines. */
1234 YYSTYPE yyval;
1235
1236
1237
1238 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1239
1240 /* The number of symbols on the RHS of the reduced rule.
1241 Keep to zero when no symbol should be popped. */
1242 int yylen = 0;
1243
1244 YYDPRINTF ((stderr, "Starting parse\n"));
1245
1246 yychar = YYEMPTY; /* Cause a token to be read. */
1247
1248 goto yysetstate;
1249
1250
1251 /*------------------------------------------------------------.
1252 | yynewstate -- push a new state, which is found in yystate. |
1253 `------------------------------------------------------------*/
1254 yynewstate:
1255 /* In all cases, when you get here, the value and location stacks
1256 have just been pushed. So pushing a state here evens the stacks. */
1257 yyssp++;
1258
1259
1260 /*--------------------------------------------------------------------.
1261 | yysetstate -- set current state (the top of the stack) to yystate. |
1262 `--------------------------------------------------------------------*/
1263 yysetstate:
1264 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1265 YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
1266 YY_IGNORE_USELESS_CAST_BEGIN
1267 *yyssp = YY_CAST (yy_state_t, yystate);
1268 YY_IGNORE_USELESS_CAST_END
1269 YY_STACK_PRINT (yyss, yyssp);
1270
1271 if (yyss + yystacksize - 1 <= yyssp)
1272 #if !defined yyoverflow && !defined YYSTACK_RELOCATE
1273 YYNOMEM;
1274 #else
1275 {
1276 /* Get the current used size of the three stacks, in elements. */
1277 YYPTRDIFF_T yysize = yyssp - yyss + 1;
1278
1279 # if defined yyoverflow
1280 {
1281 /* Give user a chance to reallocate the stack. Use copies of
1282 these so that the &'s don't force the real ones into
1283 memory. */
1284 yy_state_t *yyss1 = yyss;
1285 YYSTYPE *yyvs1 = yyvs;
1286
1287 /* Each stack pointer address is followed by the size of the
1288 data in use in that stack, in bytes. This used to be a
1289 conditional around just the two extra args, but that might
1290 be undefined if yyoverflow is a macro. */
1291 yyoverflow (YY_("memory exhausted"),
1292 &yyss1, yysize * YYSIZEOF (*yyssp),
1293 &yyvs1, yysize * YYSIZEOF (*yyvsp),
1294 &yystacksize);
1295 yyss = yyss1;
1296 yyvs = yyvs1;
1297 }
1298 # else /* defined YYSTACK_RELOCATE */
1299 /* Extend the stack our own way. */
1300 if (YYMAXDEPTH <= yystacksize)
1301 YYNOMEM;
1302 yystacksize *= 2;
1303 if (YYMAXDEPTH < yystacksize)
1304 yystacksize = YYMAXDEPTH;
1305
1306 {
1307 yy_state_t *yyss1 = yyss;
1308 union yyalloc *yyptr =
1309 YY_CAST (union yyalloc *,
1310 YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
1311 if (! yyptr)
1312 YYNOMEM;
1313 YYSTACK_RELOCATE (yyss_alloc, yyss);
1314 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1315 # undef YYSTACK_RELOCATE
1316 if (yyss1 != yyssa)
1317 YYSTACK_FREE (yyss1);
1318 }
1319 # endif
1320
1321 yyssp = yyss + yysize - 1;
1322 yyvsp = yyvs + yysize - 1;
1323
1324 YY_IGNORE_USELESS_CAST_BEGIN
1325 YYDPRINTF ((stderr, "Stack size increased to %ld\n",
1326 YY_CAST (long, yystacksize)));
1327 YY_IGNORE_USELESS_CAST_END
1328
1329 if (yyss + yystacksize - 1 <= yyssp)
1330 YYABORT;
1331 }
1332 #endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
1333
1334
1335 if (yystate == YYFINAL)
1336 YYACCEPT;
1337
1338 goto yybackup;
1339
1340
1341 /*-----------.
1342 | yybackup. |
1343 `-----------*/
1344 yybackup:
1345 /* Do appropriate processing given the current state. Read a
1346 lookahead token if we need one and don't already have one. */
1347
1348 /* First try to decide what to do without reference to lookahead token. */
1349 yyn = yypact[yystate];
1350 if (yypact_value_is_default (yyn))
1351 goto yydefault;
1352
1353 /* Not known => get a lookahead token if don't already have one. */
1354
1355 /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */
1356 if (yychar == YYEMPTY)
1357 {
1358 YYDPRINTF ((stderr, "Reading a token\n"));
1359 yychar = yylex ();
1360 }
1361
1362 if (yychar <= YYEOF)
1363 {
1364 yychar = YYEOF;
1365 yytoken = YYSYMBOL_YYEOF;
1366 YYDPRINTF ((stderr, "Now at end of input.\n"));
1367 }
1368 else if (yychar == YYerror)
1369 {
1370 /* The scanner already issued an error message, process directly
1371 to error recovery. But do not keep the error token as
1372 lookahead, it is too special and may lead us to an endless
1373 loop in error recovery. */
1374 yychar = YYUNDEF;
1375 yytoken = YYSYMBOL_YYerror;
1376 goto yyerrlab1;
1377 }
1378 else
1379 {
1380 yytoken = YYTRANSLATE (yychar);
1381 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1382 }
1383
1384 /* If the proper action on seeing token YYTOKEN is to reduce or to
1385 detect an error, take that action. */
1386 yyn += yytoken;
1387 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1388 goto yydefault;
1389 yyn = yytable[yyn];
1390 if (yyn <= 0)
1391 {
1392 if (yytable_value_is_error (yyn))
1393 goto yyerrlab;
1394 yyn = -yyn;
1395 goto yyreduce;
1396 }
1397
1398 /* Count tokens shifted since error; after three, turn off error
1399 status. */
1400 if (yyerrstatus)
1401 yyerrstatus--;
1402
1403 /* Shift the lookahead token. */
1404 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1405 yystate = yyn;
1406 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1407 *++yyvsp = yylval;
1408 YY_IGNORE_MAYBE_UNINITIALIZED_END
1409
1410 /* Discard the shifted token. */
1411 yychar = YYEMPTY;
1412 goto yynewstate;
1413
1414
1415 /*-----------------------------------------------------------.
1416 | yydefault -- do the default action for the current state. |
1417 `-----------------------------------------------------------*/
1418 yydefault:
1419 yyn = yydefact[yystate];
1420 if (yyn == 0)
1421 goto yyerrlab;
1422 goto yyreduce;
1423
1424
1425 /*-----------------------------.
1426 | yyreduce -- do a reduction. |
1427 `-----------------------------*/
1428 yyreduce:
1429 /* yyn is the number of a rule to reduce with. */
1430 yylen = yyr2[yyn];
1431
1432 /* If YYLEN is nonzero, implement the default value of the action:
1433 '$$ = $1'.
1434
1435 Otherwise, the following line sets YYVAL to garbage.
1436 This behavior is undocumented and Bison
1437 users should not rely upon it. Assigning to YYVAL
1438 unconditionally makes the parser a bit smaller, and it avoids a
1439 GCC warning that YYVAL may be used uninitialized. */
1440 yyval = yyvsp[1-yylen];
1441
1442
1443 YY_REDUCE_PRINT (yyn);
1444 switch (yyn)
1445 {
1446 case 5: /* entry: pnum regtype name value NL */
1447 #line 309 "./itbl-parse.y"
1448 {
1449 DBG (("line %d: entry pnum=%d type=%d name=%s value=x%x\n",
1450 insntbl_line, (yyvsp[-4].num), (yyvsp[-3].num), (yyvsp[-2].str), (yyvsp[-1].val)));
1451 itbl_add_reg ((yyvsp[-4].num), (yyvsp[-3].num), (yyvsp[-2].str), (yyvsp[-1].val));
1452 }
1453 #line 1454 "itbl-parse.c"
1454 break;
1455
1456 case 6: /* $@1: %empty */
1457 #line 315 "./itbl-parse.y"
1458 {
1459 DBG (("line %d: entry pnum=%d type=INSN name=%s value=x%x",
1460 insntbl_line, (yyvsp[-5].num), (yyvsp[-3].str), (yyvsp[-2].val)));
1461 DBG ((" sbit=%d ebit=%d flags=0x%x\n", sbit, ebit, (yyvsp[0].val)));
1462 insn=itbl_add_insn ((yyvsp[-5].num), (yyvsp[-3].str), (yyvsp[-2].val), sbit, ebit, (yyvsp[0].val));
1463 }
1464 #line 1465 "itbl-parse.c"
1465 break;
1466
1467 case 7: /* entry: pnum INSN name value range flags $@1 fieldspecs NL */
1468 #line 322 "./itbl-parse.y"
1469 {}
1470 #line 1471 "itbl-parse.c"
1471 break;
1472
1473 case 13: /* ftype: regtype */
1474 #line 335 "./itbl-parse.y"
1475 {
1476 DBGL2 (("ftype\n"));
1477 (yyval.num) = (yyvsp[0].num);
1478 }
1479 #line 1480 "itbl-parse.c"
1480 break;
1481
1482 case 14: /* ftype: ADDR */
1483 #line 340 "./itbl-parse.y"
1484 {
1485 DBGL2 (("addr\n"));
1486 (yyval.num) = ADDR;
1487 }
1488 #line 1489 "itbl-parse.c"
1489 break;
1490
1491 case 15: /* ftype: IMMED */
1492 #line 345 "./itbl-parse.y"
1493 {
1494 DBGL2 (("immed\n"));
1495 (yyval.num) = IMMED;
1496 }
1497 #line 1498 "itbl-parse.c"
1498 break;
1499
1500 case 16: /* fieldspec: ftype range flags */
1501 #line 353 "./itbl-parse.y"
1502 {
1503 DBG (("line %d: field type=%d sbit=%d ebit=%d, flags=0x%x\n",
1504 insntbl_line, (yyvsp[-2].num), sbit, ebit, (yyvsp[0].val)));
1505 itbl_add_operand (insn, (yyvsp[-2].num), sbit, ebit, (yyvsp[0].val));
1506 }
1507 #line 1508 "itbl-parse.c"
1508 break;
1509
1510 case 17: /* flagexpr: NUM '|' flagexpr */
1511 #line 362 "./itbl-parse.y"
1512 {
1513 (yyval.val) = (yyvsp[-2].num) | (yyvsp[0].val);
1514 }
1515 #line 1516 "itbl-parse.c"
1516 break;
1517
1518 case 18: /* flagexpr: '[' flagexpr ']' */
1519 #line 366 "./itbl-parse.y"
1520 {
1521 (yyval.val) = (yyvsp[-1].val);
1522 }
1523 #line 1524 "itbl-parse.c"
1524 break;
1525
1526 case 19: /* flagexpr: NUM */
1527 #line 370 "./itbl-parse.y"
1528 {
1529 (yyval.val) = (yyvsp[0].num);
1530 }
1531 #line 1532 "itbl-parse.c"
1532 break;
1533
1534 case 20: /* flags: '*' flagexpr */
1535 #line 377 "./itbl-parse.y"
1536 {
1537 DBGL2 (("flags=%d\n", (yyvsp[0].val)));
1538 (yyval.val) = (yyvsp[0].val);
1539 }
1540 #line 1541 "itbl-parse.c"
1541 break;
1542
1543 case 21: /* flags: %empty */
1544 #line 382 "./itbl-parse.y"
1545 {
1546 (yyval.val) = 0;
1547 }
1548 #line 1549 "itbl-parse.c"
1549 break;
1550
1551 case 22: /* range: ':' NUM '-' NUM */
1552 #line 389 "./itbl-parse.y"
1553 {
1554 DBGL2 (("range %d %d\n", (yyvsp[-2].num), (yyvsp[0].num)));
1555 sbit = (yyvsp[-2].num);
1556 ebit = (yyvsp[0].num);
1557 }
1558 #line 1559 "itbl-parse.c"
1559 break;
1560
1561 case 23: /* range: %empty */
1562 #line 395 "./itbl-parse.y"
1563 {
1564 sbit = 31;
1565 ebit = 0;
1566 }
1567 #line 1568 "itbl-parse.c"
1568 break;
1569
1570 case 24: /* pnum: PNUM */
1571 #line 403 "./itbl-parse.y"
1572 {
1573 DBGL2 (("pnum=%d\n",(yyvsp[0].num)));
1574 (yyval.num) = (yyvsp[0].num);
1575 }
1576 #line 1577 "itbl-parse.c"
1577 break;
1578
1579 case 25: /* regtype: DREG */
1580 #line 411 "./itbl-parse.y"
1581 {
1582 DBGL2 (("dreg\n"));
1583 (yyval.num) = DREG;
1584 }
1585 #line 1586 "itbl-parse.c"
1586 break;
1587
1588 case 26: /* regtype: CREG */
1589 #line 416 "./itbl-parse.y"
1590 {
1591 DBGL2 (("creg\n"));
1592 (yyval.num) = CREG;
1593 }
1594 #line 1595 "itbl-parse.c"
1595 break;
1596
1597 case 27: /* regtype: GREG */
1598 #line 421 "./itbl-parse.y"
1599 {
1600 DBGL2 (("greg\n"));
1601 (yyval.num) = GREG;
1602 }
1603 #line 1604 "itbl-parse.c"
1604 break;
1605
1606 case 28: /* name: ID */
1607 #line 429 "./itbl-parse.y"
1608 {
1609 DBGL2 (("name=%s\n",(yyvsp[0].str)));
1610 (yyval.str) = (yyvsp[0].str);
1611 }
1612 #line 1613 "itbl-parse.c"
1613 break;
1614
1615 case 29: /* value: NUM */
1616 #line 445 "./itbl-parse.y"
1617 {
1618 DBGL2 (("val=x%x\n",(yyvsp[0].num)));
1619 (yyval.val) = (yyvsp[0].num);
1620 }
1621 #line 1622 "itbl-parse.c"
1622 break;
1623
1624
1625 #line 1626 "itbl-parse.c"
1626
1627 default: break;
1628 }
1629 /* User semantic actions sometimes alter yychar, and that requires
1630 that yytoken be updated with the new translation. We take the
1631 approach of translating immediately before every use of yytoken.
1632 One alternative is translating here after every semantic action,
1633 but that translation would be missed if the semantic action invokes
1634 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
1635 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
1636 incorrect destructor might then be invoked immediately. In the
1637 case of YYERROR or YYBACKUP, subsequent parser actions might lead
1638 to an incorrect destructor call or verbose syntax error message
1639 before the lookahead is translated. */
1640 YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc);
1641
1642 YYPOPSTACK (yylen);
1643 yylen = 0;
1644
1645 *++yyvsp = yyval;
1646
1647 /* Now 'shift' the result of the reduction. Determine what state
1648 that goes to, based on the state we popped back to and the rule
1649 number reduced by. */
1650 {
1651 const int yylhs = yyr1[yyn] - YYNTOKENS;
1652 const int yyi = yypgoto[yylhs] + *yyssp;
1653 yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
1654 ? yytable[yyi]
1655 : yydefgoto[yylhs]);
1656 }
1657
1658 goto yynewstate;
1659
1660
1661 /*--------------------------------------.
1662 | yyerrlab -- here on detecting error. |
1663 `--------------------------------------*/
1664 yyerrlab:
1665 /* Make sure we have latest lookahead translation. See comments at
1666 user semantic actions for why this is necessary. */
1667 yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar);
1668 /* If not already recovering from an error, report this error. */
1669 if (!yyerrstatus)
1670 {
1671 ++yynerrs;
1672 yyerror (YY_("syntax error"));
1673 }
1674
1675 if (yyerrstatus == 3)
1676 {
1677 /* If just tried and failed to reuse lookahead token after an
1678 error, discard it. */
1679
1680 if (yychar <= YYEOF)
1681 {
1682 /* Return failure if at end of input. */
1683 if (yychar == YYEOF)
1684 YYABORT;
1685 }
1686 else
1687 {
1688 yydestruct ("Error: discarding",
1689 yytoken, &yylval);
1690 yychar = YYEMPTY;
1691 }
1692 }
1693
1694 /* Else will try to reuse lookahead token after shifting the error
1695 token. */
1696 goto yyerrlab1;
1697
1698
1699 /*---------------------------------------------------.
1700 | yyerrorlab -- error raised explicitly by YYERROR. |
1701 `---------------------------------------------------*/
1702 yyerrorlab:
1703 /* Pacify compilers when the user code never invokes YYERROR and the
1704 label yyerrorlab therefore never appears in user code. */
1705 if (0)
1706 YYERROR;
1707 ++yynerrs;
1708
1709 /* Do not reclaim the symbols of the rule whose action triggered
1710 this YYERROR. */
1711 YYPOPSTACK (yylen);
1712 yylen = 0;
1713 YY_STACK_PRINT (yyss, yyssp);
1714 yystate = *yyssp;
1715 goto yyerrlab1;
1716
1717
1718 /*-------------------------------------------------------------.
1719 | yyerrlab1 -- common code for both syntax error and YYERROR. |
1720 `-------------------------------------------------------------*/
1721 yyerrlab1:
1722 yyerrstatus = 3; /* Each real token shifted decrements this. */
1723
1724 /* Pop stack until we find a state that shifts the error token. */
1725 for (;;)
1726 {
1727 yyn = yypact[yystate];
1728 if (!yypact_value_is_default (yyn))
1729 {
1730 yyn += YYSYMBOL_YYerror;
1731 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror)
1732 {
1733 yyn = yytable[yyn];
1734 if (0 < yyn)
1735 break;
1736 }
1737 }
1738
1739 /* Pop the current state because it cannot handle the error token. */
1740 if (yyssp == yyss)
1741 YYABORT;
1742
1743
1744 yydestruct ("Error: popping",
1745 YY_ACCESSING_SYMBOL (yystate), yyvsp);
1746 YYPOPSTACK (1);
1747 yystate = *yyssp;
1748 YY_STACK_PRINT (yyss, yyssp);
1749 }
1750
1751 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1752 *++yyvsp = yylval;
1753 YY_IGNORE_MAYBE_UNINITIALIZED_END
1754
1755
1756 /* Shift the error token. */
1757 YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp);
1758
1759 yystate = yyn;
1760 goto yynewstate;
1761
1762
1763 /*-------------------------------------.
1764 | yyacceptlab -- YYACCEPT comes here. |
1765 `-------------------------------------*/
1766 yyacceptlab:
1767 yyresult = 0;
1768 goto yyreturnlab;
1769
1770
1771 /*-----------------------------------.
1772 | yyabortlab -- YYABORT comes here. |
1773 `-----------------------------------*/
1774 yyabortlab:
1775 yyresult = 1;
1776 goto yyreturnlab;
1777
1778
1779 /*-----------------------------------------------------------.
1780 | yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here. |
1781 `-----------------------------------------------------------*/
1782 yyexhaustedlab:
1783 yyerror (YY_("memory exhausted"));
1784 yyresult = 2;
1785 goto yyreturnlab;
1786
1787
1788 /*----------------------------------------------------------.
1789 | yyreturnlab -- parsing is finished, clean up and return. |
1790 `----------------------------------------------------------*/
1791 yyreturnlab:
1792 if (yychar != YYEMPTY)
1793 {
1794 /* Make sure we have latest lookahead translation. See comments at
1795 user semantic actions for why this is necessary. */
1796 yytoken = YYTRANSLATE (yychar);
1797 yydestruct ("Cleanup: discarding lookahead",
1798 yytoken, &yylval);
1799 }
1800 /* Do not reclaim the symbols of the rule whose action triggered
1801 this YYABORT or YYACCEPT. */
1802 YYPOPSTACK (yylen);
1803 YY_STACK_PRINT (yyss, yyssp);
1804 while (yyssp != yyss)
1805 {
1806 yydestruct ("Cleanup: popping",
1807 YY_ACCESSING_SYMBOL (+*yyssp), yyvsp);
1808 YYPOPSTACK (1);
1809 }
1810 #ifndef yyoverflow
1811 if (yyss != yyssa)
1812 YYSTACK_FREE (yyss);
1813 #endif
1814
1815 return yyresult;
1816 }
1817
1818 #line 450 "./itbl-parse.y"
1819
1820
1821 static void
yyerror(const char * msg)1822 yyerror (const char *msg)
1823 {
1824 printf ("line %d: %s\n", insntbl_line, msg);
1825 }
1826