scripts/genksyms/parse.tab.c_shipped

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