packages/binutils
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
binutils/remove-file-produced-by-bison.patch

1921 lines
61 KiB
Diff
Raw Permalink Normal View History

backport master to 2.41 (cherry picked from commit 76a68d9a00e7769c07675e883426534440db822d)
2024-10-31 14:15:46 +08:00
From 68485a414f2edc538ca4f4f292caea86b58acce3 Mon Sep 17 00:00:00 2001
From: Xin Wang <wangxin03@loongson.cn>
Date: Wed, 30 Oct 2024 19:47:55 +0800
Subject: [PATCH 122/123] remove file produced by bison
---
gas/config/loongarch-parse.c | 1901 ----------------------------------
1 file changed, 1901 deletions(-)
delete mode 100644 gas/config/loongarch-parse.c
diff --git a/gas/config/loongarch-parse.c b/gas/config/loongarch-parse.c
deleted file mode 100644
index 2fad9e0b..00000000
--- a/gas/config/loongarch-parse.c
+++ /dev/null
@@ -1,1901 +0,0 @@
-/* A Bison parser, made by GNU Bison 3.8.2. */
-
-/* Bison implementation for Yacc-like parsers in C
-
- Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation,
- Inc.
-
- This program is free software: you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program. If not, see <https://www.gnu.org/licenses/>. */
-
-/* As a special exception, you may create a larger work that contains
- part or all of the Bison parser skeleton and distribute that work
- under terms of your choice, so long as that work isn't itself a
- parser generator using the skeleton or a modified version thereof
- as a parser skeleton. Alternatively, if you modify or redistribute
- the parser skeleton itself, you may (at your option) remove this
- special exception, which will cause the skeleton and the resulting
- Bison output files to be licensed under the GNU General Public
- License without this special exception.
-
- This special exception was added by the Free Software Foundation in
- version 2.2 of Bison. */
-
-/* C LALR(1) parser skeleton written by Richard Stallman, by
- simplifying the original so-called "semantic" parser. */
-
-/* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual,
- especially those whose name start with YY_ or yy_. They are
- private implementation details that can be changed or removed. */
-
-/* All symbols defined below should begin with yy or YY, to avoid
- infringing on user name space. This should be done even for local
- variables, as they might otherwise be expanded by user macros.
- There are some unavoidable exceptions within include files to
- define necessary library symbols; they are noted "INFRINGES ON
- USER NAME SPACE" below. */
-
-/* Identify Bison output, and Bison version. */
-#define YYBISON 30802
-
-/* Bison version string. */
-#define YYBISON_VERSION "3.8.2"
-
-/* Skeleton name. */
-#define YYSKELETON_NAME "yacc.c"
-
-/* Pure parsers. */
-#define YYPURE 0
-
-/* Push parsers. */
-#define YYPUSH 0
-
-/* Pull parsers. */
-#define YYPULL 1
-
-
-
-
-/* First part of user prologue. */
-#line 19 "./config/loongarch-parse.y"
-
-#include "as.h"
-#include "loongarch-lex.h"
-#include "loongarch-parse.h"
-static void yyerror (const char *s ATTRIBUTE_UNUSED)
-{
-};
-int yylex (void);
-
-
-static struct reloc_info *top, *end;
-
-static expressionS const_0 =
-{
- .X_op = O_constant,
- .X_add_number = 0
-};
-
-static int
-is_const (struct reloc_info *info)
-{
- return (info->type == BFD_RELOC_LARCH_SOP_PUSH_ABSOLUTE
- && info->value.X_op == O_constant);
-}
-
-int
-loongarch_parse_expr (const char *expr,
- struct reloc_info *reloc_stack_top,
- size_t max_reloc_num,
- size_t *reloc_num,
- offsetT *imm)
-{
- int ret;
- struct yy_buffer_state *buffstate;
- top = reloc_stack_top;
- end = top + max_reloc_num;
- buffstate = yy_scan_string (expr);
- ret = yyparse ();
-
- if (ret == 0)
- {
- if (is_const (top - 1))
- *imm = (--top)->value.X_add_number;
- else
- *imm = 0;
- *reloc_num = top - reloc_stack_top;
- }
- yy_delete_buffer (buffstate);
-
- return ret;
-}
-
-static void
-emit_const (offsetT imm)
-{
- if (end <= top)
- as_fatal (_("expr too huge"));
- top->type = BFD_RELOC_LARCH_SOP_PUSH_ABSOLUTE;
- top->value.X_op = O_constant;
- top->value.X_add_number = imm;
- top++;
-}
-
-static const char *
-my_getExpression (expressionS *ep, const char *str)
-{
- char *save_in, *ret;
-
- if (*str == ':')
- {
- unsigned long j;
- char *str_1 = (char *) str;
- j = strtol (str_1, &str_1, 10);
- get_internal_label (ep, j, *str_1 == 'f');
- return NULL;
- }
- save_in = input_line_pointer;
- input_line_pointer = (char *)str;
- expression (ep);
- ret = input_line_pointer;
- input_line_pointer = save_in;
- return ret;
-}
-
-static void
-emit_const_var (const char *op)
-{
- expressionS ep;
-
- if (end <= top)
- as_fatal (_("expr too huge"));
-
- my_getExpression (&ep, op);
-
- if (ep.X_op != O_constant)
- as_bad ("illegal operand: %s", op);
-
- top->value.X_op = O_constant;
- top->value.X_add_number = ep.X_add_number;
- top->type = BFD_RELOC_LARCH_SOP_PUSH_ABSOLUTE;
- top++;
-}
-
-static void
-reloc (const char *op_c_str, const char *id_c_str, offsetT addend)
-{
- expressionS id_sym_expr;
- bfd_reloc_code_real_type btype;
-
- if (end <= top)
- as_fatal (_("expr too huge"));
-
- /* For compatible old asm code. */
- if (0 == strcmp (op_c_str, "plt"))
- btype = BFD_RELOC_LARCH_B26;
- else
- btype = loongarch_larch_reloc_name_lookup (NULL, op_c_str);
-
- if (id_c_str)
- {
- my_getExpression (&id_sym_expr, id_c_str);
- id_sym_expr.X_add_number += addend;
- }
- else
- {
- id_sym_expr.X_op = O_constant;
- id_sym_expr.X_add_number = addend;
- }
-
- top->value = id_sym_expr;
- top->type = btype;
- top++;
-}
-
-static void
-emit_unary (char op)
-{
- struct reloc_info *s_top = top - 1;
- if (is_const (s_top))
- {
- offsetT opr = s_top->value.X_add_number;
- switch (op)
- {
- case '+':
- break;
- case '-':
- opr = -opr;
- break;
- case '~':
- opr = ~opr;
- break;
- case '!':
- opr = !opr;
- break;
- default:
- abort ();
- }
- s_top->value.X_add_number = opr;
- }
- else
- {
- if (end <= top)
- as_fatal (_("expr too huge"));
- switch (op)
- {
- case '!':
- top->type = BFD_RELOC_LARCH_SOP_NOT;
- break;
- default:
- abort ();
- }
- top->value = const_0;
- top++;
- }
-}
-
-static void
-emit_bin (int op)
-{
- struct reloc_info *last_1st = top - 1, *last_2nd = top - 2;
- if (is_const (last_1st) && is_const (last_2nd))
- {
- offsetT opr1 = last_2nd->value.X_add_number;
- offsetT opr2 = last_1st->value.X_add_number;
- switch (op)
- {
- case '*':
- opr1 = opr1 * opr2;
- break;
- case '/':
- opr1 = opr1 / opr2;
- break;
- case '%':
- opr1 = opr1 % opr2;
- break;
- case '+':
- opr1 = opr1 + opr2;
- break;
- case '-':
- opr1 = opr1 - opr2;
- break;
- case LEFT_OP:
- opr1 = opr1 << opr2;
- break;
- case RIGHT_OP:
- /* Algorithm right shift. */
- opr1 = (offsetT)opr1 >> (offsetT)opr2;
- break;
- case '<':
- opr1 = opr1 < opr2;
- break;
- case '>':
- opr1 = opr1 > opr2;
- break;
- case LE_OP:
- opr1 = opr1 <= opr2;
- break;
- case GE_OP:
- opr1 = opr1 >= opr2;
- break;
- case EQ_OP:
- opr1 = opr1 == opr2;
- break;
- case NE_OP:
- opr1 = opr1 != opr2;
- break;
- case '&':
- opr1 = opr1 & opr2;
- break;
- case '^':
- opr1 = opr1 ^ opr2;
- break;
- case '|':
- opr1 = opr1 | opr2;
- break;
- case AND_OP:
- opr1 = opr1 && opr2;
- break;
- case OR_OP:
- opr1 = opr1 || opr2;
- break;
- default:
- abort ();
- }
- last_2nd->value.X_add_number = opr1;
- last_1st->type = 0;
- top--;
- }
- else
- {
- if (end <= top)
- as_fatal (_("expr too huge"));
- switch (op)
- {
- case '+':
- top->type = BFD_RELOC_LARCH_SOP_ADD;
- break;
- case '-':
- top->type = BFD_RELOC_LARCH_SOP_SUB;
- break;
- case LEFT_OP:
- top->type = BFD_RELOC_LARCH_SOP_SL;
- break;
- case RIGHT_OP:
- top->type = BFD_RELOC_LARCH_SOP_SR;
- break;
- case '&':
- top->type = BFD_RELOC_LARCH_SOP_AND;
- break;
- default:
- abort ();
- }
- top->value = const_0;
- top++;
- }
-}
-
-static void
-emit_if_else (void)
-{
- struct reloc_info *last_1st = top - 1;
- struct reloc_info *last_2nd = top - 2;
- struct reloc_info *last_3rd = top - 3;
- if (is_const (last_1st) && is_const (last_2nd) && is_const (last_3rd))
- {
- offsetT opr1 = last_3rd->value.X_add_number;
- offsetT opr2 = last_2nd->value.X_add_number;
- offsetT opr3 = last_1st->value.X_add_number;
- opr1 = opr1 ? opr2 : opr3;
- last_3rd->value.X_add_number = opr1;
- last_2nd->type = 0;
- last_1st->type = 0;
- top -= 2;
- }
- else
- {
- if (end <= top)
- as_fatal (_("expr too huge"));
- top->type = BFD_RELOC_LARCH_SOP_IF_ELSE;
- top->value = const_0;
- top++;
- }
-}
-
-
-#line 377 "config/loongarch-parse.c"
-
-# ifndef YY_CAST
-# ifdef __cplusplus
-# define YY_CAST(Type, Val) static_cast<Type> (Val)
-# define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
-# else
-# define YY_CAST(Type, Val) ((Type) (Val))
-# define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
-# endif
-# endif
-# ifndef YY_NULLPTR
-# if defined __cplusplus
-# if 201103L <= __cplusplus
-# define YY_NULLPTR nullptr
-# else
-# define YY_NULLPTR 0
-# endif
-# else
-# define YY_NULLPTR ((void*)0)
-# endif
-# endif
-
-/* Use api.header.include to #include this header
- instead of duplicating it here. */
-#ifndef YY_YY_CONFIG_LOONGARCH_PARSE_H_INCLUDED
-# define YY_YY_CONFIG_LOONGARCH_PARSE_H_INCLUDED
-/* Debug traces. */
-#ifndef YYDEBUG
-# define YYDEBUG 0
-#endif
-#if YYDEBUG
-extern int yydebug;
-#endif
-
-/* Token kinds. */
-#ifndef YYTOKENTYPE
-# define YYTOKENTYPE
- enum yytokentype
- {
- YYEMPTY = -2,
- YYEOF = 0, /* "end of file" */
- YYerror = 256, /* error */
- YYUNDEF = 257, /* "invalid token" */
- INTEGER = 258, /* INTEGER */
- IDENTIFIER = 259, /* IDENTIFIER */
- LEFT_OP = 260, /* LEFT_OP */
- RIGHT_OP = 261, /* RIGHT_OP */
- LE_OP = 262, /* LE_OP */
- GE_OP = 263, /* GE_OP */
- EQ_OP = 264, /* EQ_OP */
- NE_OP = 265, /* NE_OP */
- AND_OP = 266, /* AND_OP */
- OR_OP = 267 /* OR_OP */
- };
- typedef enum yytokentype yytoken_kind_t;
-#endif
-/* Token kinds. */
-#define YYEMPTY -2
-#define YYEOF 0
-#define YYerror 256
-#define YYUNDEF 257
-#define INTEGER 258
-#define IDENTIFIER 259
-#define LEFT_OP 260
-#define RIGHT_OP 261
-#define LE_OP 262
-#define GE_OP 263
-#define EQ_OP 264
-#define NE_OP 265
-#define AND_OP 266
-#define OR_OP 267
-
-/* Value type. */
-#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
-union YYSTYPE
-{
-#line 325 "./config/loongarch-parse.y"
-
-char *c_str;
-offsetT imm;
-
-#line 459 "config/loongarch-parse.c"
-
-};
-typedef union YYSTYPE YYSTYPE;
-# define YYSTYPE_IS_TRIVIAL 1
-# define YYSTYPE_IS_DECLARED 1
-#endif
-
-
-extern YYSTYPE yylval;
-
-
-int yyparse (void);
-
-
-#endif /* !YY_YY_CONFIG_LOONGARCH_PARSE_H_INCLUDED */
-/* Symbol kind. */
-enum yysymbol_kind_t
-{
- YYSYMBOL_YYEMPTY = -2,
- YYSYMBOL_YYEOF = 0, /* "end of file" */
- YYSYMBOL_YYerror = 1, /* error */
- YYSYMBOL_YYUNDEF = 2, /* "invalid token" */
- YYSYMBOL_INTEGER = 3, /* INTEGER */
- YYSYMBOL_IDENTIFIER = 4, /* IDENTIFIER */
- YYSYMBOL_LEFT_OP = 5, /* LEFT_OP */
- YYSYMBOL_RIGHT_OP = 6, /* RIGHT_OP */
- YYSYMBOL_LE_OP = 7, /* LE_OP */
- YYSYMBOL_GE_OP = 8, /* GE_OP */
- YYSYMBOL_EQ_OP = 9, /* EQ_OP */
- YYSYMBOL_NE_OP = 10, /* NE_OP */
- YYSYMBOL_AND_OP = 11, /* AND_OP */
- YYSYMBOL_OR_OP = 12, /* OR_OP */
- YYSYMBOL_13_ = 13, /* '(' */
- YYSYMBOL_14_ = 14, /* ')' */
- YYSYMBOL_15_ = 15, /* '%' */
- YYSYMBOL_16_ = 16, /* '-' */
- YYSYMBOL_17_ = 17, /* '+' */
- YYSYMBOL_18_ = 18, /* '~' */
- YYSYMBOL_19_ = 19, /* '!' */
- YYSYMBOL_20_ = 20, /* '*' */
- YYSYMBOL_21_ = 21, /* '/' */
- YYSYMBOL_22_ = 22, /* '<' */
- YYSYMBOL_23_ = 23, /* '>' */
- YYSYMBOL_24_ = 24, /* '&' */
- YYSYMBOL_25_ = 25, /* '^' */
- YYSYMBOL_26_ = 26, /* '|' */
- YYSYMBOL_27_ = 27, /* '?' */
- YYSYMBOL_28_ = 28, /* ':' */
- YYSYMBOL_YYACCEPT = 29, /* $accept */
- YYSYMBOL_primary_expression = 30, /* primary_expression */
- YYSYMBOL_addend = 31, /* addend */
- YYSYMBOL_unary_expression = 32, /* unary_expression */
- YYSYMBOL_multiplicative_expression = 33, /* multiplicative_expression */
- YYSYMBOL_additive_expression = 34, /* additive_expression */
- YYSYMBOL_shift_expression = 35, /* shift_expression */
- YYSYMBOL_relational_expression = 36, /* relational_expression */
- YYSYMBOL_equality_expression = 37, /* equality_expression */
- YYSYMBOL_and_expression = 38, /* and_expression */
- YYSYMBOL_exclusive_or_expression = 39, /* exclusive_or_expression */
- YYSYMBOL_inclusive_or_expression = 40, /* inclusive_or_expression */
- YYSYMBOL_logical_and_expression = 41, /* logical_and_expression */
- YYSYMBOL_logical_or_expression = 42, /* logical_or_expression */
- YYSYMBOL_conditional_expression = 43, /* conditional_expression */
- YYSYMBOL_expression = 44 /* expression */
-};
-typedef enum yysymbol_kind_t yysymbol_kind_t;
-
-
-
-
-#ifdef short
-# undef short
-#endif
-
-/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
- <limits.h> and (if available) <stdint.h> are included
- so that the code can choose integer types of a good width. */
-
-#ifndef __PTRDIFF_MAX__
-# include <limits.h> /* INFRINGES ON USER NAME SPACE */
-# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
-# include <stdint.h> /* INFRINGES ON USER NAME SPACE */
-# define YY_STDINT_H
-# endif
-#endif
-
-/* Narrow types that promote to a signed type and that can represent a
- signed or unsigned integer of at least N bits. In tables they can
- save space and decrease cache pressure. Promoting to a signed type
- helps avoid bugs in integer arithmetic. */
-
-#ifdef __INT_LEAST8_MAX__
-typedef __INT_LEAST8_TYPE__ yytype_int8;
-#elif defined YY_STDINT_H
-typedef int_least8_t yytype_int8;
-#else
-typedef signed char yytype_int8;
-#endif
-
-#ifdef __INT_LEAST16_MAX__
-typedef __INT_LEAST16_TYPE__ yytype_int16;
-#elif defined YY_STDINT_H
-typedef int_least16_t yytype_int16;
-#else
-typedef short yytype_int16;
-#endif
-
-/* Work around bug in HP-UX 11.23, which defines these macros
- incorrectly for preprocessor constants. This workaround can likely
- be removed in 2023, as HPE has promised support for HP-UX 11.23
- (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of
- <https://h20195.www2.hpe.com/V2/getpdf.aspx/4AA4-7673ENW.pdf>. */
-#ifdef __hpux
-# undef UINT_LEAST8_MAX
-# undef UINT_LEAST16_MAX
-# define UINT_LEAST8_MAX 255
-# define UINT_LEAST16_MAX 65535
-#endif
-
-#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
-typedef __UINT_LEAST8_TYPE__ yytype_uint8;
-#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
- && UINT_LEAST8_MAX <= INT_MAX)
-typedef uint_least8_t yytype_uint8;
-#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
-typedef unsigned char yytype_uint8;
-#else
-typedef short yytype_uint8;
-#endif
-
-#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
-typedef __UINT_LEAST16_TYPE__ yytype_uint16;
-#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
- && UINT_LEAST16_MAX <= INT_MAX)
-typedef uint_least16_t yytype_uint16;
-#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
-typedef unsigned short yytype_uint16;
-#else
-typedef int yytype_uint16;
-#endif
-
-#ifndef YYPTRDIFF_T
-# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
-# define YYPTRDIFF_T __PTRDIFF_TYPE__
-# define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
-# elif defined PTRDIFF_MAX
-# ifndef ptrdiff_t
-# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
-# endif
-# define YYPTRDIFF_T ptrdiff_t
-# define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
-# else
-# define YYPTRDIFF_T long
-# define YYPTRDIFF_MAXIMUM LONG_MAX
-# endif
-#endif
-
-#ifndef YYSIZE_T
-# ifdef __SIZE_TYPE__
-# define YYSIZE_T __SIZE_TYPE__
-# elif defined size_t
-# define YYSIZE_T size_t
-# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
-# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
-# define YYSIZE_T size_t
-# else
-# define YYSIZE_T unsigned
-# endif
-#endif
-
-#define YYSIZE_MAXIMUM \
- YY_CAST (YYPTRDIFF_T, \
- (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \
- ? YYPTRDIFF_MAXIMUM \
- : YY_CAST (YYSIZE_T, -1)))
-
-#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
-
-
-/* Stored state numbers (used for stacks). */
-typedef yytype_int8 yy_state_t;
-
-/* State numbers in computations. */
-typedef int yy_state_fast_t;
-
-#ifndef YY_
-# if defined YYENABLE_NLS && YYENABLE_NLS
-# if ENABLE_NLS
-# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
-# define YY_(Msgid) dgettext ("bison-runtime", Msgid)
-# endif
-# endif
-# ifndef YY_
-# define YY_(Msgid) Msgid
-# endif
-#endif
-
-
-#ifndef YY_ATTRIBUTE_PURE
-# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
-# define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
-# else
-# define YY_ATTRIBUTE_PURE
-# endif
-#endif
-
-#ifndef YY_ATTRIBUTE_UNUSED
-# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
-# define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
-# else
-# define YY_ATTRIBUTE_UNUSED
-# endif
-#endif
-
-/* Suppress unused-variable warnings by "using" E. */
-#if ! defined lint || defined __GNUC__
-# define YY_USE(E) ((void) (E))
-#else
-# define YY_USE(E) /* empty */
-#endif
-
-/* Suppress an incorrect diagnostic about yylval being uninitialized. */
-#if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__
-# if __GNUC__ * 100 + __GNUC_MINOR__ < 407
-# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
- _Pragma ("GCC diagnostic push") \
- _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")
-# else
-# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
- _Pragma ("GCC diagnostic push") \
- _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
- _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
-# endif
-# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
- _Pragma ("GCC diagnostic pop")
-#else
-# define YY_INITIAL_VALUE(Value) Value
-#endif
-#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
-# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
-# define YY_IGNORE_MAYBE_UNINITIALIZED_END
-#endif
-#ifndef YY_INITIAL_VALUE
-# define YY_INITIAL_VALUE(Value) /* Nothing. */
-#endif
-
-#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
-# define YY_IGNORE_USELESS_CAST_BEGIN \
- _Pragma ("GCC diagnostic push") \
- _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
-# define YY_IGNORE_USELESS_CAST_END \
- _Pragma ("GCC diagnostic pop")
-#endif
-#ifndef YY_IGNORE_USELESS_CAST_BEGIN
-# define YY_IGNORE_USELESS_CAST_BEGIN
-# define YY_IGNORE_USELESS_CAST_END
-#endif
-
-
-#define YY_ASSERT(E) ((void) (0 && (E)))
-
-#if !defined yyoverflow
-
-/* The parser invokes alloca or malloc; define the necessary symbols. */
-
-# ifdef YYSTACK_USE_ALLOCA
-# if YYSTACK_USE_ALLOCA
-# ifdef __GNUC__
-# define YYSTACK_ALLOC __builtin_alloca
-# elif defined __BUILTIN_VA_ARG_INCR
-# include <alloca.h> /* INFRINGES ON USER NAME SPACE */
-# elif defined _AIX
-# define YYSTACK_ALLOC __alloca
-# elif defined _MSC_VER
-# include <malloc.h> /* INFRINGES ON USER NAME SPACE */
-# define alloca _alloca
-# else
-# define YYSTACK_ALLOC alloca
-# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
-# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
- /* Use EXIT_SUCCESS as a witness for stdlib.h. */
-# ifndef EXIT_SUCCESS
-# define EXIT_SUCCESS 0
-# endif
-# endif
-# endif
-# endif
-# endif
-
-# ifdef YYSTACK_ALLOC
- /* Pacify GCC's 'empty if-body' warning. */
-# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
-# ifndef YYSTACK_ALLOC_MAXIMUM
- /* The OS might guarantee only one guard page at the bottom of the stack,
- and a page size can be as small as 4096 bytes. So we cannot safely
- invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
- to allow for a few compiler-allocated temporary stack slots. */
-# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
-# endif
-# else
-# define YYSTACK_ALLOC YYMALLOC
-# define YYSTACK_FREE YYFREE
-# ifndef YYSTACK_ALLOC_MAXIMUM
-# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
-# endif
-# if (defined __cplusplus && ! defined EXIT_SUCCESS \
- && ! ((defined YYMALLOC || defined malloc) \
- && (defined YYFREE || defined free)))
-# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
-# ifndef EXIT_SUCCESS
-# define EXIT_SUCCESS 0
-# endif
-# endif
-# ifndef YYMALLOC
-# define YYMALLOC malloc
-# if ! defined malloc && ! defined EXIT_SUCCESS
-void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
-# endif
-# endif
-# ifndef YYFREE
-# define YYFREE free
-# if ! defined free && ! defined EXIT_SUCCESS
-void free (void *); /* INFRINGES ON USER NAME SPACE */
-# endif
-# endif
-# endif
-#endif /* !defined yyoverflow */
-
-#if (! defined yyoverflow \
- && (! defined __cplusplus \
- || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
-
-/* A type that is properly aligned for any stack member. */
-union yyalloc
-{
- yy_state_t yyss_alloc;
- YYSTYPE yyvs_alloc;
-};
-
-/* The size of the maximum gap between one aligned stack and the next. */
-# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
-
-/* The size of an array large to enough to hold all stacks, each with
- N elements. */
-# define YYSTACK_BYTES(N) \
- ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \
- + YYSTACK_GAP_MAXIMUM)
-
-# define YYCOPY_NEEDED 1
-
-/* Relocate STACK from its old location to the new one. The
- local variables YYSIZE and YYSTACKSIZE give the old and new number of
- elements in the stack, and YYPTR gives the new location of the
- stack. Advance YYPTR to a properly aligned location for the next
- stack. */
-# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
- do \
- { \
- YYPTRDIFF_T yynewbytes; \
- YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
- Stack = &yyptr->Stack_alloc; \
- yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
- yyptr += yynewbytes / YYSIZEOF (*yyptr); \
- } \
- while (0)
-
-#endif
-
-#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
-/* Copy COUNT objects from SRC to DST. The source and destination do
- not overlap. */
-# ifndef YYCOPY
-# if defined __GNUC__ && 1 < __GNUC__
-# define YYCOPY(Dst, Src, Count) \
- __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
-# else
-# define YYCOPY(Dst, Src, Count) \
- do \
- { \
- YYPTRDIFF_T yyi; \
- for (yyi = 0; yyi < (Count); yyi++) \
- (Dst)[yyi] = (Src)[yyi]; \
- } \
- while (0)
-# endif
-# endif
-#endif /* !YYCOPY_NEEDED */
-
-/* YYFINAL -- State number of the termination state. */
-#define YYFINAL 48
-/* YYLAST -- Last index in YYTABLE. */
-#define YYLAST 74
-
-/* YYNTOKENS -- Number of terminals. */
-#define YYNTOKENS 29
-/* YYNNTS -- Number of nonterminals. */
-#define YYNNTS 16
-/* YYNRULES -- Number of rules. */
-#define YYNRULES 45
-/* YYNSTATES -- Number of states. */
-#define YYNSTATES 82
-
-/* YYMAXUTOK -- Last valid token kind. */
-#define YYMAXUTOK 267
-
-
-/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
- as returned by yylex, with out-of-bounds checking. */
-#define YYTRANSLATE(YYX) \
- (0 <= (YYX) && (YYX) <= YYMAXUTOK \
- ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \
- : YYSYMBOL_YYUNDEF)
-
-/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
- as returned by yylex. */
-static const yytype_int8 yytranslate[] =
-{
- 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 19, 2, 2, 2, 15, 24, 2,
- 13, 14, 20, 17, 2, 16, 2, 21, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 28, 2,
- 22, 2, 23, 27, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 25, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 26, 2, 18, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
- 5, 6, 7, 8, 9, 10, 11, 12
-};
-
-#if YYDEBUG
-/* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
-static const yytype_int16 yyrline[] =
-{
- 0, 339, 339, 340, 341, 342, 343, 347, 348, 349,
- 353, 354, 355, 356, 357, 361, 362, 363, 364, 368,
- 369, 370, 374, 375, 376, 380, 381, 382, 383, 384,
- 388, 389, 390, 394, 395, 399, 400, 404, 405, 409,
- 410, 414, 415, 419, 420, 424
-};
-#endif
-
-/** Accessing symbol of state STATE. */
-#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State])
-
-#if YYDEBUG || 0
-/* The user-facing name of the symbol whose (internal) number is
- YYSYMBOL. No bounds checking. */
-static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED;
-
-/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
- First, the terminals, then, starting at YYNTOKENS, nonterminals. */
-static const char *const yytname[] =
-{
- "\"end of file\"", "error", "\"invalid token\"", "INTEGER",
- "IDENTIFIER", "LEFT_OP", "RIGHT_OP", "LE_OP", "GE_OP", "EQ_OP", "NE_OP",
- "AND_OP", "OR_OP", "'('", "')'", "'%'", "'-'", "'+'", "'~'", "'!'",
- "'*'", "'/'", "'<'", "'>'", "'&'", "'^'", "'|'", "'?'", "':'", "$accept",
- "primary_expression", "addend", "unary_expression",
- "multiplicative_expression", "additive_expression", "shift_expression",
- "relational_expression", "equality_expression", "and_expression",
- "exclusive_or_expression", "inclusive_or_expression",
- "logical_and_expression", "logical_or_expression",
- "conditional_expression", "expression", YY_NULLPTR
-};
-
-static const char *
-yysymbol_name (yysymbol_kind_t yysymbol)
-{
- return yytname[yysymbol];
-}
-#endif
-
-#define YYPACT_NINF (-28)
-
-#define yypact_value_is_default(Yyn) \
- ((Yyn) == YYPACT_NINF)
-
-#define YYTABLE_NINF (-1)
-
-#define yytable_value_is_error(Yyn) \
- 0
-
-/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
- STATE-NUM. */
-static const yytype_int8 yypact[] =
-{
- 2, -28, -28, 2, 10, 2, 2, 2, 2, -28,
- -28, 9, 23, 36, 0, 37, -8, 7, 26, 25,
- 1, -28, 43, 31, 44, -28, -28, -28, -28, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, -28, -28,
- 45, -28, -28, -28, 9, 9, 23, 23, 36, 36,
- 36, 36, 0, 0, 37, -8, 7, 26, 25, 30,
- -28, -28, 2, 17, 21, -28, -28, 56, 57, -28,
- -28, -28
-};
-
-/* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
- Performed when YYTABLE does not specify something else to do. Zero
- means the default is an error. */
-static const yytype_int8 yydefact[] =
-{
- 0, 2, 3, 0, 0, 0, 0, 0, 0, 10,
- 15, 19, 22, 25, 30, 33, 35, 37, 39, 41,
- 43, 45, 0, 0, 0, 12, 11, 13, 14, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 1, 4,
- 0, 18, 16, 17, 21, 20, 23, 24, 28, 29,
- 26, 27, 31, 32, 34, 36, 38, 40, 42, 0,
- 9, 9, 0, 0, 0, 44, 6, 0, 0, 5,
- 7, 8
-};
-
-/* YYPGOTO[NTERM-NUM]. */
-static const yytype_int8 yypgoto[] =
-{
- -28, -28, -10, -4, 18, 19, -27, 15, 20, 22,
- 24, 27, 28, -28, -9, -3
-};
-
-/* YYDEFGOTO[NTERM-NUM]. */
-static const yytype_int8 yydefgoto[] =
-{
- 0, 9, 73, 10, 11, 12, 13, 14, 15, 16,
- 17, 18, 19, 20, 21, 22
-};
-
-/* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
- positive, shift that token. If negative, reduce the rule whose
- number is the opposite. If YYTABLE_NINF, syntax error. */
-static const yytype_int8 yytable[] =
-{
- 23, 25, 26, 27, 28, 1, 2, 36, 37, 58,
- 59, 60, 61, 46, 24, 3, 42, 4, 5, 6,
- 7, 8, 38, 39, 29, 51, 52, 53, 47, 30,
- 31, 76, 43, 77, 78, 79, 45, 77, 78, 32,
- 33, 34, 35, 48, 69, 49, 40, 41, 70, 71,
- 54, 55, 44, 56, 57, 62, 63, 50, 72, 80,
- 81, 74, 64, 75, 0, 65, 0, 0, 66, 0,
- 0, 0, 67, 0, 68
-};
-
-static const yytype_int8 yycheck[] =
-{
- 3, 5, 6, 7, 8, 3, 4, 7, 8, 36,
- 37, 38, 39, 12, 4, 13, 24, 15, 16, 17,
- 18, 19, 22, 23, 15, 29, 30, 31, 27, 20,
- 21, 14, 25, 16, 17, 14, 11, 16, 17, 16,
- 17, 5, 6, 0, 47, 14, 9, 10, 3, 4,
- 32, 33, 26, 34, 35, 40, 41, 13, 28, 3,
- 3, 71, 42, 72, -1, 43, -1, -1, 44, -1,
- -1, -1, 45, -1, 46
-};
-
-/* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of
- state STATE-NUM. */
-static const yytype_int8 yystos[] =
-{
- 0, 3, 4, 13, 15, 16, 17, 18, 19, 30,
- 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
- 42, 43, 44, 44, 4, 32, 32, 32, 32, 15,
- 20, 21, 16, 17, 5, 6, 7, 8, 22, 23,
- 9, 10, 24, 25, 26, 11, 12, 27, 0, 14,
- 13, 32, 32, 32, 33, 33, 34, 34, 35, 35,
- 35, 35, 36, 36, 37, 38, 39, 40, 41, 44,
- 3, 4, 28, 31, 31, 43, 14, 16, 17, 14,
- 3, 3
-};
-
-/* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM. */
-static const yytype_int8 yyr1[] =
-{
- 0, 29, 30, 30, 30, 30, 30, 31, 31, 31,
- 32, 32, 32, 32, 32, 33, 33, 33, 33, 34,
- 34, 34, 35, 35, 35, 36, 36, 36, 36, 36,
- 37, 37, 37, 38, 38, 39, 39, 40, 40, 41,
- 41, 42, 42, 43, 43, 44
-};
-
-/* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM. */
-static const yytype_int8 yyr2[] =
-{
- 0, 2, 1, 1, 3, 6, 6, 3, 3, 0,
- 1, 2, 2, 2, 2, 1, 3, 3, 3, 1,
- 3, 3, 1, 3, 3, 1, 3, 3, 3, 3,
- 1, 3, 3, 1, 3, 1, 3, 1, 3, 1,
- 3, 1, 3, 1, 5, 1
-};
-
-
-enum { YYENOMEM = -2 };
-
-#define yyerrok (yyerrstatus = 0)
-#define yyclearin (yychar = YYEMPTY)
-
-#define YYACCEPT goto yyacceptlab
-#define YYABORT goto yyabortlab
-#define YYERROR goto yyerrorlab
-#define YYNOMEM goto yyexhaustedlab
-
-
-#define YYRECOVERING() (!!yyerrstatus)
-
-#define YYBACKUP(Token, Value) \
- do \
- if (yychar == YYEMPTY) \
- { \
- yychar = (Token); \
- yylval = (Value); \
- YYPOPSTACK (yylen); \
- yystate = *yyssp; \
- goto yybackup; \
- } \
- else \
- { \
- yyerror (YY_("syntax error: cannot back up")); \
- YYERROR; \
- } \
- while (0)
-
-/* Backward compatibility with an undocumented macro.
- Use YYerror or YYUNDEF. */
-#define YYERRCODE YYUNDEF
-
-
-/* Enable debugging if requested. */
-#if YYDEBUG
-
-# ifndef YYFPRINTF
-# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
-# define YYFPRINTF fprintf
-# endif
-
-# define YYDPRINTF(Args) \
-do { \
- if (yydebug) \
- YYFPRINTF Args; \
-} while (0)
-
-
-
-
-# define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \
-do { \
- if (yydebug) \
- { \
- YYFPRINTF (stderr, "%s ", Title); \
- yy_symbol_print (stderr, \
- Kind, Value); \
- YYFPRINTF (stderr, "\n"); \
- } \
-} while (0)
-
-
-/*-----------------------------------.
-| Print this symbol's value on YYO. |
-`-----------------------------------*/
-
-static void
-yy_symbol_value_print (FILE *yyo,
- yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep)
-{
- FILE *yyoutput = yyo;
- YY_USE (yyoutput);
- if (!yyvaluep)
- return;
- YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
- YY_USE (yykind);
- YY_IGNORE_MAYBE_UNINITIALIZED_END
-}
-
-
-/*---------------------------.
-| Print this symbol on YYO. |
-`---------------------------*/
-
-static void
-yy_symbol_print (FILE *yyo,
- yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep)
-{
- YYFPRINTF (yyo, "%s %s (",
- yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind));
-
- yy_symbol_value_print (yyo, yykind, yyvaluep);
- YYFPRINTF (yyo, ")");
-}
-
-/*------------------------------------------------------------------.
-| yy_stack_print -- Print the state stack from its BOTTOM up to its |
-| TOP (included). |
-`------------------------------------------------------------------*/
-
-static void
-yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
-{
- YYFPRINTF (stderr, "Stack now");
- for (; yybottom <= yytop; yybottom++)
- {
- int yybot = *yybottom;
- YYFPRINTF (stderr, " %d", yybot);
- }
- YYFPRINTF (stderr, "\n");
-}
-
-# define YY_STACK_PRINT(Bottom, Top) \
-do { \
- if (yydebug) \
- yy_stack_print ((Bottom), (Top)); \
-} while (0)
-
-
-/*------------------------------------------------.
-| Report that the YYRULE is going to be reduced. |
-`------------------------------------------------*/
-
-static void
-yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp,
- int yyrule)
-{
- int yylno = yyrline[yyrule];
- int yynrhs = yyr2[yyrule];
- int yyi;
- YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
- yyrule - 1, yylno);
- /* The symbols being reduced. */
- for (yyi = 0; yyi < yynrhs; yyi++)
- {
- YYFPRINTF (stderr, " $%d = ", yyi + 1);
- yy_symbol_print (stderr,
- YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]),
- &yyvsp[(yyi + 1) - (yynrhs)]);
- YYFPRINTF (stderr, "\n");
- }
-}
-
-# define YY_REDUCE_PRINT(Rule) \
-do { \
- if (yydebug) \
- yy_reduce_print (yyssp, yyvsp, Rule); \
-} while (0)
-
-/* Nonzero means print parse trace. It is left uninitialized so that
- multiple parsers can coexist. */
-int yydebug;
-#else /* !YYDEBUG */
-# define YYDPRINTF(Args) ((void) 0)
-# define YY_SYMBOL_PRINT(Title, Kind, Value, Location)
-# define YY_STACK_PRINT(Bottom, Top)
-# define YY_REDUCE_PRINT(Rule)
-#endif /* !YYDEBUG */
-
-
-/* YYINITDEPTH -- initial size of the parser's stacks. */
-#ifndef YYINITDEPTH
-# define YYINITDEPTH 200
-#endif
-
-/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
- if the built-in stack extension method is used).
-
- Do not make this value too large; the results are undefined if
- YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
- evaluated with infinite-precision integer arithmetic. */
-
-#ifndef YYMAXDEPTH
-# define YYMAXDEPTH 10000
-#endif
-
-
-
-
-
-
-/*-----------------------------------------------.
-| Release the memory associated to this symbol. |
-`-----------------------------------------------*/
-
-static void
-yydestruct (const char *yymsg,
- yysymbol_kind_t yykind, YYSTYPE *yyvaluep)
-{
- YY_USE (yyvaluep);
- if (!yymsg)
- yymsg = "Deleting";
- YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp);
-
- YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
- YY_USE (yykind);
- YY_IGNORE_MAYBE_UNINITIALIZED_END
-}
-
-
-/* Lookahead token kind. */
-int yychar;
-
-/* The semantic value of the lookahead symbol. */
-YYSTYPE yylval;
-/* Number of syntax errors so far. */
-int yynerrs;
-
-
-
-
-/*----------.
-| yyparse. |
-`----------*/
-
-int
-yyparse (void)
-{
- yy_state_fast_t yystate = 0;
- /* Number of tokens to shift before error messages enabled. */
- int yyerrstatus = 0;
-
- /* Refer to the stacks through separate pointers, to allow yyoverflow
- to reallocate them elsewhere. */
-
- /* Their size. */
- YYPTRDIFF_T yystacksize = YYINITDEPTH;
-
- /* The state stack: array, bottom, top. */
- yy_state_t yyssa[YYINITDEPTH];
- yy_state_t *yyss = yyssa;
- yy_state_t *yyssp = yyss;
-
- /* The semantic value stack: array, bottom, top. */
- YYSTYPE yyvsa[YYINITDEPTH];
- YYSTYPE *yyvs = yyvsa;
- YYSTYPE *yyvsp = yyvs;
-
- int yyn;
- /* The return value of yyparse. */
- int yyresult;
- /* Lookahead symbol kind. */
- yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY;
- /* The variables used to return semantic value and location from the
- action routines. */
- YYSTYPE yyval;
-
-
-
-#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
-
- /* The number of symbols on the RHS of the reduced rule.
- Keep to zero when no symbol should be popped. */
- int yylen = 0;
-
- YYDPRINTF ((stderr, "Starting parse\n"));
-
- yychar = YYEMPTY; /* Cause a token to be read. */
-
- goto yysetstate;
-
-
-/*------------------------------------------------------------.
-| yynewstate -- push a new state, which is found in yystate. |
-`------------------------------------------------------------*/
-yynewstate:
- /* In all cases, when you get here, the value and location stacks
- have just been pushed. So pushing a state here evens the stacks. */
- yyssp++;
-
-
-/*--------------------------------------------------------------------.
-| yysetstate -- set current state (the top of the stack) to yystate. |
-`--------------------------------------------------------------------*/
-yysetstate:
- YYDPRINTF ((stderr, "Entering state %d\n", yystate));
- YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
- YY_IGNORE_USELESS_CAST_BEGIN
- *yyssp = YY_CAST (yy_state_t, yystate);
- YY_IGNORE_USELESS_CAST_END
- YY_STACK_PRINT (yyss, yyssp);
-
- if (yyss + yystacksize - 1 <= yyssp)
-#if !defined yyoverflow && !defined YYSTACK_RELOCATE
- YYNOMEM;
-#else
- {
- /* Get the current used size of the three stacks, in elements. */
- YYPTRDIFF_T yysize = yyssp - yyss + 1;
-
-# if defined yyoverflow
- {
- /* Give user a chance to reallocate the stack. Use copies of
- these so that the &'s don't force the real ones into
- memory. */
- yy_state_t *yyss1 = yyss;
- YYSTYPE *yyvs1 = yyvs;
-
- /* Each stack pointer address is followed by the size of the
- data in use in that stack, in bytes. This used to be a
- conditional around just the two extra args, but that might
- be undefined if yyoverflow is a macro. */
- yyoverflow (YY_("memory exhausted"),
- &yyss1, yysize * YYSIZEOF (*yyssp),
- &yyvs1, yysize * YYSIZEOF (*yyvsp),
- &yystacksize);
- yyss = yyss1;
- yyvs = yyvs1;
- }
-# else /* defined YYSTACK_RELOCATE */
- /* Extend the stack our own way. */
- if (YYMAXDEPTH <= yystacksize)
- YYNOMEM;
- yystacksize *= 2;
- if (YYMAXDEPTH < yystacksize)
- yystacksize = YYMAXDEPTH;
-
- {
- yy_state_t *yyss1 = yyss;
- union yyalloc *yyptr =
- YY_CAST (union yyalloc *,
- YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
- if (! yyptr)
- YYNOMEM;
- YYSTACK_RELOCATE (yyss_alloc, yyss);
- YYSTACK_RELOCATE (yyvs_alloc, yyvs);
-# undef YYSTACK_RELOCATE
- if (yyss1 != yyssa)
- YYSTACK_FREE (yyss1);
- }
-# endif
-
- yyssp = yyss + yysize - 1;
- yyvsp = yyvs + yysize - 1;
-
- YY_IGNORE_USELESS_CAST_BEGIN
- YYDPRINTF ((stderr, "Stack size increased to %ld\n",
- YY_CAST (long, yystacksize)));
- YY_IGNORE_USELESS_CAST_END
-
- if (yyss + yystacksize - 1 <= yyssp)
- YYABORT;
- }
-#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
-
-
- if (yystate == YYFINAL)
- YYACCEPT;
-
- goto yybackup;
-
-
-/*-----------.
-| yybackup. |
-`-----------*/
-yybackup:
- /* Do appropriate processing given the current state. Read a
- lookahead token if we need one and don't already have one. */
-
- /* First try to decide what to do without reference to lookahead token. */
- yyn = yypact[yystate];
- if (yypact_value_is_default (yyn))
- goto yydefault;
-
- /* Not known => get a lookahead token if don't already have one. */
-
- /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */
- if (yychar == YYEMPTY)
- {
- YYDPRINTF ((stderr, "Reading a token\n"));
- yychar = yylex ();
- }
-
- if (yychar <= YYEOF)
- {
- yychar = YYEOF;
- yytoken = YYSYMBOL_YYEOF;
- YYDPRINTF ((stderr, "Now at end of input.\n"));
- }
- else if (yychar == YYerror)
- {
- /* The scanner already issued an error message, process directly
- to error recovery. But do not keep the error token as
- lookahead, it is too special and may lead us to an endless
- loop in error recovery. */
- yychar = YYUNDEF;
- yytoken = YYSYMBOL_YYerror;
- goto yyerrlab1;
- }
- else
- {
- yytoken = YYTRANSLATE (yychar);
- YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
- }
-
- /* If the proper action on seeing token YYTOKEN is to reduce or to
- detect an error, take that action. */
- yyn += yytoken;
- if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
- goto yydefault;
- yyn = yytable[yyn];
- if (yyn <= 0)
- {
- if (yytable_value_is_error (yyn))
- goto yyerrlab;
- yyn = -yyn;
- goto yyreduce;
- }
-
- /* Count tokens shifted since error; after three, turn off error
- status. */
- if (yyerrstatus)
- yyerrstatus--;
-
- /* Shift the lookahead token. */
- YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
- yystate = yyn;
- YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
- *++yyvsp = yylval;
- YY_IGNORE_MAYBE_UNINITIALIZED_END
-
- /* Discard the shifted token. */
- yychar = YYEMPTY;
- goto yynewstate;
-
-
-/*-----------------------------------------------------------.
-| yydefault -- do the default action for the current state. |
-`-----------------------------------------------------------*/
-yydefault:
- yyn = yydefact[yystate];
- if (yyn == 0)
- goto yyerrlab;
- goto yyreduce;
-
-
-/*-----------------------------.
-| yyreduce -- do a reduction. |
-`-----------------------------*/
-yyreduce:
- /* yyn is the number of a rule to reduce with. */
- yylen = yyr2[yyn];
-
- /* If YYLEN is nonzero, implement the default value of the action:
- '$$ = $1'.
-
- Otherwise, the following line sets YYVAL to garbage.
- This behavior is undocumented and Bison
- users should not rely upon it. Assigning to YYVAL
- unconditionally makes the parser a bit smaller, and it avoids a
- GCC warning that YYVAL may be used uninitialized. */
- yyval = yyvsp[1-yylen];
-
-
- YY_REDUCE_PRINT (yyn);
- switch (yyn)
- {
- case 2: /* primary_expression: INTEGER */
-#line 339 "./config/loongarch-parse.y"
- {emit_const ((yyvsp[0].imm));}
-#line 1529 "config/loongarch-parse.c"
- break;
-
- case 3: /* primary_expression: IDENTIFIER */
-#line 340 "./config/loongarch-parse.y"
- {emit_const_var ((yyvsp[0].c_str));}
-#line 1535 "config/loongarch-parse.c"
- break;
-
- case 5: /* primary_expression: '%' IDENTIFIER '(' IDENTIFIER addend ')' */
-#line 342 "./config/loongarch-parse.y"
- {reloc ((yyvsp[-4].c_str), (yyvsp[-2].c_str), (yyvsp[-1].imm)); free ((yyvsp[-4].c_str)); free ((yyvsp[-2].c_str));}
-#line 1541 "config/loongarch-parse.c"
- break;
-
- case 6: /* primary_expression: '%' IDENTIFIER '(' INTEGER addend ')' */
-#line 343 "./config/loongarch-parse.y"
- {reloc ((yyvsp[-4].c_str), NULL, (yyvsp[-2].imm) + (yyvsp[-1].imm)); free ((yyvsp[-4].c_str));}
-#line 1547 "config/loongarch-parse.c"
- break;
-
- case 7: /* addend: addend '-' INTEGER */
-#line 347 "./config/loongarch-parse.y"
- {(yyval.imm) -= (yyvsp[0].imm);}
-#line 1553 "config/loongarch-parse.c"
- break;
-
- case 8: /* addend: addend '+' INTEGER */
-#line 348 "./config/loongarch-parse.y"
- {(yyval.imm) += (yyvsp[0].imm);}
-#line 1559 "config/loongarch-parse.c"
- break;
-
- case 9: /* addend: %empty */
-#line 349 "./config/loongarch-parse.y"
- {(yyval.imm) = 0;}
-#line 1565 "config/loongarch-parse.c"
- break;
-
- case 11: /* unary_expression: '+' unary_expression */
-#line 354 "./config/loongarch-parse.y"
- {emit_unary ('+');}
-#line 1571 "config/loongarch-parse.c"
- break;
-
- case 12: /* unary_expression: '-' unary_expression */
-#line 355 "./config/loongarch-parse.y"
- {emit_unary ('-');}
-#line 1577 "config/loongarch-parse.c"
- break;
-
- case 13: /* unary_expression: '~' unary_expression */
-#line 356 "./config/loongarch-parse.y"
- {emit_unary ('~');}
-#line 1583 "config/loongarch-parse.c"
- break;
-
- case 14: /* unary_expression: '!' unary_expression */
-#line 357 "./config/loongarch-parse.y"
- {emit_unary ('!');}
-#line 1589 "config/loongarch-parse.c"
- break;
-
- case 16: /* multiplicative_expression: multiplicative_expression '*' unary_expression */
-#line 362 "./config/loongarch-parse.y"
- {emit_bin ('*');}
-#line 1595 "config/loongarch-parse.c"
- break;
-
- case 17: /* multiplicative_expression: multiplicative_expression '/' unary_expression */
-#line 363 "./config/loongarch-parse.y"
- {emit_bin ('/');}
-#line 1601 "config/loongarch-parse.c"
- break;
-
- case 18: /* multiplicative_expression: multiplicative_expression '%' unary_expression */
-#line 364 "./config/loongarch-parse.y"
- {emit_bin ('%');}
-#line 1607 "config/loongarch-parse.c"
- break;
-
- case 20: /* additive_expression: additive_expression '+' multiplicative_expression */
-#line 369 "./config/loongarch-parse.y"
- {emit_bin ('+');}
-#line 1613 "config/loongarch-parse.c"
- break;
-
- case 21: /* additive_expression: additive_expression '-' multiplicative_expression */
-#line 370 "./config/loongarch-parse.y"
- {emit_bin ('-');}
-#line 1619 "config/loongarch-parse.c"
- break;
-
- case 23: /* shift_expression: shift_expression LEFT_OP additive_expression */
-#line 375 "./config/loongarch-parse.y"
- {emit_bin (LEFT_OP);}
-#line 1625 "config/loongarch-parse.c"
- break;
-
- case 24: /* shift_expression: shift_expression RIGHT_OP additive_expression */
-#line 376 "./config/loongarch-parse.y"
- {emit_bin (RIGHT_OP);}
-#line 1631 "config/loongarch-parse.c"
- break;
-
- case 26: /* relational_expression: relational_expression '<' shift_expression */
-#line 381 "./config/loongarch-parse.y"
- {emit_bin ('<');}
-#line 1637 "config/loongarch-parse.c"
- break;
-
- case 27: /* relational_expression: relational_expression '>' shift_expression */
-#line 382 "./config/loongarch-parse.y"
- {emit_bin ('>');}
-#line 1643 "config/loongarch-parse.c"
- break;
-
- case 28: /* relational_expression: relational_expression LE_OP shift_expression */
-#line 383 "./config/loongarch-parse.y"
- {emit_bin (LE_OP);}
-#line 1649 "config/loongarch-parse.c"
- break;
-
- case 29: /* relational_expression: relational_expression GE_OP shift_expression */
-#line 384 "./config/loongarch-parse.y"
- {emit_bin (GE_OP);}
-#line 1655 "config/loongarch-parse.c"
- break;
-
- case 31: /* equality_expression: equality_expression EQ_OP relational_expression */
-#line 389 "./config/loongarch-parse.y"
- {emit_bin (EQ_OP);}
-#line 1661 "config/loongarch-parse.c"
- break;
-
- case 32: /* equality_expression: equality_expression NE_OP relational_expression */
-#line 390 "./config/loongarch-parse.y"
- {emit_bin (NE_OP);}
-#line 1667 "config/loongarch-parse.c"
- break;
-
- case 34: /* and_expression: and_expression '&' equality_expression */
-#line 395 "./config/loongarch-parse.y"
- {emit_bin ('&');}
-#line 1673 "config/loongarch-parse.c"
- break;
-
- case 36: /* exclusive_or_expression: exclusive_or_expression '^' and_expression */
-#line 400 "./config/loongarch-parse.y"
- {emit_bin ('^');}
-#line 1679 "config/loongarch-parse.c"
- break;
-
- case 38: /* inclusive_or_expression: inclusive_or_expression '|' exclusive_or_expression */
-#line 405 "./config/loongarch-parse.y"
- {emit_bin ('|');}
-#line 1685 "config/loongarch-parse.c"
- break;
-
- case 40: /* logical_and_expression: logical_and_expression AND_OP inclusive_or_expression */
-#line 410 "./config/loongarch-parse.y"
- {emit_bin (AND_OP);}
-#line 1691 "config/loongarch-parse.c"
- break;
-
- case 42: /* logical_or_expression: logical_or_expression OR_OP logical_and_expression */
-#line 415 "./config/loongarch-parse.y"
- {emit_bin (OR_OP);}
-#line 1697 "config/loongarch-parse.c"
- break;
-
- case 44: /* conditional_expression: logical_or_expression '?' expression ':' conditional_expression */
-#line 420 "./config/loongarch-parse.y"
- {emit_if_else ();}
-#line 1703 "config/loongarch-parse.c"
- break;
-
-
-#line 1707 "config/loongarch-parse.c"
-
- default: break;
- }
- /* User semantic actions sometimes alter yychar, and that requires
- that yytoken be updated with the new translation. We take the
- approach of translating immediately before every use of yytoken.
- One alternative is translating here after every semantic action,
- but that translation would be missed if the semantic action invokes
- YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
- if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
- incorrect destructor might then be invoked immediately. In the
- case of YYERROR or YYBACKUP, subsequent parser actions might lead
- to an incorrect destructor call or verbose syntax error message
- before the lookahead is translated. */
- YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc);
-
- YYPOPSTACK (yylen);
- yylen = 0;
-
- *++yyvsp = yyval;
-
- /* Now 'shift' the result of the reduction. Determine what state
- that goes to, based on the state we popped back to and the rule
- number reduced by. */
- {
- const int yylhs = yyr1[yyn] - YYNTOKENS;
- const int yyi = yypgoto[yylhs] + *yyssp;
- yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
- ? yytable[yyi]
- : yydefgoto[yylhs]);
- }
-
- goto yynewstate;
-
-
-/*--------------------------------------.
-| yyerrlab -- here on detecting error. |
-`--------------------------------------*/
-yyerrlab:
- /* Make sure we have latest lookahead translation. See comments at
- user semantic actions for why this is necessary. */
- yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar);
- /* If not already recovering from an error, report this error. */
- if (!yyerrstatus)
- {
- ++yynerrs;
- yyerror (YY_("syntax error"));
- }
-
- if (yyerrstatus == 3)
- {
- /* If just tried and failed to reuse lookahead token after an
- error, discard it. */
-
- if (yychar <= YYEOF)
- {
- /* Return failure if at end of input. */
- if (yychar == YYEOF)
- YYABORT;
- }
- else
- {
- yydestruct ("Error: discarding",
- yytoken, &yylval);
- yychar = YYEMPTY;
- }
- }
-
- /* Else will try to reuse lookahead token after shifting the error
- token. */
- goto yyerrlab1;
-
-
-/*---------------------------------------------------.
-| yyerrorlab -- error raised explicitly by YYERROR. |
-`---------------------------------------------------*/
-yyerrorlab:
- /* Pacify compilers when the user code never invokes YYERROR and the
- label yyerrorlab therefore never appears in user code. */
- if (0)
- YYERROR;
- ++yynerrs;
-
- /* Do not reclaim the symbols of the rule whose action triggered
- this YYERROR. */
- YYPOPSTACK (yylen);
- yylen = 0;
- YY_STACK_PRINT (yyss, yyssp);
- yystate = *yyssp;
- goto yyerrlab1;
-
-
-/*-------------------------------------------------------------.
-| yyerrlab1 -- common code for both syntax error and YYERROR. |
-`-------------------------------------------------------------*/
-yyerrlab1:
- yyerrstatus = 3; /* Each real token shifted decrements this. */
-
- /* Pop stack until we find a state that shifts the error token. */
- for (;;)
- {
- yyn = yypact[yystate];
- if (!yypact_value_is_default (yyn))
- {
- yyn += YYSYMBOL_YYerror;
- if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror)
- {
- yyn = yytable[yyn];
- if (0 < yyn)
- break;
- }
- }
-
- /* Pop the current state because it cannot handle the error token. */
- if (yyssp == yyss)
- YYABORT;
-
-
- yydestruct ("Error: popping",
- YY_ACCESSING_SYMBOL (yystate), yyvsp);
- YYPOPSTACK (1);
- yystate = *yyssp;
- YY_STACK_PRINT (yyss, yyssp);
- }
-
- YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
- *++yyvsp = yylval;
- YY_IGNORE_MAYBE_UNINITIALIZED_END
-
-
- /* Shift the error token. */
- YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp);
-
- yystate = yyn;
- goto yynewstate;
-
-
-/*-------------------------------------.
-| yyacceptlab -- YYACCEPT comes here. |
-`-------------------------------------*/
-yyacceptlab:
- yyresult = 0;
- goto yyreturnlab;
-
-
-/*-----------------------------------.
-| yyabortlab -- YYABORT comes here. |
-`-----------------------------------*/
-yyabortlab:
- yyresult = 1;
- goto yyreturnlab;
-
-
-/*-----------------------------------------------------------.
-| yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here. |
-`-----------------------------------------------------------*/
-yyexhaustedlab:
- yyerror (YY_("memory exhausted"));
- yyresult = 2;
- goto yyreturnlab;
-
-
-/*----------------------------------------------------------.
-| yyreturnlab -- parsing is finished, clean up and return. |
-`----------------------------------------------------------*/
-yyreturnlab:
- if (yychar != YYEMPTY)
- {
- /* Make sure we have latest lookahead translation. See comments at
- user semantic actions for why this is necessary. */
- yytoken = YYTRANSLATE (yychar);
- yydestruct ("Cleanup: discarding lookahead",
- yytoken, &yylval);
- }
- /* Do not reclaim the symbols of the rule whose action triggered
- this YYABORT or YYACCEPT. */
- YYPOPSTACK (yylen);
- YY_STACK_PRINT (yyss, yyssp);
- while (yyssp != yyss)
- {
- yydestruct ("Cleanup: popping",
- YY_ACCESSING_SYMBOL (+*yyssp), yyvsp);
- YYPOPSTACK (1);
- }
-#ifndef yyoverflow
- if (yyss != yyssa)
- YYSTACK_FREE (yyss);
-#endif
-
- return yyresult;
-}
-
-#line 426 "./config/loongarch-parse.y"
-
-
--
2.33.0
Reference in New Issue Copy Permalink