scripts/genksyms/parse.c_shipped

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