scripts/genksyms/parse.tab.c_shipped

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