binutils/defparse.c

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