Debian Codegraph @

src/fcml_gas_parser_def.c

raw
1 /* A Bison parser, made by GNU Bison 3.5.1. */
2
3 /* Bison implementation for Yacc-like parsers in C
4
5 Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 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.1"
52
53 /* Skeleton name. */
54 #define YYSKELETON_NAME "yacc.c"
55
56 /* Pure parsers. */
57 #define YYPURE 1
58
59 /* Push parsers. */
60 #define YYPUSH 0
61
62 /* Pull parsers. */
63 #define YYPULL 1
64
65 /* Substitute the type names. */
66 #define YYSTYPE GAS_STYPE
67 #define YYLTYPE GAS_LTYPE
68 /* Substitute the variable and function names. */
69 #define yyparse gas_parse
70 #define yylex gas_lex
71 #define yyerror gas_error
72 #define yydebug gas_debug
73 #define yynerrs gas_nerrs
74
75 /* First part of user prologue. */
76 #line 32 "fcml_gas_parser_def.y"
77
78 #include <stdio.h>
79 #include "fcml_parser_utils.h"
80
81 /* Macro responsible for handling 'Out of memory' errors. */
82 #define HANDLE_ERRORS(x) if( !x ) { yyerror(&yylloc, pd, \
83 "Out of memory."); YYERROR; }
84
85 /* Macro responsible for adding error messages to result. */
86 #define ADD_ERROR_MSG(x) { yyerror(&yylloc, pd, x); }
87
88 #line 89 "fcml_gas_parser_def.c"
89
90 # ifndef YY_CAST
91 # ifdef __cplusplus
92 # define YY_CAST(Type, Val) static_cast<Type> (Val)
93 # define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
94 # else
95 # define YY_CAST(Type, Val) ((Type) (Val))
96 # define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
97 # endif
98 # endif
99 # ifndef YY_NULLPTR
100 # if defined __cplusplus
101 # if 201103L <= __cplusplus
102 # define YY_NULLPTR nullptr
103 # else
104 # define YY_NULLPTR 0
105 # endif
106 # else
107 # define YY_NULLPTR ((void*)0)
108 # endif
109 # endif
110
111 /* Enabling verbose error messages. */
112 #ifdef YYERROR_VERBOSE
113 # undef YYERROR_VERBOSE
114 # define YYERROR_VERBOSE 1
115 #else
116 # define YYERROR_VERBOSE 0
117 #endif
118
119 /* Use api.header.include to #include this header
120 instead of duplicating it here. */
121 #ifndef YY_GAS_FCML_GAS_PARSER_DEF_H_INCLUDED
122 # define YY_GAS_FCML_GAS_PARSER_DEF_H_INCLUDED
123 /* Debug traces. */
124 #ifndef GAS_DEBUG
125 # if defined YYDEBUG
126 #if YYDEBUG
127 # define GAS_DEBUG 1
128 # else
129 # define GAS_DEBUG 0
130 # endif
131 # else /* ! defined YYDEBUG */
132 # define GAS_DEBUG 0
133 # endif /* ! defined YYDEBUG */
134 #endif /* ! defined GAS_DEBUG */
135 #if GAS_DEBUG
136 extern int gas_debug;
137 #endif
138
139 /* Token type. */
140 #ifndef GAS_TOKENTYPE
141 # define GAS_TOKENTYPE
142 enum gas_tokentype
143 {
144 FCML_TK_UNEXPECTED = 258,
145 FCML_TK_REG_GPR = 259,
146 FCML_TK_REG_SIMD = 260,
147 FCML_TK_REG_FPU = 261,
148 FCML_TK_REG_SEG = 262,
149 FCML_TK_REG_OPMASK = 263,
150 FCML_TK_REG_CR = 264,
151 FCML_TK_REG_DR = 265,
152 FCML_TK_REG_RIP = 266,
153 FCML_TK_DECORATOR_BCAST = 267,
154 FCML_TK_DECORATOR_ER = 268,
155 FCML_TK_DECORATOR_Z = 269,
156 FCML_TK_DECORATOR_SAE = 270,
157 FCML_TK_OPMASK_REG_DECORATOR = 271,
158 FCML_TK_INTEGER = 272,
159 FCML_TK_SYMBOL = 273,
160 FCML_TK_PREFIX = 274,
161 FCML_TK_PO_BYTE = 275,
162 FCML_OP_UMINUS = 276
163 };
164 #endif
165 /* Tokens. */
166 #define FCML_TK_UNEXPECTED 258
167 #define FCML_TK_REG_GPR 259
168 #define FCML_TK_REG_SIMD 260
169 #define FCML_TK_REG_FPU 261
170 #define FCML_TK_REG_SEG 262
171 #define FCML_TK_REG_OPMASK 263
172 #define FCML_TK_REG_CR 264
173 #define FCML_TK_REG_DR 265
174 #define FCML_TK_REG_RIP 266
175 #define FCML_TK_DECORATOR_BCAST 267
176 #define FCML_TK_DECORATOR_ER 268
177 #define FCML_TK_DECORATOR_Z 269
178 #define FCML_TK_DECORATOR_SAE 270
179 #define FCML_TK_OPMASK_REG_DECORATOR 271
180 #define FCML_TK_INTEGER 272
181 #define FCML_TK_SYMBOL 273
182 #define FCML_TK_PREFIX 274
183 #define FCML_TK_PO_BYTE 275
184 #define FCML_OP_UMINUS 276
185
186 /* Value type. */
187 #if ! defined GAS_STYPE && ! defined GAS_STYPE_IS_DECLARED
188 union GAS_STYPE
189 {
190 #line 117 "fcml_gas_parser_def.y"
191
192 /*Complex values.*/
193 fcml_st_ast_val_integer integer_value;
194 fcml_st_register reg_value;
195 fcml_st_ast_node *ast;
196 struct {
197 fcml_string text;
198 int length;
199 } symbol;
200 fcml_hints hints;
201 fcml_prefixes prefixes;
202 fcml_bool bool_value;
203 fcml_int int_value;
204
205 #line 206 "fcml_gas_parser_def.c"
206
207 };
208 typedef union GAS_STYPE GAS_STYPE;
209 # define GAS_STYPE_IS_TRIVIAL 1
210 # define GAS_STYPE_IS_DECLARED 1
211 #endif
212
213 /* Location type. */
214 #if ! defined GAS_LTYPE && ! defined GAS_LTYPE_IS_DECLARED
215 typedef struct GAS_LTYPE GAS_LTYPE;
216 struct GAS_LTYPE
217 {
218 int first_line;
219 int first_column;
220 int last_line;
221 int last_column;
222 };
223 # define GAS_LTYPE_IS_DECLARED 1
224 # define GAS_LTYPE_IS_TRIVIAL 1
225 #endif
226
227
228
229 int gas_parse (struct fcml_st_parser_data *pd);
230 /* "%code provides" blocks. */
231 #line 27 "fcml_gas_parser_def.y"
232
233 #define YYSTYPE GAS_STYPE
234 #define YYLTYPE GAS_LTYPE
235
236 #line 237 "fcml_gas_parser_def.c"
237
238 #endif /* !YY_GAS_FCML_GAS_PARSER_DEF_H_INCLUDED */
239
240 /* Second part of user prologue. */
241 #line 132 "fcml_gas_parser_def.y"
242
243 #include "fcml_gas_lexer.h"
244 #define yyscanner ((yyscan_t)pd->scannerInfo)
245 void gas_error(YYLTYPE *yyloc, struct fcml_st_parser_data *pd,
246 const char *error );
247
248 #line 249 "fcml_gas_parser_def.c"
249
250
251 #ifdef short
252 # undef short
253 #endif
254
255 /* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
256 <limits.h> and (if available) <stdint.h> are included
257 so that the code can choose integer types of a good width. */
258
259 #ifndef __PTRDIFF_MAX__
260 # include <limits.h> /* INFRINGES ON USER NAME SPACE */
261 # if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
262 # include <stdint.h> /* INFRINGES ON USER NAME SPACE */
263 # define YY_STDINT_H
264 # endif
265 #endif
266
267 /* Narrow types that promote to a signed type and that can represent a
268 signed or unsigned integer of at least N bits. In tables they can
269 save space and decrease cache pressure. Promoting to a signed type
270 helps avoid bugs in integer arithmetic. */
271
272 #ifdef __INT_LEAST8_MAX__
273 typedef __INT_LEAST8_TYPE__ yytype_int8;
274 #elif defined YY_STDINT_H
275 typedef int_least8_t yytype_int8;
276 #else
277 typedef signed char yytype_int8;
278 #endif
279
280 #ifdef __INT_LEAST16_MAX__
281 typedef __INT_LEAST16_TYPE__ yytype_int16;
282 #elif defined YY_STDINT_H
283 typedef int_least16_t yytype_int16;
284 #else
285 typedef short yytype_int16;
286 #endif
287
288 #if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
289 typedef __UINT_LEAST8_TYPE__ yytype_uint8;
290 #elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
291 && UINT_LEAST8_MAX <= INT_MAX)
292 typedef uint_least8_t yytype_uint8;
293 #elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
294 typedef unsigned char yytype_uint8;
295 #else
296 typedef short yytype_uint8;
297 #endif
298
299 #if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
300 typedef __UINT_LEAST16_TYPE__ yytype_uint16;
301 #elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
302 && UINT_LEAST16_MAX <= INT_MAX)
303 typedef uint_least16_t yytype_uint16;
304 #elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
305 typedef unsigned short yytype_uint16;
306 #else
307 typedef int yytype_uint16;
308 #endif
309
310 #ifndef YYPTRDIFF_T
311 # if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
312 # define YYPTRDIFF_T __PTRDIFF_TYPE__
313 # define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
314 # elif defined PTRDIFF_MAX
315 # ifndef ptrdiff_t
316 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
317 # endif
318 # define YYPTRDIFF_T ptrdiff_t
319 # define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
320 # else
321 # define YYPTRDIFF_T long
322 # define YYPTRDIFF_MAXIMUM LONG_MAX
323 # endif
324 #endif
325
326 #ifndef YYSIZE_T
327 # ifdef __SIZE_TYPE__
328 # define YYSIZE_T __SIZE_TYPE__
329 # elif defined size_t
330 # define YYSIZE_T size_t
331 # elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
332 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
333 # define YYSIZE_T size_t
334 # else
335 # define YYSIZE_T unsigned
336 # endif
337 #endif
338
339 #define YYSIZE_MAXIMUM \
340 YY_CAST (YYPTRDIFF_T, \
341 (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \
342 ? YYPTRDIFF_MAXIMUM \
343 : YY_CAST (YYSIZE_T, -1)))
344
345 #define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
346
347 /* Stored state numbers (used for stacks). */
348 typedef yytype_int8 yy_state_t;
349
350 /* State numbers in computations. */
351 typedef int yy_state_fast_t;
352
353 #ifndef YY_
354 # if defined YYENABLE_NLS && YYENABLE_NLS
355 # if ENABLE_NLS
356 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
357 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
358 # endif
359 # endif
360 # ifndef YY_
361 # define YY_(Msgid) Msgid
362 # endif
363 #endif
364
365 #ifndef YY_ATTRIBUTE_PURE
366 # if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
367 # define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
368 # else
369 # define YY_ATTRIBUTE_PURE
370 # endif
371 #endif
372
373 #ifndef YY_ATTRIBUTE_UNUSED
374 # if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
375 # define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
376 # else
377 # define YY_ATTRIBUTE_UNUSED
378 # endif
379 #endif
380
381 /* Suppress unused-variable warnings by "using" E. */
382 #if ! defined lint || defined __GNUC__
383 # define YYUSE(E) ((void) (E))
384 #else
385 # define YYUSE(E) /* empty */
386 #endif
387
388 #if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
389 /* Suppress an incorrect diagnostic about yylval being uninitialized. */
390 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
391 _Pragma ("GCC diagnostic push") \
392 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
393 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
394 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
395 _Pragma ("GCC diagnostic pop")
396 #else
397 # define YY_INITIAL_VALUE(Value) Value
398 #endif
399 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
400 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
401 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
402 #endif
403 #ifndef YY_INITIAL_VALUE
404 # define YY_INITIAL_VALUE(Value) /* Nothing. */
405 #endif
406
407 #if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
408 # define YY_IGNORE_USELESS_CAST_BEGIN \
409 _Pragma ("GCC diagnostic push") \
410 _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
411 # define YY_IGNORE_USELESS_CAST_END \
412 _Pragma ("GCC diagnostic pop")
413 #endif
414 #ifndef YY_IGNORE_USELESS_CAST_BEGIN
415 # define YY_IGNORE_USELESS_CAST_BEGIN
416 # define YY_IGNORE_USELESS_CAST_END
417 #endif
418
419
420 #define YY_ASSERT(E) ((void) (0 && (E)))
421
422 #if ! defined yyoverflow || YYERROR_VERBOSE
423
424 /* The parser invokes alloca or malloc; define the necessary symbols. */
425
426 # ifdef YYSTACK_USE_ALLOCA
427 # if YYSTACK_USE_ALLOCA
428 # ifdef __GNUC__
429 # define YYSTACK_ALLOC __builtin_alloca
430 # elif defined __BUILTIN_VA_ARG_INCR
431 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
432 # elif defined _AIX
433 # define YYSTACK_ALLOC __alloca
434 # elif defined _MSC_VER
435 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
436 # define alloca _alloca
437 # else
438 # define YYSTACK_ALLOC alloca
439 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
440 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
441 /* Use EXIT_SUCCESS as a witness for stdlib.h. */
442 # ifndef EXIT_SUCCESS
443 # define EXIT_SUCCESS 0
444 # endif
445 # endif
446 # endif
447 # endif
448 # endif
449
450 # ifdef YYSTACK_ALLOC
451 /* Pacify GCC's 'empty if-body' warning. */
452 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
453 # ifndef YYSTACK_ALLOC_MAXIMUM
454 /* The OS might guarantee only one guard page at the bottom of the stack,
455 and a page size can be as small as 4096 bytes. So we cannot safely
456 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
457 to allow for a few compiler-allocated temporary stack slots. */
458 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
459 # endif
460 # else
461 # define YYSTACK_ALLOC YYMALLOC
462 # define YYSTACK_FREE YYFREE
463 # ifndef YYSTACK_ALLOC_MAXIMUM
464 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
465 # endif
466 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
467 && ! ((defined YYMALLOC || defined malloc) \
468 && (defined YYFREE || defined free)))
469 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
470 # ifndef EXIT_SUCCESS
471 # define EXIT_SUCCESS 0
472 # endif
473 # endif
474 # ifndef YYMALLOC
475 # define YYMALLOC malloc
476 # if ! defined malloc && ! defined EXIT_SUCCESS
477 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
478 # endif
479 # endif
480 # ifndef YYFREE
481 # define YYFREE free
482 # if ! defined free && ! defined EXIT_SUCCESS
483 void free (void *); /* INFRINGES ON USER NAME SPACE */
484 # endif
485 # endif
486 # endif
487 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
488
489
490 #if (! defined yyoverflow \
491 && (! defined __cplusplus \
492 || (defined GAS_LTYPE_IS_TRIVIAL && GAS_LTYPE_IS_TRIVIAL \
493 && defined GAS_STYPE_IS_TRIVIAL && GAS_STYPE_IS_TRIVIAL)))
494
495 /* A type that is properly aligned for any stack member. */
496 union yyalloc
497 {
498 yy_state_t yyss_alloc;
499 YYSTYPE yyvs_alloc;
500 YYLTYPE yyls_alloc;
501 };
502
503 /* The size of the maximum gap between one aligned stack and the next. */
504 # define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
505
506 /* The size of an array large to enough to hold all stacks, each with
507 N elements. */
508 # define YYSTACK_BYTES(N) \
509 ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE) \
510 + YYSIZEOF (YYLTYPE)) \
511 + 2 * YYSTACK_GAP_MAXIMUM)
512
513 # define YYCOPY_NEEDED 1
514
515 /* Relocate STACK from its old location to the new one. The
516 local variables YYSIZE and YYSTACKSIZE give the old and new number of
517 elements in the stack, and YYPTR gives the new location of the
518 stack. Advance YYPTR to a properly aligned location for the next
519 stack. */
520 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
521 do \
522 { \
523 YYPTRDIFF_T yynewbytes; \
524 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
525 Stack = &yyptr->Stack_alloc; \
526 yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
527 yyptr += yynewbytes / YYSIZEOF (*yyptr); \
528 } \
529 while (0)
530
531 #endif
532
533 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
534 /* Copy COUNT objects from SRC to DST. The source and destination do
535 not overlap. */
536 # ifndef YYCOPY
537 # if defined __GNUC__ && 1 < __GNUC__
538 # define YYCOPY(Dst, Src, Count) \
539 __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
540 # else
541 # define YYCOPY(Dst, Src, Count) \
542 do \
543 { \
544 YYPTRDIFF_T yyi; \
545 for (yyi = 0; yyi < (Count); yyi++) \
546 (Dst)[yyi] = (Src)[yyi]; \
547 } \
548 while (0)
549 # endif
550 # endif
551 #endif /* !YYCOPY_NEEDED */
552
553 /* YYFINAL -- State number of the termination state. */
554 #define YYFINAL 15
555 /* YYLAST -- Last index in YYTABLE. */
556 #define YYLAST 124
557
558 /* YYNTOKENS -- Number of terminals. */
559 #define YYNTOKENS 31
560 /* YYNNTS -- Number of nonterminals. */
561 #define YYNNTS 14
562 /* YYNRULES -- Number of rules. */
563 #define YYNRULES 57
564 /* YYNSTATES -- Number of states. */
565 #define YYNSTATES 86
566
567 #define YYUNDEFTOK 2
568 #define YYMAXUTOK 276
569
570
571 /* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
572 as returned by yylex, with out-of-bounds checking. */
573 #define YYTRANSLATE(YYX) \
574 (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
575
576 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
577 as returned by yylex. */
578 static const yytype_int8 yytranslate[] =
579 {
580 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
581 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
582 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
583 2, 2, 2, 2, 2, 2, 28, 2, 2, 2,
584 29, 30, 23, 22, 27, 21, 2, 24, 2, 2,
585 2, 2, 2, 2, 2, 2, 2, 2, 26, 2,
586 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
587 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
588 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
589 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
590 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
591 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
592 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
593 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
594 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
595 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
596 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
597 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
598 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
599 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
600 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
601 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
602 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
603 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
604 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
605 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
606 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
607 15, 16, 17, 18, 19, 20, 25
608 };
609
610 #if GAS_DEBUG
611 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
612 static const yytype_uint8 yyrline[] =
613 {
614 0, 146, 146, 147, 148, 149, 150, 151, 154, 155,
615 156, 157, 160, 161, 164, 167, 168, 171, 172, 173,
616 174, 175, 176, 177, 178, 179, 180, 181, 182, 185,
617 186, 187, 191, 192, 193, 197, 198, 199, 200, 201,
618 202, 205, 209, 210, 211, 212, 213, 214, 215, 216,
619 220, 221, 222, 223, 224, 225, 226, 231
620 };
621 #endif
622
623 #if GAS_DEBUG || YYERROR_VERBOSE || 0
624 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
625 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
626 static const char *const yytname[] =
627 {
628 "$end", "error", "$undefined", "FCML_TK_UNEXPECTED", "FCML_TK_REG_GPR",
629 "FCML_TK_REG_SIMD", "FCML_TK_REG_FPU", "FCML_TK_REG_SEG",
630 "FCML_TK_REG_OPMASK", "FCML_TK_REG_CR", "FCML_TK_REG_DR",
631 "FCML_TK_REG_RIP", "FCML_TK_DECORATOR_BCAST", "FCML_TK_DECORATOR_ER",
632 "FCML_TK_DECORATOR_Z", "FCML_TK_DECORATOR_SAE",
633 "FCML_TK_OPMASK_REG_DECORATOR", "FCML_TK_INTEGER", "FCML_TK_SYMBOL",
634 "FCML_TK_PREFIX", "FCML_TK_PO_BYTE", "'-'", "'+'", "'*'", "'/'",
635 "FCML_OP_UMINUS", "':'", "','", "'$'", "'('", "')'", "$accept", "start",
636 "instruction", "inst_prefixes", "mnemonic", "operand_list", "operand",
637 "effective_address", "effective_address_components",
638 "effective_address_components_without_dis", "segment_selector", "exp",
639 "reg", "pseudo_operation", YY_NULLPTR
640 };
641 #endif
642
643 # ifdef YYPRINT
644 /* YYTOKNUM[NUM] -- (External) token number corresponding to the
645 (internal) symbol number NUM (which must be that of a token). */
646 static const yytype_int16 yytoknum[] =
647 {
648 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
649 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
650 275, 45, 43, 42, 47, 276, 58, 44, 36, 40,
651 41
652 };
653 # endif
654
655 #define YYPACT_NINF (-27)
656
657 #define yypact_value_is_default(Yyn) \
658 ((Yyn) == YYPACT_NINF)
659
660 #define YYTABLE_NINF (-1)
661
662 #define yytable_value_is_error(Yyn) \
663 0
664
665 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
666 STATE-NUM. */
667 static const yytype_int8 yypact[] =
668 {
669 -12, -24, -27, 2, 25, -27, 11, 43, -27, 19,
670 -27, -27, 2, 2, 46, -27, -27, -27, 43, -27,
671 -27, -27, 29, -27, -27, -27, -27, -27, 15, 2,
672 69, 18, -27, -11, -27, -27, 64, 82, 49, -27,
673 -27, -27, 78, 2, 2, 2, 2, 18, -27, 29,
674 76, 46, -27, 59, 108, -6, 43, -27, -27, 77,
675 -27, 7, -27, -27, 80, -27, 60, 60, -27, -27,
676 -27, 27, 108, -27, -27, -27, -27, 75, -27, 32,
677 65, 90, -27, -27, 67, -27
678 };
679
680 /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
681 Performed when YYTABLE does not specify something else to do. Zero
682 means the default is an error. */
683 static const yytype_int8 yydefact[] =
684 {
685 2, 14, 12, 0, 0, 3, 0, 8, 4, 5,
686 42, 47, 0, 0, 57, 1, 14, 13, 10, 50,
687 51, 52, 53, 54, 55, 56, 28, 27, 0, 0,
688 0, 9, 15, 18, 29, 32, 0, 34, 23, 6,
689 7, 48, 0, 0, 0, 0, 0, 11, 41, 0,
690 22, 17, 53, 0, 0, 0, 0, 31, 21, 19,
691 30, 0, 33, 26, 24, 49, 43, 44, 46, 45,
692 35, 0, 0, 36, 16, 20, 25, 0, 38, 0,
693 0, 0, 37, 40, 0, 39
694 };
695
696 /* YYPGOTO[NTERM-NUM]. */
697 static const yytype_int8 yypgoto[] =
698 {
699 -27, -27, 100, -27, 104, 101, 66, 92, 85, 86,
700 -27, -3, -26, 115
701 };
702
703 /* YYDEFGOTO[NTERM-NUM]. */
704 static const yytype_int8 yydefgoto[] =
705 {
706 -1, 4, 5, 6, 7, 31, 32, 33, 34, 35,
707 36, 37, 38, 8
708 };
709
710 /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
711 positive, shift that token. If negative, reduce the rule whose
712 number is the opposite. If YYTABLE_NINF, syntax error. */
713 static const yytype_int8 yytable[] =
714 {
715 14, 57, 9, 58, 55, 59, 1, 2, 3, 41,
716 42, 19, 20, 21, 52, 23, 24, 25, 53, 10,
717 11, 72, 49, 12, 73, 15, 51, 42, 71, 16,
718 17, 13, 10, 11, 54, 55, 12, 16, 2, 3,
719 66, 67, 68, 69, 30, 56, 79, 19, 20, 21,
720 22, 23, 24, 25, 77, 48, 26, 78, 27, 81,
721 10, 11, 82, 63, 12, 64, 28, 43, 44, 45,
722 46, 29, 30, 19, 20, 21, 52, 23, 24, 25,
723 53, 10, 11, 45, 46, 12, 10, 11, 57, 70,
724 12, 75, 80, 30, 76, 83, 54, 85, 13, 43,
725 44, 45, 46, 43, 44, 45, 46, 84, 65, 39,
726 18, 61, 19, 20, 21, 52, 23, 24, 25, 47,
727 50, 60, 74, 62, 40
728 };
729
730 static const yytype_int8 yycheck[] =
731 {
732 3, 12, 26, 14, 30, 16, 18, 19, 20, 12,
733 13, 4, 5, 6, 7, 8, 9, 10, 11, 17,
734 18, 27, 7, 21, 30, 0, 29, 30, 54, 18,
735 19, 29, 17, 18, 27, 61, 21, 18, 19, 20,
736 43, 44, 45, 46, 29, 27, 72, 4, 5, 6,
737 7, 8, 9, 10, 27, 26, 13, 30, 15, 27,
738 17, 18, 30, 14, 21, 16, 23, 21, 22, 23,
739 24, 28, 29, 4, 5, 6, 7, 8, 9, 10,
740 11, 17, 18, 23, 24, 21, 17, 18, 12, 30,
741 21, 14, 17, 29, 14, 30, 27, 30, 29, 21,
742 22, 23, 24, 21, 22, 23, 24, 17, 30, 9,
743 6, 29, 4, 5, 6, 7, 8, 9, 10, 18,
744 28, 36, 56, 37, 9
745 };
746
747 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
748 symbol of state STATE-NUM. */
749 static const yytype_int8 yystos[] =
750 {
751 0, 18, 19, 20, 32, 33, 34, 35, 44, 26,
752 17, 18, 21, 29, 42, 0, 18, 19, 35, 4,
753 5, 6, 7, 8, 9, 10, 13, 15, 23, 28,
754 29, 36, 37, 38, 39, 40, 41, 42, 43, 33,
755 44, 42, 42, 21, 22, 23, 24, 36, 26, 7,
756 38, 42, 7, 11, 27, 43, 27, 12, 14, 16,
757 39, 29, 40, 14, 16, 30, 42, 42, 42, 42,
758 30, 43, 27, 30, 37, 14, 14, 27, 30, 43,
759 17, 27, 30, 30, 17, 30
760 };
761
762 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
763 static const yytype_int8 yyr1[] =
764 {
765 0, 31, 32, 32, 32, 32, 32, 32, 33, 33,
766 33, 33, 34, 34, 35, 36, 36, 37, 37, 37,
767 37, 37, 37, 37, 37, 37, 37, 37, 37, 38,
768 38, 38, 39, 39, 39, 40, 40, 40, 40, 40,
769 40, 41, 42, 42, 42, 42, 42, 42, 42, 42,
770 43, 43, 43, 43, 43, 43, 43, 44
771 };
772
773 /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
774 static const yytype_int8 yyr2[] =
775 {
776 0, 2, 0, 1, 1, 2, 3, 3, 1, 2,
777 2, 3, 1, 2, 1, 1, 3, 2, 1, 2,
778 3, 2, 2, 1, 2, 3, 2, 1, 1, 1,
779 2, 2, 1, 2, 1, 3, 3, 5, 4, 7,
780 6, 2, 1, 3, 3, 3, 3, 1, 2, 3,
781 1, 1, 1, 1, 1, 1, 1, 2
782 };
783
784
785 #define yyerrok (yyerrstatus = 0)
786 #define yyclearin (yychar = YYEMPTY)
787 #define YYEMPTY (-2)
788 #define YYEOF 0
789
790 #define YYACCEPT goto yyacceptlab
791 #define YYABORT goto yyabortlab
792 #define YYERROR goto yyerrorlab
793
794
795 #define YYRECOVERING() (!!yyerrstatus)
796
797 #define YYBACKUP(Token, Value) \
798 do \
799 if (yychar == YYEMPTY) \
800 { \
801 yychar = (Token); \
802 yylval = (Value); \
803 YYPOPSTACK (yylen); \
804 yystate = *yyssp; \
805 goto yybackup; \
806 } \
807 else \
808 { \
809 yyerror (&yylloc, pd, YY_("syntax error: cannot back up")); \
810 YYERROR; \
811 } \
812 while (0)
813
814 /* Error token number */
815 #define YYTERROR 1
816 #define YYERRCODE 256
817
818
819 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
820 If N is 0, then set CURRENT to the empty location which ends
821 the previous symbol: RHS[0] (always defined). */
822
823 #ifndef YYLLOC_DEFAULT
824 # define YYLLOC_DEFAULT(Current, Rhs, N) \
825 do \
826 if (N) \
827 { \
828 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
829 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
830 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
831 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
832 } \
833 else \
834 { \
835 (Current).first_line = (Current).last_line = \
836 YYRHSLOC (Rhs, 0).last_line; \
837 (Current).first_column = (Current).last_column = \
838 YYRHSLOC (Rhs, 0).last_column; \
839 } \
840 while (0)
841 #endif
842
843 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
844
845
846 /* Enable debugging if requested. */
847 #if GAS_DEBUG
848
849 # ifndef YYFPRINTF
850 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
851 # define YYFPRINTF fprintf
852 # endif
853
854 # define YYDPRINTF(Args) \
855 do { \
856 if (yydebug) \
857 YYFPRINTF Args; \
858 } while (0)
859
860
861 /* YY_LOCATION_PRINT -- Print the location on the stream.
862 This macro was not mandated originally: define only if we know
863 we won't break user code: when these are the locations we know. */
864
865 #ifndef YY_LOCATION_PRINT
866 # if defined GAS_LTYPE_IS_TRIVIAL && GAS_LTYPE_IS_TRIVIAL
867
868 /* Print *YYLOCP on YYO. Private, do not rely on its existence. */
869
870 YY_ATTRIBUTE_UNUSED
871 static int
872 yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp)
873 {
874 int res = 0;
875 int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0;
876 if (0 <= yylocp->first_line)
877 {
878 res += YYFPRINTF (yyo, "%d", yylocp->first_line);
879 if (0 <= yylocp->first_column)
880 res += YYFPRINTF (yyo, ".%d", yylocp->first_column);
881 }
882 if (0 <= yylocp->last_line)
883 {
884 if (yylocp->first_line < yylocp->last_line)
885 {
886 res += YYFPRINTF (yyo, "-%d", yylocp->last_line);
887 if (0 <= end_col)
888 res += YYFPRINTF (yyo, ".%d", end_col);
889 }
890 else if (0 <= end_col && yylocp->first_column < end_col)
891 res += YYFPRINTF (yyo, "-%d", end_col);
892 }
893 return res;
894 }
895
896 # define YY_LOCATION_PRINT(File, Loc) \
897 yy_location_print_ (File, &(Loc))
898
899 # else
900 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
901 # endif
902 #endif
903
904
905 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
906 do { \
907 if (yydebug) \
908 { \
909 YYFPRINTF (stderr, "%s ", Title); \
910 yy_symbol_print (stderr, \
911 Type, Value, Location, pd); \
912 YYFPRINTF (stderr, "\n"); \
913 } \
914 } while (0)
915
916
917 /*-----------------------------------.
918 | Print this symbol's value on YYO. |
919 `-----------------------------------*/
920
921 static void
922 yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, struct fcml_st_parser_data *pd)
923 {
924 FILE *yyoutput = yyo;
925 YYUSE (yyoutput);
926 YYUSE (yylocationp);
927 YYUSE (pd);
928 if (!yyvaluep)
929 return;
930 # ifdef YYPRINT
931 if (yytype < YYNTOKENS)
932 YYPRINT (yyo, yytoknum[yytype], *yyvaluep);
933 # endif
934 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
935 switch (yytype)
936 {
937 case 4: /* FCML_TK_REG_GPR */
938 #line 115 "fcml_gas_parser_def.y"
939 { YYFPRINTF(yyoutput, "Type: %s Size: %d Reg: %d x64_exp: %d", fcml_fn_pu_reg_type_to_string( ((*yyvaluep).reg_value).type ), ((*yyvaluep).reg_value).size, ((*yyvaluep).reg_value).reg, ((*yyvaluep).reg_value).x64_exp); }
940 #line 941 "fcml_gas_parser_def.c"
941 break;
942
943 case 5: /* FCML_TK_REG_SIMD */
944 #line 115 "fcml_gas_parser_def.y"
945 { YYFPRINTF(yyoutput, "Type: %s Size: %d Reg: %d x64_exp: %d", fcml_fn_pu_reg_type_to_string( ((*yyvaluep).reg_value).type ), ((*yyvaluep).reg_value).size, ((*yyvaluep).reg_value).reg, ((*yyvaluep).reg_value).x64_exp); }
946 #line 947 "fcml_gas_parser_def.c"
947 break;
948
949 case 6: /* FCML_TK_REG_FPU */
950 #line 115 "fcml_gas_parser_def.y"
951 { YYFPRINTF(yyoutput, "Type: %s Size: %d Reg: %d x64_exp: %d", fcml_fn_pu_reg_type_to_string( ((*yyvaluep).reg_value).type ), ((*yyvaluep).reg_value).size, ((*yyvaluep).reg_value).reg, ((*yyvaluep).reg_value).x64_exp); }
952 #line 953 "fcml_gas_parser_def.c"
953 break;
954
955 case 7: /* FCML_TK_REG_SEG */
956 #line 115 "fcml_gas_parser_def.y"
957 { YYFPRINTF(yyoutput, "Type: %s Size: %d Reg: %d x64_exp: %d", fcml_fn_pu_reg_type_to_string( ((*yyvaluep).reg_value).type ), ((*yyvaluep).reg_value).size, ((*yyvaluep).reg_value).reg, ((*yyvaluep).reg_value).x64_exp); }
958 #line 959 "fcml_gas_parser_def.c"
959 break;
960
961 case 8: /* FCML_TK_REG_OPMASK */
962 #line 115 "fcml_gas_parser_def.y"
963 { YYFPRINTF(yyoutput, "Type: %s Size: %d Reg: %d x64_exp: %d", fcml_fn_pu_reg_type_to_string( ((*yyvaluep).reg_value).type ), ((*yyvaluep).reg_value).size, ((*yyvaluep).reg_value).reg, ((*yyvaluep).reg_value).x64_exp); }
964 #line 965 "fcml_gas_parser_def.c"
965 break;
966
967 case 9: /* FCML_TK_REG_CR */
968 #line 115 "fcml_gas_parser_def.y"
969 { YYFPRINTF(yyoutput, "Type: %s Size: %d Reg: %d x64_exp: %d", fcml_fn_pu_reg_type_to_string( ((*yyvaluep).reg_value).type ), ((*yyvaluep).reg_value).size, ((*yyvaluep).reg_value).reg, ((*yyvaluep).reg_value).x64_exp); }
970 #line 971 "fcml_gas_parser_def.c"
971 break;
972
973 case 10: /* FCML_TK_REG_DR */
974 #line 115 "fcml_gas_parser_def.y"
975 { YYFPRINTF(yyoutput, "Type: %s Size: %d Reg: %d x64_exp: %d", fcml_fn_pu_reg_type_to_string( ((*yyvaluep).reg_value).type ), ((*yyvaluep).reg_value).size, ((*yyvaluep).reg_value).reg, ((*yyvaluep).reg_value).x64_exp); }
976 #line 977 "fcml_gas_parser_def.c"
977 break;
978
979 case 11: /* FCML_TK_REG_RIP */
980 #line 115 "fcml_gas_parser_def.y"
981 { YYFPRINTF(yyoutput, "Type: %s Size: %d Reg: %d x64_exp: %d", fcml_fn_pu_reg_type_to_string( ((*yyvaluep).reg_value).type ), ((*yyvaluep).reg_value).size, ((*yyvaluep).reg_value).reg, ((*yyvaluep).reg_value).x64_exp); }
982 #line 983 "fcml_gas_parser_def.c"
983 break;
984
985 case 16: /* FCML_TK_OPMASK_REG_DECORATOR */
986 #line 115 "fcml_gas_parser_def.y"
987 { YYFPRINTF(yyoutput, "Type: %s Size: %d Reg: %d x64_exp: %d", fcml_fn_pu_reg_type_to_string( ((*yyvaluep).reg_value).type ), ((*yyvaluep).reg_value).size, ((*yyvaluep).reg_value).reg, ((*yyvaluep).reg_value).x64_exp); }
988 #line 989 "fcml_gas_parser_def.c"
989 break;
990
991 case 17: /* FCML_TK_INTEGER */
992 #line 113 "fcml_gas_parser_def.y"
993 { YYFPRINTF(yyoutput, "Integer: %ld Overflow: %d", ((*yyvaluep).integer_value).value, ((*yyvaluep).integer_value).overflow); }
994 #line 995 "fcml_gas_parser_def.c"
995 break;
996
997 case 33: /* instruction */
998 #line 114 "fcml_gas_parser_def.y"
999 { YYFPRINTF(yyoutput, "AST-Type: %d", ((*yyvaluep).ast)->type); }
1000 #line 1001 "fcml_gas_parser_def.c"
1001 break;
1002
1003 case 36: /* operand_list */
1004 #line 114 "fcml_gas_parser_def.y"
1005 { YYFPRINTF(yyoutput, "AST-Type: %d", ((*yyvaluep).ast)->type); }
1006 #line 1007 "fcml_gas_parser_def.c"
1007 break;
1008
1009 case 37: /* operand */
1010 #line 114 "fcml_gas_parser_def.y"
1011 { YYFPRINTF(yyoutput, "AST-Type: %d", ((*yyvaluep).ast)->type); }
1012 #line 1013 "fcml_gas_parser_def.c"
1013 break;
1014
1015 case 38: /* effective_address */
1016 #line 114 "fcml_gas_parser_def.y"
1017 { YYFPRINTF(yyoutput, "AST-Type: %d", ((*yyvaluep).ast)->type); }
1018 #line 1019 "fcml_gas_parser_def.c"
1019 break;
1020
1021 case 39: /* effective_address_components */
1022 #line 114 "fcml_gas_parser_def.y"
1023 { YYFPRINTF(yyoutput, "AST-Type: %d", ((*yyvaluep).ast)->type); }
1024 #line 1025 "fcml_gas_parser_def.c"
1025 break;
1026
1027 case 40: /* effective_address_components_without_dis */
1028 #line 114 "fcml_gas_parser_def.y"
1029 { YYFPRINTF(yyoutput, "AST-Type: %d", ((*yyvaluep).ast)->type); }
1030 #line 1031 "fcml_gas_parser_def.c"
1031 break;
1032
1033 case 41: /* segment_selector */
1034 #line 115 "fcml_gas_parser_def.y"
1035 { YYFPRINTF(yyoutput, "Type: %s Size: %d Reg: %d x64_exp: %d", fcml_fn_pu_reg_type_to_string( ((*yyvaluep).reg_value).type ), ((*yyvaluep).reg_value).size, ((*yyvaluep).reg_value).reg, ((*yyvaluep).reg_value).x64_exp); }
1036 #line 1037 "fcml_gas_parser_def.c"
1037 break;
1038
1039 case 42: /* exp */
1040 #line 114 "fcml_gas_parser_def.y"
1041 { YYFPRINTF(yyoutput, "AST-Type: %d", ((*yyvaluep).ast)->type); }
1042 #line 1043 "fcml_gas_parser_def.c"
1043 break;
1044
1045 case 43: /* reg */
1046 #line 115 "fcml_gas_parser_def.y"
1047 { YYFPRINTF(yyoutput, "Type: %s Size: %d Reg: %d x64_exp: %d", fcml_fn_pu_reg_type_to_string( ((*yyvaluep).reg_value).type ), ((*yyvaluep).reg_value).size, ((*yyvaluep).reg_value).reg, ((*yyvaluep).reg_value).x64_exp); }
1048 #line 1049 "fcml_gas_parser_def.c"
1049 break;
1050
1051 case 44: /* pseudo_operation */
1052 #line 114 "fcml_gas_parser_def.y"
1053 { YYFPRINTF(yyoutput, "AST-Type: %d", ((*yyvaluep).ast)->type); }
1054 #line 1055 "fcml_gas_parser_def.c"
1055 break;
1056
1057 default:
1058 break;
1059 }
1060 YY_IGNORE_MAYBE_UNINITIALIZED_END
1061 }
1062
1063
1064 /*---------------------------.
1065 | Print this symbol on YYO. |
1066 `---------------------------*/
1067
1068 static void
1069 yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, struct fcml_st_parser_data *pd)
1070 {
1071 YYFPRINTF (yyo, "%s %s (",
1072 yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
1073
1074 YY_LOCATION_PRINT (yyo, *yylocationp);
1075 YYFPRINTF (yyo, ": ");
1076 yy_symbol_value_print (yyo, yytype, yyvaluep, yylocationp, pd);
1077 YYFPRINTF (yyo, ")");
1078 }
1079
1080 /*------------------------------------------------------------------.
1081 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1082 | TOP (included). |
1083 `------------------------------------------------------------------*/
1084
1085 static void
1086 yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
1087 {
1088 YYFPRINTF (stderr, "Stack now");
1089 for (; yybottom <= yytop; yybottom++)
1090 {
1091 int yybot = *yybottom;
1092 YYFPRINTF (stderr, " %d", yybot);
1093 }
1094 YYFPRINTF (stderr, "\n");
1095 }
1096
1097 # define YY_STACK_PRINT(Bottom, Top) \
1098 do { \
1099 if (yydebug) \
1100 yy_stack_print ((Bottom), (Top)); \
1101 } while (0)
1102
1103
1104 /*------------------------------------------------.
1105 | Report that the YYRULE is going to be reduced. |
1106 `------------------------------------------------*/
1107
1108 static void
1109 yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, struct fcml_st_parser_data *pd)
1110 {
1111 int yylno = yyrline[yyrule];
1112 int yynrhs = yyr2[yyrule];
1113 int yyi;
1114 YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
1115 yyrule - 1, yylno);
1116 /* The symbols being reduced. */
1117 for (yyi = 0; yyi < yynrhs; yyi++)
1118 {
1119 YYFPRINTF (stderr, " $%d = ", yyi + 1);
1120 yy_symbol_print (stderr,
1121 yystos[+yyssp[yyi + 1 - yynrhs]],
1122 &yyvsp[(yyi + 1) - (yynrhs)]
1123 , &(yylsp[(yyi + 1) - (yynrhs)]) , pd);
1124 YYFPRINTF (stderr, "\n");
1125 }
1126 }
1127
1128 # define YY_REDUCE_PRINT(Rule) \
1129 do { \
1130 if (yydebug) \
1131 yy_reduce_print (yyssp, yyvsp, yylsp, Rule, pd); \
1132 } while (0)
1133
1134 /* Nonzero means print parse trace. It is left uninitialized so that
1135 multiple parsers can coexist. */
1136 int yydebug;
1137 #else /* !GAS_DEBUG */
1138 # define YYDPRINTF(Args)
1139 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1140 # define YY_STACK_PRINT(Bottom, Top)
1141 # define YY_REDUCE_PRINT(Rule)
1142 #endif /* !GAS_DEBUG */
1143
1144
1145 /* YYINITDEPTH -- initial size of the parser's stacks. */
1146 #ifndef YYINITDEPTH
1147 # define YYINITDEPTH 200
1148 #endif
1149
1150 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1151 if the built-in stack extension method is used).
1152
1153 Do not make this value too large; the results are undefined if
1154 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1155 evaluated with infinite-precision integer arithmetic. */
1156
1157 #ifndef YYMAXDEPTH
1158 # define YYMAXDEPTH 10000
1159 #endif
1160
1161
1162 #if YYERROR_VERBOSE
1163
1164 # ifndef yystrlen
1165 # if defined __GLIBC__ && defined _STRING_H
1166 # define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S)))
1167 # else
1168 /* Return the length of YYSTR. */
1169 static YYPTRDIFF_T
1170 yystrlen (const char *yystr)
1171 {
1172 YYPTRDIFF_T yylen;
1173 for (yylen = 0; yystr[yylen]; yylen++)
1174 continue;
1175 return yylen;
1176 }
1177 # endif
1178 # endif
1179
1180 # ifndef yystpcpy
1181 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1182 # define yystpcpy stpcpy
1183 # else
1184 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1185 YYDEST. */
1186 static char *
1187 yystpcpy (char *yydest, const char *yysrc)
1188 {
1189 char *yyd = yydest;
1190 const char *yys = yysrc;
1191
1192 while ((*yyd++ = *yys++) != '\0')
1193 continue;
1194
1195 return yyd - 1;
1196 }
1197 # endif
1198 # endif
1199
1200 # ifndef yytnamerr
1201 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1202 quotes and backslashes, so that it's suitable for yyerror. The
1203 heuristic is that double-quoting is unnecessary unless the string
1204 contains an apostrophe, a comma, or backslash (other than
1205 backslash-backslash). YYSTR is taken from yytname. If YYRES is
1206 null, do not copy; instead, return the length of what the result
1207 would have been. */
1208 static YYPTRDIFF_T
1209 yytnamerr (char *yyres, const char *yystr)
1210 {
1211 if (*yystr == '"')
1212 {
1213 YYPTRDIFF_T yyn = 0;
1214 char const *yyp = yystr;
1215
1216 for (;;)
1217 switch (*++yyp)
1218 {
1219 case '\'':
1220 case ',':
1221 goto do_not_strip_quotes;
1222
1223 case '\\':
1224 if (*++yyp != '\\')
1225 goto do_not_strip_quotes;
1226 else
1227 goto append;
1228
1229 append:
1230 default:
1231 if (yyres)
1232 yyres[yyn] = *yyp;
1233 yyn++;
1234 break;
1235
1236 case '"':
1237 if (yyres)
1238 yyres[yyn] = '\0';
1239 return yyn;
1240 }
1241 do_not_strip_quotes: ;
1242 }
1243
1244 if (yyres)
1245 return yystpcpy (yyres, yystr) - yyres;
1246 else
1247 return yystrlen (yystr);
1248 }
1249 # endif
1250
1251 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1252 about the unexpected token YYTOKEN for the state stack whose top is
1253 YYSSP.
1254
1255 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
1256 not large enough to hold the message. In that case, also set
1257 *YYMSG_ALLOC to the required number of bytes. Return 2 if the
1258 required number of bytes is too large to store. */
1259 static int
1260 yysyntax_error (YYPTRDIFF_T *yymsg_alloc, char **yymsg,
1261 yy_state_t *yyssp, int yytoken)
1262 {
1263 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1264 /* Internationalized format string. */
1265 const char *yyformat = YY_NULLPTR;
1266 /* Arguments of yyformat: reported tokens (one for the "unexpected",
1267 one per "expected"). */
1268 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1269 /* Actual size of YYARG. */
1270 int yycount = 0;
1271 /* Cumulated lengths of YYARG. */
1272 YYPTRDIFF_T yysize = 0;
1273
1274 /* There are many possibilities here to consider:
1275 - If this state is a consistent state with a default action, then
1276 the only way this function was invoked is if the default action
1277 is an error action. In that case, don't check for expected
1278 tokens because there are none.
1279 - The only way there can be no lookahead present (in yychar) is if
1280 this state is a consistent state with a default action. Thus,
1281 detecting the absence of a lookahead is sufficient to determine
1282 that there is no unexpected or expected token to report. In that
1283 case, just report a simple "syntax error".
1284 - Don't assume there isn't a lookahead just because this state is a
1285 consistent state with a default action. There might have been a
1286 previous inconsistent state, consistent state with a non-default
1287 action, or user semantic action that manipulated yychar.
1288 - Of course, the expected token list depends on states to have
1289 correct lookahead information, and it depends on the parser not
1290 to perform extra reductions after fetching a lookahead from the
1291 scanner and before detecting a syntax error. Thus, state merging
1292 (from LALR or IELR) and default reductions corrupt the expected
1293 token list. However, the list is correct for canonical LR with
1294 one exception: it will still contain any token that will not be
1295 accepted due to an error action in a later state.
1296 */
1297 if (yytoken != YYEMPTY)
1298 {
1299 int yyn = yypact[+*yyssp];
1300 YYPTRDIFF_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
1301 yysize = yysize0;
1302 yyarg[yycount++] = yytname[yytoken];
1303 if (!yypact_value_is_default (yyn))
1304 {
1305 /* Start YYX at -YYN if negative to avoid negative indexes in
1306 YYCHECK. In other words, skip the first -YYN actions for
1307 this state because they are default actions. */
1308 int yyxbegin = yyn < 0 ? -yyn : 0;
1309 /* Stay within bounds of both yycheck and yytname. */
1310 int yychecklim = YYLAST - yyn + 1;
1311 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1312 int yyx;
1313
1314 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1315 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1316 && !yytable_value_is_error (yytable[yyx + yyn]))
1317 {
1318 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1319 {
1320 yycount = 1;
1321 yysize = yysize0;
1322 break;
1323 }
1324 yyarg[yycount++] = yytname[yyx];
1325 {
1326 YYPTRDIFF_T yysize1
1327 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
1328 if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
1329 yysize = yysize1;
1330 else
1331 return 2;
1332 }
1333 }
1334 }
1335 }
1336
1337 switch (yycount)
1338 {
1339 # define YYCASE_(N, S) \
1340 case N: \
1341 yyformat = S; \
1342 break
1343 default: /* Avoid compiler warnings. */
1344 YYCASE_(0, YY_("syntax error"));
1345 YYCASE_(1, YY_("syntax error, unexpected %s"));
1346 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1347 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1348 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1349 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1350 # undef YYCASE_
1351 }
1352
1353 {
1354 /* Don't count the "%s"s in the final size, but reserve room for
1355 the terminator. */
1356 YYPTRDIFF_T yysize1 = yysize + (yystrlen (yyformat) - 2 * yycount) + 1;
1357 if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
1358 yysize = yysize1;
1359 else
1360 return 2;
1361 }
1362
1363 if (*yymsg_alloc < yysize)
1364 {
1365 *yymsg_alloc = 2 * yysize;
1366 if (! (yysize <= *yymsg_alloc
1367 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1368 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1369 return 1;
1370 }
1371
1372 /* Avoid sprintf, as that infringes on the user's name space.
1373 Don't have undefined behavior even if the translation
1374 produced a string with the wrong number of "%s"s. */
1375 {
1376 char *yyp = *yymsg;
1377 int yyi = 0;
1378 while ((*yyp = *yyformat) != '\0')
1379 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1380 {
1381 yyp += yytnamerr (yyp, yyarg[yyi++]);
1382 yyformat += 2;
1383 }
1384 else
1385 {
1386 ++yyp;
1387 ++yyformat;
1388 }
1389 }
1390 return 0;
1391 }
1392 #endif /* YYERROR_VERBOSE */
1393
1394 /*-----------------------------------------------.
1395 | Release the memory associated to this symbol. |
1396 `-----------------------------------------------*/
1397
1398 static void
1399 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, struct fcml_st_parser_data *pd)
1400 {
1401 YYUSE (yyvaluep);
1402 YYUSE (yylocationp);
1403 YYUSE (pd);
1404 if (!yymsg)
1405 yymsg = "Deleting";
1406 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1407
1408 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1409 switch (yytype)
1410 {
1411 case 33: /* instruction */
1412 #line 110 "fcml_gas_parser_def.y"
1413 { fcml_fn_ast_free_node(((*yyvaluep).ast)); }
1414 #line 1415 "fcml_gas_parser_def.c"
1415 break;
1416
1417 case 36: /* operand_list */
1418 #line 110 "fcml_gas_parser_def.y"
1419 { fcml_fn_ast_free_node(((*yyvaluep).ast)); }
1420 #line 1421 "fcml_gas_parser_def.c"
1421 break;
1422
1423 case 37: /* operand */
1424 #line 110 "fcml_gas_parser_def.y"
1425 { fcml_fn_ast_free_node(((*yyvaluep).ast)); }
1426 #line 1427 "fcml_gas_parser_def.c"
1427 break;
1428
1429 case 38: /* effective_address */
1430 #line 110 "fcml_gas_parser_def.y"
1431 { fcml_fn_ast_free_node(((*yyvaluep).ast)); }
1432 #line 1433 "fcml_gas_parser_def.c"
1433 break;
1434
1435 case 39: /* effective_address_components */
1436 #line 110 "fcml_gas_parser_def.y"
1437 { fcml_fn_ast_free_node(((*yyvaluep).ast)); }
1438 #line 1439 "fcml_gas_parser_def.c"
1439 break;
1440
1441 case 40: /* effective_address_components_without_dis */
1442 #line 110 "fcml_gas_parser_def.y"
1443 { fcml_fn_ast_free_node(((*yyvaluep).ast)); }
1444 #line 1445 "fcml_gas_parser_def.c"
1445 break;
1446
1447 case 42: /* exp */
1448 #line 110 "fcml_gas_parser_def.y"
1449 { fcml_fn_ast_free_node(((*yyvaluep).ast)); }
1450 #line 1451 "fcml_gas_parser_def.c"
1451 break;
1452
1453 case 44: /* pseudo_operation */
1454 #line 110 "fcml_gas_parser_def.y"
1455 { fcml_fn_ast_free_node(((*yyvaluep).ast)); }
1456 #line 1457 "fcml_gas_parser_def.c"
1457 break;
1458
1459 default:
1460 break;
1461 }
1462 YY_IGNORE_MAYBE_UNINITIALIZED_END
1463 }
1464
1465
1466
1467
1468 /*----------.
1469 | yyparse. |
1470 `----------*/
1471
1472 int
1473 yyparse (struct fcml_st_parser_data *pd)
1474 {
1475 /* The lookahead symbol. */
1476 int yychar;
1477
1478
1479 /* The semantic value of the lookahead symbol. */
1480 /* Default value used for initialization, for pacifying older GCCs
1481 or non-GCC compilers. */
1482 YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
1483 YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
1484
1485 /* Location data for the lookahead symbol. */
1486 static YYLTYPE yyloc_default
1487 # if defined GAS_LTYPE_IS_TRIVIAL && GAS_LTYPE_IS_TRIVIAL
1488 = { 1, 1, 1, 1 }
1489 # endif
1490 ;
1491 YYLTYPE yylloc = yyloc_default;
1492
1493 /* Number of syntax errors so far. */
1494 int yynerrs;
1495
1496 yy_state_fast_t yystate;
1497 /* Number of tokens to shift before error messages enabled. */
1498 int yyerrstatus;
1499
1500 /* The stacks and their tools:
1501 'yyss': related to states.
1502 'yyvs': related to semantic values.
1503 'yyls': related to locations.
1504
1505 Refer to the stacks through separate pointers, to allow yyoverflow
1506 to reallocate them elsewhere. */
1507
1508 /* The state stack. */
1509 yy_state_t yyssa[YYINITDEPTH];
1510 yy_state_t *yyss;
1511 yy_state_t *yyssp;
1512
1513 /* The semantic value stack. */
1514 YYSTYPE yyvsa[YYINITDEPTH];
1515 YYSTYPE *yyvs;
1516 YYSTYPE *yyvsp;
1517
1518 /* The location stack. */
1519 YYLTYPE yylsa[YYINITDEPTH];
1520 YYLTYPE *yyls;
1521 YYLTYPE *yylsp;
1522
1523 /* The locations where the error started and ended. */
1524 YYLTYPE yyerror_range[3];
1525
1526 YYPTRDIFF_T yystacksize;
1527
1528 int yyn;
1529 int yyresult;
1530 /* Lookahead token as an internal (translated) token number. */
1531 int yytoken = 0;
1532 /* The variables used to return semantic value and location from the
1533 action routines. */
1534 YYSTYPE yyval;
1535 YYLTYPE yyloc;
1536
1537 #if YYERROR_VERBOSE
1538 /* Buffer for error messages, and its allocated size. */
1539 char yymsgbuf[128];
1540 char *yymsg = yymsgbuf;
1541 YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf;
1542 #endif
1543
1544 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
1545
1546 /* The number of symbols on the RHS of the reduced rule.
1547 Keep to zero when no symbol should be popped. */
1548 int yylen = 0;
1549
1550 yyssp = yyss = yyssa;
1551 yyvsp = yyvs = yyvsa;
1552 yylsp = yyls = yylsa;
1553 yystacksize = YYINITDEPTH;
1554
1555 YYDPRINTF ((stderr, "Starting parse\n"));
1556
1557 yystate = 0;
1558 yyerrstatus = 0;
1559 yynerrs = 0;
1560 yychar = YYEMPTY; /* Cause a token to be read. */
1561
1562 /* User initialization code. */
1563 #line 139 "fcml_gas_parser_def.y"
1564 {
1565 /* Uncomment it in order to enable debugging */
1566 /* gas_debug = 1; */
1567 }
1568
1569 #line 1570 "fcml_gas_parser_def.c"
1570
1571 yylsp[0] = yylloc;
1572 goto yysetstate;
1573
1574
1575 /*------------------------------------------------------------.
1576 | yynewstate -- push a new state, which is found in yystate. |
1577 `------------------------------------------------------------*/
1578 yynewstate:
1579 /* In all cases, when you get here, the value and location stacks
1580 have just been pushed. So pushing a state here evens the stacks. */
1581 yyssp++;
1582
1583
1584 /*--------------------------------------------------------------------.
1585 | yysetstate -- set current state (the top of the stack) to yystate. |
1586 `--------------------------------------------------------------------*/
1587 yysetstate:
1588 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1589 YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
1590 YY_IGNORE_USELESS_CAST_BEGIN
1591 *yyssp = YY_CAST (yy_state_t, yystate);
1592 YY_IGNORE_USELESS_CAST_END
1593
1594 if (yyss + yystacksize - 1 <= yyssp)
1595 #if !defined yyoverflow && !defined YYSTACK_RELOCATE
1596 goto yyexhaustedlab;
1597 #else
1598 {
1599 /* Get the current used size of the three stacks, in elements. */
1600 YYPTRDIFF_T yysize = yyssp - yyss + 1;
1601
1602 # if defined yyoverflow
1603 {
1604 /* Give user a chance to reallocate the stack. Use copies of
1605 these so that the &'s don't force the real ones into
1606 memory. */
1607 yy_state_t *yyss1 = yyss;
1608 YYSTYPE *yyvs1 = yyvs;
1609 YYLTYPE *yyls1 = yyls;
1610
1611 /* Each stack pointer address is followed by the size of the
1612 data in use in that stack, in bytes. This used to be a
1613 conditional around just the two extra args, but that might
1614 be undefined if yyoverflow is a macro. */
1615 yyoverflow (YY_("memory exhausted"),
1616 &yyss1, yysize * YYSIZEOF (*yyssp),
1617 &yyvs1, yysize * YYSIZEOF (*yyvsp),
1618 &yyls1, yysize * YYSIZEOF (*yylsp),
1619 &yystacksize);
1620 yyss = yyss1;
1621 yyvs = yyvs1;
1622 yyls = yyls1;
1623 }
1624 # else /* defined YYSTACK_RELOCATE */
1625 /* Extend the stack our own way. */
1626 if (YYMAXDEPTH <= yystacksize)
1627 goto yyexhaustedlab;
1628 yystacksize *= 2;
1629 if (YYMAXDEPTH < yystacksize)
1630 yystacksize = YYMAXDEPTH;
1631
1632 {
1633 yy_state_t *yyss1 = yyss;
1634 union yyalloc *yyptr =
1635 YY_CAST (union yyalloc *,
1636 YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
1637 if (! yyptr)
1638 goto yyexhaustedlab;
1639 YYSTACK_RELOCATE (yyss_alloc, yyss);
1640 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1641 YYSTACK_RELOCATE (yyls_alloc, yyls);
1642 # undef YYSTACK_RELOCATE
1643 if (yyss1 != yyssa)
1644 YYSTACK_FREE (yyss1);
1645 }
1646 # endif
1647
1648 yyssp = yyss + yysize - 1;
1649 yyvsp = yyvs + yysize - 1;
1650 yylsp = yyls + yysize - 1;
1651
1652 YY_IGNORE_USELESS_CAST_BEGIN
1653 YYDPRINTF ((stderr, "Stack size increased to %ld\n",
1654 YY_CAST (long, yystacksize)));
1655 YY_IGNORE_USELESS_CAST_END
1656
1657 if (yyss + yystacksize - 1 <= yyssp)
1658 YYABORT;
1659 }
1660 #endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
1661
1662 if (yystate == YYFINAL)
1663 YYACCEPT;
1664
1665 goto yybackup;
1666
1667
1668 /*-----------.
1669 | yybackup. |
1670 `-----------*/
1671 yybackup:
1672 /* Do appropriate processing given the current state. Read a
1673 lookahead token if we need one and don't already have one. */
1674
1675 /* First try to decide what to do without reference to lookahead token. */
1676 yyn = yypact[yystate];
1677 if (yypact_value_is_default (yyn))
1678 goto yydefault;
1679
1680 /* Not known => get a lookahead token if don't already have one. */
1681
1682 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1683 if (yychar == YYEMPTY)
1684 {
1685 YYDPRINTF ((stderr, "Reading a token: "));
1686 yychar = yylex (&yylval, &yylloc, yyscanner);
1687 }
1688
1689 if (yychar <= YYEOF)
1690 {
1691 yychar = yytoken = YYEOF;
1692 YYDPRINTF ((stderr, "Now at end of input.\n"));
1693 }
1694 else
1695 {
1696 yytoken = YYTRANSLATE (yychar);
1697 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1698 }
1699
1700 /* If the proper action on seeing token YYTOKEN is to reduce or to
1701 detect an error, take that action. */
1702 yyn += yytoken;
1703 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1704 goto yydefault;
1705 yyn = yytable[yyn];
1706 if (yyn <= 0)
1707 {
1708 if (yytable_value_is_error (yyn))
1709 goto yyerrlab;
1710 yyn = -yyn;
1711 goto yyreduce;
1712 }
1713
1714 /* Count tokens shifted since error; after three, turn off error
1715 status. */
1716 if (yyerrstatus)
1717 yyerrstatus--;
1718
1719 /* Shift the lookahead token. */
1720 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1721 yystate = yyn;
1722 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1723 *++yyvsp = yylval;
1724 YY_IGNORE_MAYBE_UNINITIALIZED_END
1725 *++yylsp = yylloc;
1726
1727 /* Discard the shifted token. */
1728 yychar = YYEMPTY;
1729 goto yynewstate;
1730
1731
1732 /*-----------------------------------------------------------.
1733 | yydefault -- do the default action for the current state. |
1734 `-----------------------------------------------------------*/
1735 yydefault:
1736 yyn = yydefact[yystate];
1737 if (yyn == 0)
1738 goto yyerrlab;
1739 goto yyreduce;
1740
1741
1742 /*-----------------------------.
1743 | yyreduce -- do a reduction. |
1744 `-----------------------------*/
1745 yyreduce:
1746 /* yyn is the number of a rule to reduce with. */
1747 yylen = yyr2[yyn];
1748
1749 /* If YYLEN is nonzero, implement the default value of the action:
1750 '$$ = $1'.
1751
1752 Otherwise, the following line sets YYVAL to garbage.
1753 This behavior is undocumented and Bison
1754 users should not rely upon it. Assigning to YYVAL
1755 unconditionally makes the parser a bit smaller, and it avoids a
1756 GCC warning that YYVAL may be used uninitialized. */
1757 yyval = yyvsp[1-yylen];
1758
1759 /* Default location. */
1760 YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
1761 yyerror_range[1] = yyloc;
1762 YY_REDUCE_PRINT (yyn);
1763 switch (yyn)
1764 {
1765 case 3:
1766 #line 147 "fcml_gas_parser_def.y"
1767 { pd->tree = (yyvsp[0].ast); pd->symbol = NULL; }
1768 #line 1769 "fcml_gas_parser_def.c"
1769 break;
1770
1771 case 4:
1772 #line 148 "fcml_gas_parser_def.y"
1773 { pd->tree = (yyvsp[0].ast); pd->symbol = NULL; }
1774 #line 1775 "fcml_gas_parser_def.c"
1775 break;
1776
1777 case 5:
1778 #line 149 "fcml_gas_parser_def.y"
1779 { pd->tree = NULL; pd->symbol = fcml_fn_ast_alloc_node_define_symbol( pd->ip, (yyvsp[-1].symbol).text, (yyvsp[-1].symbol).length ); HANDLE_ERRORS( pd->symbol ); }
1780 #line 1781 "fcml_gas_parser_def.c"
1781 break;
1782
1783 case 6:
1784 #line 150 "fcml_gas_parser_def.y"
1785 { pd->tree = (yyvsp[0].ast); pd->symbol = fcml_fn_ast_alloc_node_define_symbol( pd->ip, (yyvsp[-2].symbol).text, (yyvsp[-2].symbol).length ); HANDLE_ERRORS( pd->symbol ); }
1786 #line 1787 "fcml_gas_parser_def.c"
1787 break;
1788
1789 case 7:
1790 #line 151 "fcml_gas_parser_def.y"
1791 { pd->tree = (yyvsp[0].ast); pd->symbol = fcml_fn_ast_alloc_node_define_symbol( pd->ip, (yyvsp[-2].symbol).text, (yyvsp[-2].symbol).length ); HANDLE_ERRORS( pd->symbol ); }
1792 #line 1793 "fcml_gas_parser_def.c"
1793 break;
1794
1795 case 8:
1796 #line 154 "fcml_gas_parser_def.y"
1797 { (yyval.ast) = fcml_fn_ast_alloc_node_instruction( 0, (yyvsp[0].symbol).text, (yyvsp[0].symbol).length, 0, NULL ); HANDLE_ERRORS((yyval.ast)); }
1798 #line 1799 "fcml_gas_parser_def.c"
1799 break;
1800
1801 case 9:
1802 #line 155 "fcml_gas_parser_def.y"
1803 { (yyval.ast) = fcml_fn_ast_alloc_node_instruction( 0, (yyvsp[-1].symbol).text, (yyvsp[-1].symbol).length, 0, (yyvsp[0].ast) ); HANDLE_ERRORS((yyval.ast)); }
1804 #line 1805 "fcml_gas_parser_def.c"
1805 break;
1806
1807 case 10:
1808 #line 156 "fcml_gas_parser_def.y"
1809 { (yyval.ast) = fcml_fn_ast_alloc_node_instruction( (yyvsp[-1].prefixes), (yyvsp[0].symbol).text, (yyvsp[0].symbol).length, 0, NULL ); HANDLE_ERRORS((yyval.ast)); }
1810 #line 1811 "fcml_gas_parser_def.c"
1811 break;
1812
1813 case 11:
1814 #line 157 "fcml_gas_parser_def.y"
1815 { (yyval.ast) = fcml_fn_ast_alloc_node_instruction( (yyvsp[-2].prefixes), (yyvsp[-1].symbol).text, (yyvsp[-1].symbol).length, 0, (yyvsp[0].ast) ); HANDLE_ERRORS((yyval.ast)); }
1816 #line 1817 "fcml_gas_parser_def.c"
1817 break;
1818
1819 case 13:
1820 #line 161 "fcml_gas_parser_def.y"
1821 { if( (yyvsp[-1].prefixes) & (yyvsp[0].prefixes) ) { ADD_ERROR_MSG( "Doubled prefixes." ); YYERROR; } else { (yyval.prefixes) = (yyvsp[-1].prefixes) | (yyvsp[0].prefixes); } }
1822 #line 1823 "fcml_gas_parser_def.c"
1823 break;
1824
1825 case 15:
1826 #line 167 "fcml_gas_parser_def.y"
1827 { (yyval.ast) = fcml_fn_ast_alloc_node_operand_list( (yyvsp[0].ast), NULL ); HANDLE_ERRORS((yyval.ast)); }
1828 #line 1829 "fcml_gas_parser_def.c"
1829 break;
1830
1831 case 16:
1832 #line 168 "fcml_gas_parser_def.y"
1833 { (yyval.ast) = fcml_fn_ast_alloc_node_operand_list( (yyvsp[-2].ast), (yyvsp[0].ast) ); HANDLE_ERRORS((yyval.ast)); }
1834 #line 1835 "fcml_gas_parser_def.c"
1835 break;
1836
1837 case 17:
1838 #line 171 "fcml_gas_parser_def.y"
1839 { (yyval.ast) = (yyvsp[0].ast); }
1840 #line 1841 "fcml_gas_parser_def.c"
1841 break;
1842
1843 case 19:
1844 #line 173 "fcml_gas_parser_def.y"
1845 { (yyval.ast) = fcml_fn_ast_decorate_effective_address((yyvsp[-1].ast), &(yyvsp[0].reg_value), FCML_FALSE); }
1846 #line 1847 "fcml_gas_parser_def.c"
1847 break;
1848
1849 case 20:
1850 #line 174 "fcml_gas_parser_def.y"
1851 { (yyval.ast) = fcml_fn_ast_decorate_effective_address((yyvsp[-2].ast), &(yyvsp[-1].reg_value), FCML_TRUE); }
1852 #line 1853 "fcml_gas_parser_def.c"
1853 break;
1854
1855 case 21:
1856 #line 175 "fcml_gas_parser_def.y"
1857 { (yyval.ast) = fcml_fn_ast_decorate_effective_address((yyvsp[-1].ast), NULL, FCML_TRUE); }
1858 #line 1859 "fcml_gas_parser_def.c"
1859 break;
1860
1861 case 22:
1862 #line 176 "fcml_gas_parser_def.y"
1863 { (yyval.ast) = fcml_fn_ast_set_effective_address_hins( (yyvsp[0].ast), FCML_HINT_INDIRECT_POINTER ); }
1864 #line 1865 "fcml_gas_parser_def.c"
1865 break;
1866
1867 case 23:
1868 #line 177 "fcml_gas_parser_def.y"
1869 { (yyval.ast) = fcml_fn_ast_alloc_node_register( &(yyvsp[0].reg_value), NULL, FCML_FALSE ); HANDLE_ERRORS((yyval.ast)); }
1870 #line 1871 "fcml_gas_parser_def.c"
1871 break;
1872
1873 case 24:
1874 #line 178 "fcml_gas_parser_def.y"
1875 { (yyval.ast) = fcml_fn_ast_alloc_node_register( &(yyvsp[-1].reg_value), &(yyvsp[0].reg_value), FCML_FALSE ); HANDLE_ERRORS((yyval.ast)); }
1876 #line 1877 "fcml_gas_parser_def.c"
1877 break;
1878
1879 case 25:
1880 #line 179 "fcml_gas_parser_def.y"
1881 { (yyval.ast) = fcml_fn_ast_alloc_node_register( &(yyvsp[-2].reg_value), &(yyvsp[-1].reg_value), FCML_TRUE ); HANDLE_ERRORS((yyval.ast)); }
1882 #line 1883 "fcml_gas_parser_def.c"
1883 break;
1884
1885 case 26:
1886 #line 180 "fcml_gas_parser_def.y"
1887 { (yyval.ast) = fcml_fn_ast_alloc_node_register( &(yyvsp[-1].reg_value), NULL, FCML_TRUE ); HANDLE_ERRORS((yyval.ast)); }
1888 #line 1889 "fcml_gas_parser_def.c"
1889 break;
1890
1891 case 27:
1892 #line 181 "fcml_gas_parser_def.y"
1893 { (yyval.ast) = fcml_fn_ast_alloc_node_virtual( FCML_TRUE, FCML_FALSE, 0 ); HANDLE_ERRORS((yyval.ast)); }
1894 #line 1895 "fcml_gas_parser_def.c"
1895 break;
1896
1897 case 28:
1898 #line 182 "fcml_gas_parser_def.y"
1899 { (yyval.ast) = fcml_fn_ast_alloc_node_virtual( FCML_FALSE, FCML_TRUE, (yyvsp[0].int_value) ); HANDLE_ERRORS((yyval.ast)); }
1900 #line 1901 "fcml_gas_parser_def.c"
1901 break;
1902
1903 case 30:
1904 #line 186 "fcml_gas_parser_def.y"
1905 { (yyval.ast) = fcml_fn_ast_set_effective_address_details( &(yyvsp[-1].reg_value), FCML_OS_UNDEFINED, 0, (yyvsp[0].ast) ); }
1906 #line 1907 "fcml_gas_parser_def.c"
1907 break;
1908
1909 case 31:
1910 #line 187 "fcml_gas_parser_def.y"
1911 { (yyval.ast) = fcml_fn_ast_set_effective_address_details( NULL, FCML_OS_UNDEFINED, (yyvsp[0].int_value), (yyvsp[-1].ast) ); }
1912 #line 1913 "fcml_gas_parser_def.c"
1913 break;
1914
1915 case 33:
1916 #line 192 "fcml_gas_parser_def.y"
1917 { (yyval.ast) = fcml_fn_ast_set_displacemnt( (yyvsp[-1].ast), (yyvsp[0].ast) ); }
1918 #line 1919 "fcml_gas_parser_def.c"
1919 break;
1920
1921 case 34:
1922 #line 193 "fcml_gas_parser_def.y"
1923 { (yyval.ast) = fcml_fn_ast_alloc_node_effective_address( NULL, NULL, NULL, (yyvsp[0].ast), FCML_FALSE, 0); }
1924 #line 1925 "fcml_gas_parser_def.c"
1925 break;
1926
1927 case 35:
1928 #line 197 "fcml_gas_parser_def.y"
1929 { (yyval.ast) = fcml_fn_ast_alloc_node_effective_address( &(yyvsp[-1].reg_value), NULL, NULL, NULL, FCML_FALSE, 0 ); }
1930 #line 1931 "fcml_gas_parser_def.c"
1931 break;
1932
1933 case 36:
1934 #line 198 "fcml_gas_parser_def.y"
1935 { (yyval.ast) = fcml_fn_ast_alloc_node_effective_address( &(yyvsp[-1].reg_value), NULL, NULL, NULL, FCML_FALSE, 0 ); }
1936 #line 1937 "fcml_gas_parser_def.c"
1937 break;
1938
1939 case 37:
1940 #line 199 "fcml_gas_parser_def.y"
1941 { (yyval.ast) = fcml_fn_ast_alloc_node_effective_address( &(yyvsp[-3].reg_value), &(yyvsp[-1].reg_value), NULL, NULL, FCML_FALSE, 0 ); }
1942 #line 1943 "fcml_gas_parser_def.c"
1943 break;
1944
1945 case 38:
1946 #line 200 "fcml_gas_parser_def.y"
1947 { (yyval.ast) = fcml_fn_ast_alloc_node_effective_address( NULL, &(yyvsp[-1].reg_value), NULL, NULL, FCML_FALSE, 0 ); }
1948 #line 1949 "fcml_gas_parser_def.c"
1949 break;
1950
1951 case 39:
1952 #line 201 "fcml_gas_parser_def.y"
1953 { (yyval.ast) = fcml_fn_ast_alloc_node_effective_address( &(yyvsp[-5].reg_value), &(yyvsp[-3].reg_value), &(yyvsp[-1].integer_value), NULL, FCML_FALSE, 0 ); }
1954 #line 1955 "fcml_gas_parser_def.c"
1955 break;
1956
1957 case 40:
1958 #line 202 "fcml_gas_parser_def.y"
1959 { (yyval.ast) = fcml_fn_ast_alloc_node_effective_address( NULL, &(yyvsp[-3].reg_value), &(yyvsp[-1].integer_value), NULL, FCML_FALSE, 0 ); }
1960 #line 1961 "fcml_gas_parser_def.c"
1961 break;
1962
1963 case 41:
1964 #line 205 "fcml_gas_parser_def.y"
1965 { (yyval.reg_value) = (yyvsp[-1].reg_value); }
1966 #line 1967 "fcml_gas_parser_def.c"
1967 break;
1968
1969 case 42:
1970 #line 209 "fcml_gas_parser_def.y"
1971 { (yyval.ast) = fcml_fn_ast_alloc_node_integer( &(yyvsp[0].integer_value) ); HANDLE_ERRORS((yyval.ast)); }
1972 #line 1973 "fcml_gas_parser_def.c"
1973 break;
1974
1975 case 43:
1976 #line 210 "fcml_gas_parser_def.y"
1977 { (yyval.ast) = fcml_fn_ast_alloc_node_exp( FCML_EN_EXN_SUB, (yyvsp[-2].ast), (yyvsp[0].ast) ); HANDLE_ERRORS((yyval.ast)); }
1978 #line 1979 "fcml_gas_parser_def.c"
1979 break;
1980
1981 case 44:
1982 #line 211 "fcml_gas_parser_def.y"
1983 { (yyval.ast) = fcml_fn_ast_alloc_node_exp( FCML_EN_EXN_ADD, (yyvsp[-2].ast), (yyvsp[0].ast) ); HANDLE_ERRORS((yyval.ast)); }
1984 #line 1985 "fcml_gas_parser_def.c"
1985 break;
1986
1987 case 45:
1988 #line 212 "fcml_gas_parser_def.y"
1989 { (yyval.ast) = fcml_fn_ast_alloc_node_exp( FCML_EN_EXN_DIV, (yyvsp[-2].ast), (yyvsp[0].ast) ); HANDLE_ERRORS((yyval.ast)); }
1990 #line 1991 "fcml_gas_parser_def.c"
1991 break;
1992
1993 case 46:
1994 #line 213 "fcml_gas_parser_def.y"
1995 { (yyval.ast) = fcml_fn_ast_alloc_node_exp( FCML_EN_EXN_MUL, (yyvsp[-2].ast), (yyvsp[0].ast) ); HANDLE_ERRORS((yyval.ast)); }
1996 #line 1997 "fcml_gas_parser_def.c"
1997 break;
1998
1999 case 47:
2000 #line 214 "fcml_gas_parser_def.y"
2001 { (yyval.ast) = fcml_fn_ast_alloc_node_use_symbol( (yyvsp[0].symbol).text, (yyvsp[0].symbol).length ); HANDLE_ERRORS((yyval.ast)); }
2002 #line 2003 "fcml_gas_parser_def.c"
2003 break;
2004
2005 case 48:
2006 #line 215 "fcml_gas_parser_def.y"
2007 { (yyval.ast) = fcml_fn_ast_alloc_node_uminus( (yyvsp[0].ast) ); HANDLE_ERRORS((yyval.ast)); }
2008 #line 2009 "fcml_gas_parser_def.c"
2009 break;
2010
2011 case 49:
2012 #line 216 "fcml_gas_parser_def.y"
2013 { (yyval.ast) = (yyvsp[-1].ast); }
2014 #line 2015 "fcml_gas_parser_def.c"
2015 break;
2016
2017 case 57:
2018 #line 231 "fcml_gas_parser_def.y"
2019 { (yyval.ast) = fcml_fn_ast_alloc_node_pseudo_operation( (yyvsp[-1].symbol).text, (yyvsp[-1].symbol).length, (yyvsp[0].ast) ); HANDLE_ERRORS((yyval.ast)); }
2020 #line 2021 "fcml_gas_parser_def.c"
2021 break;
2022
2023
2024 #line 2025 "fcml_gas_parser_def.c"
2025
2026 default: break;
2027 }
2028 /* User semantic actions sometimes alter yychar, and that requires
2029 that yytoken be updated with the new translation. We take the
2030 approach of translating immediately before every use of yytoken.
2031 One alternative is translating here after every semantic action,
2032 but that translation would be missed if the semantic action invokes
2033 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
2034 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
2035 incorrect destructor might then be invoked immediately. In the
2036 case of YYERROR or YYBACKUP, subsequent parser actions might lead
2037 to an incorrect destructor call or verbose syntax error message
2038 before the lookahead is translated. */
2039 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
2040
2041 YYPOPSTACK (yylen);
2042 yylen = 0;
2043 YY_STACK_PRINT (yyss, yyssp);
2044
2045 *++yyvsp = yyval;
2046 *++yylsp = yyloc;
2047
2048 /* Now 'shift' the result of the reduction. Determine what state
2049 that goes to, based on the state we popped back to and the rule
2050 number reduced by. */
2051 {
2052 const int yylhs = yyr1[yyn] - YYNTOKENS;
2053 const int yyi = yypgoto[yylhs] + *yyssp;
2054 yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
2055 ? yytable[yyi]
2056 : yydefgoto[yylhs]);
2057 }
2058
2059 goto yynewstate;
2060
2061
2062 /*--------------------------------------.
2063 | yyerrlab -- here on detecting error. |
2064 `--------------------------------------*/
2065 yyerrlab:
2066 /* Make sure we have latest lookahead translation. See comments at
2067 user semantic actions for why this is necessary. */
2068 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
2069
2070 /* If not already recovering from an error, report this error. */
2071 if (!yyerrstatus)
2072 {
2073 ++yynerrs;
2074 #if ! YYERROR_VERBOSE
2075 yyerror (&yylloc, pd, YY_("syntax error"));
2076 #else
2077 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
2078 yyssp, yytoken)
2079 {
2080 char const *yymsgp = YY_("syntax error");
2081 int yysyntax_error_status;
2082 yysyntax_error_status = YYSYNTAX_ERROR;
2083 if (yysyntax_error_status == 0)
2084 yymsgp = yymsg;
2085 else if (yysyntax_error_status == 1)
2086 {
2087 if (yymsg != yymsgbuf)
2088 YYSTACK_FREE (yymsg);
2089 yymsg = YY_CAST (char *, YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc)));
2090 if (!yymsg)
2091 {
2092 yymsg = yymsgbuf;
2093 yymsg_alloc = sizeof yymsgbuf;
2094 yysyntax_error_status = 2;
2095 }
2096 else
2097 {
2098 yysyntax_error_status = YYSYNTAX_ERROR;
2099 yymsgp = yymsg;
2100 }
2101 }
2102 yyerror (&yylloc, pd, yymsgp);
2103 if (yysyntax_error_status == 2)
2104 goto yyexhaustedlab;
2105 }
2106 # undef YYSYNTAX_ERROR
2107 #endif
2108 }
2109
2110 yyerror_range[1] = yylloc;
2111
2112 if (yyerrstatus == 3)
2113 {
2114 /* If just tried and failed to reuse lookahead token after an
2115 error, discard it. */
2116
2117 if (yychar <= YYEOF)
2118 {
2119 /* Return failure if at end of input. */
2120 if (yychar == YYEOF)
2121 YYABORT;
2122 }
2123 else
2124 {
2125 yydestruct ("Error: discarding",
2126 yytoken, &yylval, &yylloc, pd);
2127 yychar = YYEMPTY;
2128 }
2129 }
2130
2131 /* Else will try to reuse lookahead token after shifting the error
2132 token. */
2133 goto yyerrlab1;
2134
2135
2136 /*---------------------------------------------------.
2137 | yyerrorlab -- error raised explicitly by YYERROR. |
2138 `---------------------------------------------------*/
2139 yyerrorlab:
2140 /* Pacify compilers when the user code never invokes YYERROR and the
2141 label yyerrorlab therefore never appears in user code. */
2142 if (0)
2143 YYERROR;
2144
2145 /* Do not reclaim the symbols of the rule whose action triggered
2146 this YYERROR. */
2147 YYPOPSTACK (yylen);
2148 yylen = 0;
2149 YY_STACK_PRINT (yyss, yyssp);
2150 yystate = *yyssp;
2151 goto yyerrlab1;
2152
2153
2154 /*-------------------------------------------------------------.
2155 | yyerrlab1 -- common code for both syntax error and YYERROR. |
2156 `-------------------------------------------------------------*/
2157 yyerrlab1:
2158 yyerrstatus = 3; /* Each real token shifted decrements this. */
2159
2160 for (;;)
2161 {
2162 yyn = yypact[yystate];
2163 if (!yypact_value_is_default (yyn))
2164 {
2165 yyn += YYTERROR;
2166 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
2167 {
2168 yyn = yytable[yyn];
2169 if (0 < yyn)
2170 break;
2171 }
2172 }
2173
2174 /* Pop the current state because it cannot handle the error token. */
2175 if (yyssp == yyss)
2176 YYABORT;
2177
2178 yyerror_range[1] = *yylsp;
2179 yydestruct ("Error: popping",
2180 yystos[yystate], yyvsp, yylsp, pd);
2181 YYPOPSTACK (1);
2182 yystate = *yyssp;
2183 YY_STACK_PRINT (yyss, yyssp);
2184 }
2185
2186 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2187 *++yyvsp = yylval;
2188 YY_IGNORE_MAYBE_UNINITIALIZED_END
2189
2190 yyerror_range[2] = yylloc;
2191 /* Using YYLLOC is tempting, but would change the location of
2192 the lookahead. YYLOC is available though. */
2193 YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
2194 *++yylsp = yyloc;
2195
2196 /* Shift the error token. */
2197 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
2198
2199 yystate = yyn;
2200 goto yynewstate;
2201
2202
2203 /*-------------------------------------.
2204 | yyacceptlab -- YYACCEPT comes here. |
2205 `-------------------------------------*/
2206 yyacceptlab:
2207 yyresult = 0;
2208 goto yyreturn;
2209
2210
2211 /*-----------------------------------.
2212 | yyabortlab -- YYABORT comes here. |
2213 `-----------------------------------*/
2214 yyabortlab:
2215 yyresult = 1;
2216 goto yyreturn;
2217
2218
2219 #if !defined yyoverflow || YYERROR_VERBOSE
2220 /*-------------------------------------------------.
2221 | yyexhaustedlab -- memory exhaustion comes here. |
2222 `-------------------------------------------------*/
2223 yyexhaustedlab:
2224 yyerror (&yylloc, pd, YY_("memory exhausted"));
2225 yyresult = 2;
2226 /* Fall through. */
2227 #endif
2228
2229
2230 /*-----------------------------------------------------.
2231 | yyreturn -- parsing is finished, return the result. |
2232 `-----------------------------------------------------*/
2233 yyreturn:
2234 if (yychar != YYEMPTY)
2235 {
2236 /* Make sure we have latest lookahead translation. See comments at
2237 user semantic actions for why this is necessary. */
2238 yytoken = YYTRANSLATE (yychar);
2239 yydestruct ("Cleanup: discarding lookahead",
2240 yytoken, &yylval, &yylloc, pd);
2241 }
2242 /* Do not reclaim the symbols of the rule whose action triggered
2243 this YYABORT or YYACCEPT. */
2244 YYPOPSTACK (yylen);
2245 YY_STACK_PRINT (yyss, yyssp);
2246 while (yyssp != yyss)
2247 {
2248 yydestruct ("Cleanup: popping",
2249 yystos[+*yyssp], yyvsp, yylsp, pd);
2250 YYPOPSTACK (1);
2251 }
2252 #ifndef yyoverflow
2253 if (yyss != yyssa)
2254 YYSTACK_FREE (yyss);
2255 #endif
2256 #if YYERROR_VERBOSE
2257 if (yymsg != yymsgbuf)
2258 YYSTACK_FREE (yymsg);
2259 #endif
2260 return yyresult;
2261 }
2262 #line 234 "fcml_gas_parser_def.y"
2263