"Fossies" - the Fresh Open Source Software Archive

Member "srg-1.3.6/libconfig/config.parser.c" (5 Aug 2009, 42465 Bytes) of package /linux/privat/old/srg-1.3.6.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file.

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