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