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