Back to index

php5  5.3.10
zend_ini_parser.c
Go to the documentation of this file.
00001 
00002 /* A Bison parser, made by GNU Bison 2.4.1.  */
00003 
00004 /* Skeleton implementation for Bison's Yacc-like parsers in C
00005    
00006       Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
00007    Free Software Foundation, Inc.
00008    
00009    This program is free software: you can redistribute it and/or modify
00010    it under the terms of the GNU General Public License as published by
00011    the Free Software Foundation, either version 3 of the License, or
00012    (at your option) any later version.
00013    
00014    This program is distributed in the hope that it will be useful,
00015    but WITHOUT ANY WARRANTY; without even the implied warranty of
00016    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00017    GNU General Public License for more details.
00018    
00019    You should have received a copy of the GNU General Public License
00020    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
00021 
00022 /* As a special exception, you may create a larger work that contains
00023    part or all of the Bison parser skeleton and distribute that work
00024    under terms of your choice, so long as that work isn't itself a
00025    parser generator using the skeleton or a modified version thereof
00026    as a parser skeleton.  Alternatively, if you modify or redistribute
00027    the parser skeleton itself, you may (at your option) remove this
00028    special exception, which will cause the skeleton and the resulting
00029    Bison output files to be licensed under the GNU General Public
00030    License without this special exception.
00031    
00032    This special exception was added by the Free Software Foundation in
00033    version 2.2 of Bison.  */
00034 
00035 /* C LALR(1) parser skeleton written by Richard Stallman, by
00036    simplifying the original so-called "semantic" parser.  */
00037 
00038 /* All symbols defined below should begin with yy or YY, to avoid
00039    infringing on user name space.  This should be done even for local
00040    variables, as they might otherwise be expanded by user macros.
00041    There are some unavoidable exceptions within include files to
00042    define necessary library symbols; they are noted "INFRINGES ON
00043    USER NAME SPACE" below.  */
00044 
00045 /* Identify Bison output.  */
00046 #define YYBISON 1
00047 
00048 /* Bison version.  */
00049 #define YYBISON_VERSION "2.4.1"
00050 
00051 /* Skeleton name.  */
00052 #define YYSKELETON_NAME "yacc.c"
00053 
00054 /* Pure parsers.  */
00055 #define YYPURE 1
00056 
00057 /* Push parsers.  */
00058 #define YYPUSH 0
00059 
00060 /* Pull parsers.  */
00061 #define YYPULL 1
00062 
00063 /* Using locations.  */
00064 #define YYLSP_NEEDED 0
00065 
00066 /* Substitute the variable and function names.  */
00067 #define yyparse         ini_parse
00068 #define yylex           ini_lex
00069 #define yyerror         ini_error
00070 #define yylval          ini_lval
00071 #define yychar          ini_char
00072 #define yydebug         ini_debug
00073 #define yynerrs         ini_nerrs
00074 
00075 
00076 /* Copy the first part of user declarations.  */
00077 
00078 
00079 /*
00080    +----------------------------------------------------------------------+
00081    | Zend Engine                                                          |
00082    +----------------------------------------------------------------------+
00083    | Copyright (c) 1998-2012 Zend Technologies Ltd. (http://www.zend.com) |
00084    +----------------------------------------------------------------------+
00085    | This source file is subject to version 2.00 of the Zend license,     |
00086    | that is bundled with this package in the file LICENSE, and is        |
00087    | available through the world-wide-web at the following url:           |
00088    | http://www.zend.com/license/2_00.txt.                                |
00089    | If you did not receive a copy of the Zend license and are unable to  |
00090    | obtain it through the world-wide-web, please send a note to          |
00091    | license@zend.com so we can mail you a copy immediately.              |
00092    +----------------------------------------------------------------------+
00093    | Authors: Zeev Suraski <zeev@zend.com>                                |
00094    |          Jani Taskinen <jani@php.net>                                |
00095    +----------------------------------------------------------------------+
00096 */
00097 
00098 /* $Id: zend_ini_parser.y 321634 2012-01-01 13:15:04Z felipe $ */
00099 
00100 #define DEBUG_CFG_PARSER 0
00101 
00102 #include "zend.h"
00103 #include "zend_API.h"
00104 #include "zend_ini.h"
00105 #include "zend_constants.h"
00106 #include "zend_ini_scanner.h"
00107 #include "zend_extensions.h"
00108 
00109 #define YYERROR_VERBOSE
00110 #define YYSTYPE zval
00111 
00112 #ifdef ZTS
00113 #define YYPARSE_PARAM tsrm_ls
00114 #define YYLEX_PARAM tsrm_ls
00115 int ini_parse(void *arg);
00116 #else
00117 int ini_parse(void);
00118 #endif
00119 
00120 #define ZEND_INI_PARSER_CB  (CG(ini_parser_param))->ini_parser_cb
00121 #define ZEND_INI_PARSER_ARG (CG(ini_parser_param))->arg
00122 
00123 /* {{{ zend_ini_do_op()
00124 */
00125 static void zend_ini_do_op(char type, zval *result, zval *op1, zval *op2)
00126 {
00127        int i_result;
00128        int i_op1, i_op2;
00129        char str_result[MAX_LENGTH_OF_LONG];
00130 
00131        i_op1 = atoi(Z_STRVAL_P(op1));
00132        free(Z_STRVAL_P(op1));
00133        if (op2) {
00134               i_op2 = atoi(Z_STRVAL_P(op2));
00135               free(Z_STRVAL_P(op2));
00136        } else {
00137               i_op2 = 0;
00138        }
00139 
00140        switch (type) {
00141               case '|':
00142                      i_result = i_op1 | i_op2;
00143                      break;
00144               case '&':
00145                      i_result = i_op1 & i_op2;
00146                      break;
00147               case '~':
00148                      i_result = ~i_op1;
00149                      break;
00150               case '!':
00151                      i_result = !i_op1;
00152                      break;
00153               default:
00154                      i_result = 0;
00155                      break;
00156        }
00157 
00158        Z_STRLEN_P(result) = zend_sprintf(str_result, "%d", i_result);
00159        Z_STRVAL_P(result) = (char *) malloc(Z_STRLEN_P(result)+1);
00160        memcpy(Z_STRVAL_P(result), str_result, Z_STRLEN_P(result));
00161        Z_STRVAL_P(result)[Z_STRLEN_P(result)] = 0;
00162        Z_TYPE_P(result) = IS_STRING;
00163 }
00164 /* }}} */
00165 
00166 /* {{{ zend_ini_init_string()
00167 */
00168 static void zend_ini_init_string(zval *result)
00169 {
00170        Z_STRVAL_P(result) = malloc(1);
00171        Z_STRVAL_P(result)[0] = 0;
00172        Z_STRLEN_P(result) = 0;
00173        Z_TYPE_P(result) = IS_STRING;
00174 }
00175 /* }}} */
00176 
00177 /* {{{ zend_ini_add_string()
00178 */
00179 static void zend_ini_add_string(zval *result, zval *op1, zval *op2)
00180 {
00181        int length = Z_STRLEN_P(op1) + Z_STRLEN_P(op2);
00182 
00183        Z_STRVAL_P(result) = (char *) realloc(Z_STRVAL_P(op1), length+1);
00184        memcpy(Z_STRVAL_P(result)+Z_STRLEN_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op2));
00185        Z_STRVAL_P(result)[length] = 0;
00186        Z_STRLEN_P(result) = length;
00187        Z_TYPE_P(result) = IS_STRING;
00188 }
00189 /* }}} */
00190 
00191 /* {{{ zend_ini_get_constant()
00192 */
00193 static void zend_ini_get_constant(zval *result, zval *name TSRMLS_DC)
00194 {
00195        zval z_constant;
00196 
00197        /* If name contains ':' it is not a constant. Bug #26893. */
00198        if (!memchr(Z_STRVAL_P(name), ':', Z_STRLEN_P(name))
00199                      && zend_get_constant(Z_STRVAL_P(name), Z_STRLEN_P(name), &z_constant TSRMLS_CC)) {
00200               /* z_constant is emalloc()'d */
00201               convert_to_string(&z_constant);
00202               Z_STRVAL_P(result) = zend_strndup(Z_STRVAL(z_constant), Z_STRLEN(z_constant));
00203               Z_STRLEN_P(result) = Z_STRLEN(z_constant);
00204               Z_TYPE_P(result) = Z_TYPE(z_constant);
00205               zval_dtor(&z_constant);
00206               free(Z_STRVAL_P(name));
00207        } else {
00208               *result = *name;
00209        }
00210 }
00211 /* }}} */
00212 
00213 /* {{{ zend_ini_get_var()
00214 */
00215 static void zend_ini_get_var(zval *result, zval *name TSRMLS_DC)
00216 {
00217        zval curval;
00218        char *envvar;
00219 
00220        /* Fetch configuration option value */
00221        if (zend_get_configuration_directive(Z_STRVAL_P(name), Z_STRLEN_P(name)+1, &curval) == SUCCESS) {
00222               Z_STRVAL_P(result) = zend_strndup(Z_STRVAL(curval), Z_STRLEN(curval));
00223               Z_STRLEN_P(result) = Z_STRLEN(curval);
00224        /* ..or if not found, try ENV */
00225        } else if ((envvar = zend_getenv(Z_STRVAL_P(name), Z_STRLEN_P(name) TSRMLS_CC)) != NULL ||
00226                         (envvar = getenv(Z_STRVAL_P(name))) != NULL) {
00227               Z_STRVAL_P(result) = strdup(envvar);
00228               Z_STRLEN_P(result) = strlen(envvar);
00229        } else {
00230               zend_ini_init_string(result);
00231        }
00232 }
00233 /* }}} */
00234 
00235 /* {{{ ini_error()
00236 */
00237 static void ini_error(char *msg)
00238 {
00239        char *error_buf;
00240        int error_buf_len;
00241        char *currently_parsed_filename;
00242        TSRMLS_FETCH();
00243 
00244        currently_parsed_filename = zend_ini_scanner_get_filename(TSRMLS_C);
00245        if (currently_parsed_filename) {
00246               error_buf_len = 128 + strlen(msg) + strlen(currently_parsed_filename); /* should be more than enough */
00247               error_buf = (char *) emalloc(error_buf_len);
00248 
00249               sprintf(error_buf, "%s in %s on line %d\n", msg, currently_parsed_filename, zend_ini_scanner_get_lineno(TSRMLS_C));
00250        } else {
00251               error_buf = estrdup("Invalid configuration directive\n");
00252        }
00253 
00254        if (CG(ini_parser_unbuffered_errors)) {
00255 #ifdef PHP_WIN32
00256               MessageBox(NULL, error_buf, "PHP Error", MB_OK|MB_TOPMOST|0x00200000L);
00257 #else
00258               fprintf(stderr, "PHP:  %s", error_buf);
00259 #endif
00260        } else {
00261               zend_error(E_WARNING, "%s", error_buf);
00262        }
00263        efree(error_buf);
00264 }
00265 /* }}} */
00266 
00267 /* {{{ zend_parse_ini_file()
00268 */
00269 ZEND_API int zend_parse_ini_file(zend_file_handle *fh, zend_bool unbuffered_errors, int scanner_mode, zend_ini_parser_cb_t ini_parser_cb, void *arg TSRMLS_DC)
00270 {
00271        int retval;
00272        zend_ini_parser_param ini_parser_param;
00273 
00274        ini_parser_param.ini_parser_cb = ini_parser_cb;
00275        ini_parser_param.arg = arg;
00276        CG(ini_parser_param) = &ini_parser_param;
00277 
00278        if (zend_ini_open_file_for_scanning(fh, scanner_mode TSRMLS_CC) == FAILURE) {
00279               return FAILURE;
00280        }
00281 
00282        CG(ini_parser_unbuffered_errors) = unbuffered_errors;
00283        retval = ini_parse(TSRMLS_C);
00284        zend_file_handle_dtor(fh TSRMLS_CC);
00285 
00286        shutdown_ini_scanner(TSRMLS_C);
00287        
00288        if (retval == 0) {
00289               return SUCCESS;
00290        } else {
00291               return FAILURE;
00292        }
00293 }
00294 /* }}} */
00295 
00296 /* {{{ zend_parse_ini_string()
00297 */
00298 ZEND_API int zend_parse_ini_string(char *str, zend_bool unbuffered_errors, int scanner_mode, zend_ini_parser_cb_t ini_parser_cb, void *arg TSRMLS_DC)
00299 {
00300        int retval;
00301        zend_ini_parser_param ini_parser_param;
00302 
00303        ini_parser_param.ini_parser_cb = ini_parser_cb;
00304        ini_parser_param.arg = arg;
00305        CG(ini_parser_param) = &ini_parser_param;
00306 
00307        if (zend_ini_prepare_string_for_scanning(str, scanner_mode TSRMLS_CC) == FAILURE) {
00308               return FAILURE;
00309        }
00310 
00311        CG(ini_parser_unbuffered_errors) = unbuffered_errors;
00312        retval = ini_parse(TSRMLS_C);
00313 
00314        shutdown_ini_scanner(TSRMLS_C);
00315 
00316        if (retval == 0) {
00317               return SUCCESS;
00318        } else {
00319               return FAILURE;
00320        }
00321 }
00322 /* }}} */
00323 
00324 
00325 
00326 
00327 /* Enabling traces.  */
00328 #ifndef YYDEBUG
00329 # define YYDEBUG 0
00330 #endif
00331 
00332 /* Enabling verbose error messages.  */
00333 #ifdef YYERROR_VERBOSE
00334 # undef YYERROR_VERBOSE
00335 # define YYERROR_VERBOSE 1
00336 #else
00337 # define YYERROR_VERBOSE 0
00338 #endif
00339 
00340 /* Enabling the token table.  */
00341 #ifndef YYTOKEN_TABLE
00342 # define YYTOKEN_TABLE 0
00343 #endif
00344 
00345 
00346 /* Tokens.  */
00347 #ifndef YYTOKENTYPE
00348 # define YYTOKENTYPE
00349    /* Put the tokens into the symbol table, so that GDB and other debuggers
00350       know about them.  */
00351    enum yytokentype {
00352      TC_SECTION = 258,
00353      TC_RAW = 259,
00354      TC_CONSTANT = 260,
00355      TC_NUMBER = 261,
00356      TC_STRING = 262,
00357      TC_WHITESPACE = 263,
00358      TC_LABEL = 264,
00359      TC_OFFSET = 265,
00360      TC_DOLLAR_CURLY = 266,
00361      TC_VARNAME = 267,
00362      TC_QUOTED_STRING = 268,
00363      BOOL_TRUE = 269,
00364      BOOL_FALSE = 270,
00365      END_OF_LINE = 271
00366    };
00367 #endif
00368 /* Tokens.  */
00369 #define TC_SECTION 258
00370 #define TC_RAW 259
00371 #define TC_CONSTANT 260
00372 #define TC_NUMBER 261
00373 #define TC_STRING 262
00374 #define TC_WHITESPACE 263
00375 #define TC_LABEL 264
00376 #define TC_OFFSET 265
00377 #define TC_DOLLAR_CURLY 266
00378 #define TC_VARNAME 267
00379 #define TC_QUOTED_STRING 268
00380 #define BOOL_TRUE 269
00381 #define BOOL_FALSE 270
00382 #define END_OF_LINE 271
00383 
00384 
00385 
00386 
00387 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
00388 typedef int YYSTYPE;
00389 # define YYSTYPE_IS_TRIVIAL 1
00390 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
00391 # define YYSTYPE_IS_DECLARED 1
00392 #endif
00393 
00394 
00395 /* Copy the second part of user declarations.  */
00396 
00397 
00398 
00399 #ifdef short
00400 # undef short
00401 #endif
00402 
00403 #ifdef YYTYPE_UINT8
00404 typedef YYTYPE_UINT8 yytype_uint8;
00405 #else
00406 typedef unsigned char yytype_uint8;
00407 #endif
00408 
00409 #ifdef YYTYPE_INT8
00410 typedef YYTYPE_INT8 yytype_int8;
00411 #elif (defined __STDC__ || defined __C99__FUNC__ \
00412      || defined __cplusplus || defined _MSC_VER)
00413 typedef signed char yytype_int8;
00414 #else
00415 typedef short int yytype_int8;
00416 #endif
00417 
00418 #ifdef YYTYPE_UINT16
00419 typedef YYTYPE_UINT16 yytype_uint16;
00420 #else
00421 typedef unsigned short int yytype_uint16;
00422 #endif
00423 
00424 #ifdef YYTYPE_INT16
00425 typedef YYTYPE_INT16 yytype_int16;
00426 #else
00427 typedef short int yytype_int16;
00428 #endif
00429 
00430 #ifndef YYSIZE_T
00431 # ifdef __SIZE_TYPE__
00432 #  define YYSIZE_T __SIZE_TYPE__
00433 # elif defined size_t
00434 #  define YYSIZE_T size_t
00435 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
00436      || defined __cplusplus || defined _MSC_VER)
00437 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
00438 #  define YYSIZE_T size_t
00439 # else
00440 #  define YYSIZE_T unsigned int
00441 # endif
00442 #endif
00443 
00444 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
00445 
00446 #ifndef YY_
00447 # if YYENABLE_NLS
00448 #  if ENABLE_NLS
00449 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
00450 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
00451 #  endif
00452 # endif
00453 # ifndef YY_
00454 #  define YY_(msgid) msgid
00455 # endif
00456 #endif
00457 
00458 /* Suppress unused-variable warnings by "using" E.  */
00459 #if ! defined lint || defined __GNUC__
00460 # define YYUSE(e) ((void) (e))
00461 #else
00462 # define YYUSE(e) /* empty */
00463 #endif
00464 
00465 /* Identity function, used to suppress warnings about constant conditions.  */
00466 #ifndef lint
00467 # define YYID(n) (n)
00468 #else
00469 #if (defined __STDC__ || defined __C99__FUNC__ \
00470      || defined __cplusplus || defined _MSC_VER)
00471 static int
00472 YYID (int yyi)
00473 #else
00474 static int
00475 YYID (yyi)
00476     int yyi;
00477 #endif
00478 {
00479   return yyi;
00480 }
00481 #endif
00482 
00483 #if ! defined yyoverflow || YYERROR_VERBOSE
00484 
00485 /* The parser invokes alloca or malloc; define the necessary symbols.  */
00486 
00487 # ifdef YYSTACK_USE_ALLOCA
00488 #  if YYSTACK_USE_ALLOCA
00489 #   ifdef __GNUC__
00490 #    define YYSTACK_ALLOC __builtin_alloca
00491 #   elif defined __BUILTIN_VA_ARG_INCR
00492 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
00493 #   elif defined _AIX
00494 #    define YYSTACK_ALLOC __alloca
00495 #   elif defined _MSC_VER
00496 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
00497 #    define alloca _alloca
00498 #   else
00499 #    define YYSTACK_ALLOC alloca
00500 #    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
00501      || defined __cplusplus || defined _MSC_VER)
00502 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
00503 #     ifndef _STDLIB_H
00504 #      define _STDLIB_H 1
00505 #     endif
00506 #    endif
00507 #   endif
00508 #  endif
00509 # endif
00510 
00511 # ifdef YYSTACK_ALLOC
00512    /* Pacify GCC's `empty if-body' warning.  */
00513 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
00514 #  ifndef YYSTACK_ALLOC_MAXIMUM
00515     /* The OS might guarantee only one guard page at the bottom of the stack,
00516        and a page size can be as small as 4096 bytes.  So we cannot safely
00517        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
00518        to allow for a few compiler-allocated temporary stack slots.  */
00519 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
00520 #  endif
00521 # else
00522 #  define YYSTACK_ALLOC YYMALLOC
00523 #  define YYSTACK_FREE YYFREE
00524 #  ifndef YYSTACK_ALLOC_MAXIMUM
00525 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
00526 #  endif
00527 #  if (defined __cplusplus && ! defined _STDLIB_H \
00528        && ! ((defined YYMALLOC || defined malloc) \
00529             && (defined YYFREE || defined free)))
00530 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
00531 #   ifndef _STDLIB_H
00532 #    define _STDLIB_H 1
00533 #   endif
00534 #  endif
00535 #  ifndef YYMALLOC
00536 #   define YYMALLOC malloc
00537 #   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
00538      || defined __cplusplus || defined _MSC_VER)
00539 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
00540 #   endif
00541 #  endif
00542 #  ifndef YYFREE
00543 #   define YYFREE free
00544 #   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
00545      || defined __cplusplus || defined _MSC_VER)
00546 void free (void *); /* INFRINGES ON USER NAME SPACE */
00547 #   endif
00548 #  endif
00549 # endif
00550 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
00551 
00552 
00553 #if (! defined yyoverflow \
00554      && (! defined __cplusplus \
00555         || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
00556 
00557 /* A type that is properly aligned for any stack member.  */
00558 union yyalloc
00559 {
00560   yytype_int16 yyss_alloc;
00561   YYSTYPE yyvs_alloc;
00562 };
00563 
00564 /* The size of the maximum gap between one aligned stack and the next.  */
00565 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
00566 
00567 /* The size of an array large to enough to hold all stacks, each with
00568    N elements.  */
00569 # define YYSTACK_BYTES(N) \
00570      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
00571       + YYSTACK_GAP_MAXIMUM)
00572 
00573 /* Copy COUNT objects from FROM to TO.  The source and destination do
00574    not overlap.  */
00575 # ifndef YYCOPY
00576 #  if defined __GNUC__ && 1 < __GNUC__
00577 #   define YYCOPY(To, From, Count) \
00578       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
00579 #  else
00580 #   define YYCOPY(To, From, Count)        \
00581       do                                  \
00582        {                                  \
00583          YYSIZE_T yyi;                           \
00584          for (yyi = 0; yyi < (Count); yyi++)     \
00585            (To)[yyi] = (From)[yyi];              \
00586        }                                  \
00587       while (YYID (0))
00588 #  endif
00589 # endif
00590 
00591 /* Relocate STACK from its old location to the new one.  The
00592    local variables YYSIZE and YYSTACKSIZE give the old and new number of
00593    elements in the stack, and YYPTR gives the new location of the
00594    stack.  Advance YYPTR to a properly aligned location for the next
00595    stack.  */
00596 # define YYSTACK_RELOCATE(Stack_alloc, Stack)                         \
00597     do                                                         \
00598       {                                                               \
00599        YYSIZE_T yynewbytes;                                    \
00600        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                   \
00601        Stack = &yyptr->Stack_alloc;                                   \
00602        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
00603        yyptr += yynewbytes / sizeof (*yyptr);                         \
00604       }                                                               \
00605     while (YYID (0))
00606 
00607 #endif
00608 
00609 /* YYFINAL -- State number of the termination state.  */
00610 #define YYFINAL  2
00611 /* YYLAST -- Last index in YYTABLE.  */
00612 #define YYLAST   109
00613 
00614 /* YYNTOKENS -- Number of terminals.  */
00615 #define YYNTOKENS  43
00616 /* YYNNTS -- Number of nonterminals.  */
00617 #define YYNNTS  13
00618 /* YYNRULES -- Number of rules.  */
00619 #define YYNRULES  48
00620 /* YYNRULES -- Number of states.  */
00621 #define YYNSTATES  69
00622 
00623 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
00624 #define YYUNDEFTOK  2
00625 #define YYMAXUTOK   271
00626 
00627 #define YYTRANSLATE(YYX)                                       \
00628   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
00629 
00630 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
00631 static const yytype_uint8 yytranslate[] =
00632 {
00633        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00634        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00635        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00636        2,     2,     2,    39,    21,     2,    29,    28,    38,    22,
00637       41,    42,    27,    24,    19,    25,    20,    26,     2,     2,
00638        2,     2,     2,     2,     2,     2,     2,     2,    18,     2,
00639       31,    17,    32,    33,    34,     2,     2,     2,     2,     2,
00640        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00641        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00642        2,     2,     2,    40,    23,     2,     2,     2,     2,     2,
00643        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00644        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00645        2,     2,     2,    35,    37,    36,    30,     2,     2,     2,
00646        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00647        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00648        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00649        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00650        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00651        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00652        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00653        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00654        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00655        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00656        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00657        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00658        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
00659        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
00660       15,    16
00661 };
00662 
00663 #if YYDEBUG
00664 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
00665    YYRHS.  */
00666 static const yytype_uint8 yyprhs[] =
00667 {
00668        0,     0,     3,     6,     7,    11,    15,    21,    23,    25,
00669       27,    28,    30,    32,    34,    36,    38,    39,    42,    45,
00670       46,    48,    50,    54,    57,    60,    65,    67,    69,    73,
00671       76,    79,    84,    86,    90,    94,    97,   100,   104,   108,
00672      110,   112,   114,   116,   118,   120,   122,   124,   126
00673 };
00674 
00675 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
00676 static const yytype_int8 yyrhs[] =
00677 {
00678       44,     0,    -1,    44,    45,    -1,    -1,     3,    46,    40,
00679       -1,     9,    17,    47,    -1,    10,    48,    40,    17,    47,
00680       -1,     9,    -1,    16,    -1,    50,    -1,    -1,    52,    -1,
00681       14,    -1,    15,    -1,    16,    -1,    51,    -1,    -1,    49,
00682       53,    -1,    49,    13,    -1,    -1,    53,    -1,    54,    -1,
00683       21,    49,    21,    -1,    50,    53,    -1,    50,    54,    -1,
00684       50,    21,    49,    21,    -1,    53,    -1,    55,    -1,    21,
00685       49,    21,    -1,    51,    53,    -1,    51,    55,    -1,    51,
00686       21,    49,    21,    -1,    51,    -1,    52,    37,    52,    -1,
00687       52,    38,    52,    -1,    30,    52,    -1,    39,    52,    -1,
00688       41,    52,    42,    -1,    11,    12,    36,    -1,     5,    -1,
00689        4,    -1,     6,    -1,     7,    -1,     8,    -1,     5,    -1,
00690        4,    -1,     6,    -1,     7,    -1,     8,    -1
00691 };
00692 
00693 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
00694 static const yytype_uint16 yyrline[] =
00695 {
00696        0,   273,   273,   274,   278,   285,   293,   302,   303,   307,
00697      308,   312,   313,   314,   315,   319,   320,   324,   325,   326,
00698      330,   331,   332,   333,   334,   335,   339,   340,   341,   342,
00699      343,   344,   348,   349,   350,   351,   352,   353,   357,   361,
00700      362,   363,   364,   365,   369,   370,   371,   372,   373
00701 };
00702 #endif
00703 
00704 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
00705 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
00706    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
00707 static const char *const yytname[] =
00708 {
00709   "$end", "error", "$undefined", "TC_SECTION", "TC_RAW", "TC_CONSTANT",
00710   "TC_NUMBER", "TC_STRING", "TC_WHITESPACE", "TC_LABEL", "TC_OFFSET",
00711   "TC_DOLLAR_CURLY", "TC_VARNAME", "TC_QUOTED_STRING", "BOOL_TRUE",
00712   "BOOL_FALSE", "END_OF_LINE", "'='", "':'", "','", "'.'", "'\"'", "'\\''",
00713   "'^'", "'+'", "'-'", "'/'", "'*'", "'%'", "'$'", "'~'", "'<'", "'>'",
00714   "'?'", "'@'", "'{'", "'}'", "'|'", "'&'", "'!'", "']'", "'('", "')'",
00715   "$accept", "statement_list", "statement", "section_string_or_value",
00716   "string_or_value", "option_offset", "encapsed_list",
00717   "var_string_list_section", "var_string_list", "expr", "cfg_var_ref",
00718   "constant_literal", "constant_string", 0
00719 };
00720 #endif
00721 
00722 # ifdef YYPRINT
00723 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
00724    token YYLEX-NUM.  */
00725 static const yytype_uint16 yytoknum[] =
00726 {
00727        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
00728      265,   266,   267,   268,   269,   270,   271,    61,    58,    44,
00729       46,    34,    39,    94,    43,    45,    47,    42,    37,    36,
00730      126,    60,    62,    63,    64,   123,   125,   124,    38,    33,
00731       93,    40,    41
00732 };
00733 # endif
00734 
00735 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
00736 static const yytype_uint8 yyr1[] =
00737 {
00738        0,    43,    44,    44,    45,    45,    45,    45,    45,    46,
00739       46,    47,    47,    47,    47,    48,    48,    49,    49,    49,
00740       50,    50,    50,    50,    50,    50,    51,    51,    51,    51,
00741       51,    51,    52,    52,    52,    52,    52,    52,    53,    54,
00742       54,    54,    54,    54,    55,    55,    55,    55,    55
00743 };
00744 
00745 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
00746 static const yytype_uint8 yyr2[] =
00747 {
00748        0,     2,     2,     0,     3,     3,     5,     1,     1,     1,
00749        0,     1,     1,     1,     1,     1,     0,     2,     2,     0,
00750        1,     1,     3,     2,     2,     4,     1,     1,     3,     2,
00751        2,     4,     1,     3,     3,     2,     2,     3,     3,     1,
00752        1,     1,     1,     1,     1,     1,     1,     1,     1
00753 };
00754 
00755 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
00756    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
00757    means the default is an error.  */
00758 static const yytype_uint8 yydefact[] =
00759 {
00760        3,     0,     1,    10,     7,    16,     8,     2,    40,    39,
00761       41,    42,    43,     0,    19,     0,     9,    20,    21,     0,
00762       45,    44,    46,    47,    48,    19,     0,    15,    26,    27,
00763        0,     0,     4,    19,    23,    24,    12,    13,    14,     0,
00764        0,     0,     5,    32,    11,     0,     0,    19,    29,    30,
00765       38,    18,    22,    17,     0,    35,    36,     0,     0,     0,
00766       28,     0,     0,    25,    37,    33,    34,     6,    31
00767 };
00768 
00769 /* YYDEFGOTO[NTERM-NUM].  */
00770 static const yytype_int8 yydefgoto[] =
00771 {
00772       -1,     1,     7,    15,    42,    26,    31,    16,    43,    44,
00773       28,    18,    29
00774 };
00775 
00776 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
00777    STATE-NUM.  */
00778 #define YYPACT_NINF -36
00779 static const yytype_int8 yypact[] =
00780 {
00781      -36,    93,   -36,    39,    -5,    65,   -36,   -36,   -36,   -36,
00782      -36,   -36,   -36,     8,   -36,   -18,    73,   -36,   -36,     0,
00783      -36,   -36,   -36,   -36,   -36,   -36,   -15,    84,   -36,   -36,
00784       -9,    41,   -36,   -36,   -36,   -36,   -36,   -36,   -36,    27,
00785       27,    27,   -36,    84,   -35,    42,    12,   -36,   -36,   -36,
00786      -36,   -36,   -36,   -36,    54,   -36,   -36,    45,    27,    27,
00787      -36,     0,    86,   -36,   -36,   -36,   -36,   -36,   -36
00788 };
00789 
00790 /* YYPGOTO[NTERM-NUM].  */
00791 static const yytype_int8 yypgoto[] =
00792 {
00793      -36,   -36,   -36,   -36,   -12,   -36,   -24,   -36,    51,   -22,
00794       -3,    48,   -17
00795 };
00796 
00797 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
00798    positive, shift that token.  If negative, reduce the rule which
00799    number is the opposite.  If zero, do what YYDEFACT says.
00800    If YYTABLE_NINF, syntax error.  */
00801 #define YYTABLE_NINF -1
00802 static const yytype_uint8 yytable[] =
00803 {
00804       17,    45,    58,    59,    20,    21,    22,    23,    24,    54,
00805       49,    13,    19,    34,    36,    37,    38,    55,    56,    57,
00806       30,    25,    32,    62,    48,    46,    49,    50,    53,    61,
00807       39,    20,    21,    22,    23,    24,    65,    66,    13,    40,
00808       48,    41,    53,     8,     9,    10,    11,    12,    25,    67,
00809       13,    53,    13,    13,    51,    51,    27,    39,     0,    53,
00810       14,     0,    52,    60,    35,    13,    40,    51,    41,    20,
00811       21,    22,    23,    24,     0,    63,    13,     8,     9,    10,
00812       11,    12,    58,    59,    13,     0,    25,    64,    20,    21,
00813       22,    23,    24,     2,    33,    13,     3,    13,     0,    51,
00814        0,     0,     4,     5,     0,    47,     0,    68,     0,     6
00815 };
00816 
00817 static const yytype_int8 yycheck[] =
00818 {
00819        3,    25,    37,    38,     4,     5,     6,     7,     8,    33,
00820       27,    11,    17,    16,    14,    15,    16,    39,    40,    41,
00821       12,    21,    40,    47,    27,    40,    43,    36,    31,    17,
00822       30,     4,     5,     6,     7,     8,    58,    59,    11,    39,
00823       43,    41,    45,     4,     5,     6,     7,     8,    21,    61,
00824       11,    54,    11,    11,    13,    13,     5,    30,    -1,    62,
00825       21,    -1,    21,    21,    16,    11,    39,    13,    41,     4,
00826        5,     6,     7,     8,    -1,    21,    11,     4,     5,     6,
00827        7,     8,    37,    38,    11,    -1,    21,    42,     4,     5,
00828        6,     7,     8,     0,    21,    11,     3,    11,    -1,    13,
00829       -1,    -1,     9,    10,    -1,    21,    -1,    21,    -1,    16
00830 };
00831 
00832 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
00833    symbol of state STATE-NUM.  */
00834 static const yytype_uint8 yystos[] =
00835 {
00836        0,    44,     0,     3,     9,    10,    16,    45,     4,     5,
00837        6,     7,     8,    11,    21,    46,    50,    53,    54,    17,
00838        4,     5,     6,     7,     8,    21,    48,    51,    53,    55,
00839       12,    49,    40,    21,    53,    54,    14,    15,    16,    30,
00840       39,    41,    47,    51,    52,    49,    40,    21,    53,    55,
00841       36,    13,    21,    53,    49,    52,    52,    52,    37,    38,
00842       21,    17,    49,    21,    42,    52,    52,    47,    21
00843 };
00844 
00845 #define yyerrok             (yyerrstatus = 0)
00846 #define yyclearin    (yychar = YYEMPTY)
00847 #define YYEMPTY             (-2)
00848 #define YYEOF        0
00849 
00850 #define YYACCEPT     goto yyacceptlab
00851 #define YYABORT             goto yyabortlab
00852 #define YYERROR             goto yyerrorlab
00853 
00854 
00855 /* Like YYERROR except do call yyerror.  This remains here temporarily
00856    to ease the transition to the new meaning of YYERROR, for GCC.
00857    Once GCC version 2 has supplanted version 1, this can go.  */
00858 
00859 #define YYFAIL              goto yyerrlab
00860 
00861 #define YYRECOVERING()  (!!yyerrstatus)
00862 
00863 #define YYBACKUP(Token, Value)                                 \
00864 do                                                      \
00865   if (yychar == YYEMPTY && yylen == 1)                         \
00866     {                                                   \
00867       yychar = (Token);                                        \
00868       yylval = (Value);                                        \
00869       yytoken = YYTRANSLATE (yychar);                          \
00870       YYPOPSTACK (1);                                          \
00871       goto yybackup;                                    \
00872     }                                                   \
00873   else                                                  \
00874     {                                                   \
00875       yyerror (YY_("syntax error: cannot back up")); \
00876       YYERROR;                                                 \
00877     }                                                   \
00878 while (YYID (0))
00879 
00880 
00881 #define YYTERROR     1
00882 #define YYERRCODE    256
00883 
00884 
00885 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
00886    If N is 0, then set CURRENT to the empty location which ends
00887    the previous symbol: RHS[0] (always defined).  */
00888 
00889 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
00890 #ifndef YYLLOC_DEFAULT
00891 # define YYLLOC_DEFAULT(Current, Rhs, N)                       \
00892     do                                                         \
00893       if (YYID (N))                                                    \
00894        {                                                       \
00895          (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;       \
00896          (Current).first_column = YYRHSLOC (Rhs, 1).first_column;     \
00897          (Current).last_line    = YYRHSLOC (Rhs, N).last_line;        \
00898          (Current).last_column  = YYRHSLOC (Rhs, N).last_column;      \
00899        }                                                       \
00900       else                                                     \
00901        {                                                       \
00902          (Current).first_line   = (Current).last_line   =             \
00903            YYRHSLOC (Rhs, 0).last_line;                        \
00904          (Current).first_column = (Current).last_column =             \
00905            YYRHSLOC (Rhs, 0).last_column;                      \
00906        }                                                       \
00907     while (YYID (0))
00908 #endif
00909 
00910 
00911 /* YY_LOCATION_PRINT -- Print the location on the stream.
00912    This macro was not mandated originally: define only if we know
00913    we won't break user code: when these are the locations we know.  */
00914 
00915 #ifndef YY_LOCATION_PRINT
00916 # if YYLTYPE_IS_TRIVIAL
00917 #  define YY_LOCATION_PRINT(File, Loc)                  \
00918      fprintf (File, "%d.%d-%d.%d",               \
00919              (Loc).first_line, (Loc).first_column,      \
00920              (Loc).last_line,  (Loc).last_column)
00921 # else
00922 #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
00923 # endif
00924 #endif
00925 
00926 
00927 /* YYLEX -- calling `yylex' with the right arguments.  */
00928 
00929 #ifdef YYLEX_PARAM
00930 # define YYLEX yylex (&yylval, YYLEX_PARAM)
00931 #else
00932 # define YYLEX yylex (&yylval)
00933 #endif
00934 
00935 /* Enable debugging if requested.  */
00936 #if YYDEBUG
00937 
00938 # ifndef YYFPRINTF
00939 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
00940 #  define YYFPRINTF fprintf
00941 # endif
00942 
00943 # define YYDPRINTF(Args)                  \
00944 do {                                      \
00945   if (yydebug)                                   \
00946     YYFPRINTF Args;                       \
00947 } while (YYID (0))
00948 
00949 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                  \
00950 do {                                                             \
00951   if (yydebug)                                                          \
00952     {                                                            \
00953       YYFPRINTF (stderr, "%s ", Title);                                 \
00954       yy_symbol_print (stderr,                                          \
00955                 Type, Value); \
00956       YYFPRINTF (stderr, "\n");                                         \
00957     }                                                            \
00958 } while (YYID (0))
00959 
00960 
00961 /*--------------------------------.
00962 | Print this symbol on YYOUTPUT.  |
00963 `--------------------------------*/
00964 
00965 /*ARGSUSED*/
00966 #if (defined __STDC__ || defined __C99__FUNC__ \
00967      || defined __cplusplus || defined _MSC_VER)
00968 static void
00969 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
00970 #else
00971 static void
00972 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
00973     FILE *yyoutput;
00974     int yytype;
00975     YYSTYPE const * const yyvaluep;
00976 #endif
00977 {
00978   if (!yyvaluep)
00979     return;
00980 # ifdef YYPRINT
00981   if (yytype < YYNTOKENS)
00982     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
00983 # else
00984   YYUSE (yyoutput);
00985 # endif
00986   switch (yytype)
00987     {
00988       default:
00989        break;
00990     }
00991 }
00992 
00993 
00994 /*--------------------------------.
00995 | Print this symbol on YYOUTPUT.  |
00996 `--------------------------------*/
00997 
00998 #if (defined __STDC__ || defined __C99__FUNC__ \
00999      || defined __cplusplus || defined _MSC_VER)
01000 static void
01001 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
01002 #else
01003 static void
01004 yy_symbol_print (yyoutput, yytype, yyvaluep)
01005     FILE *yyoutput;
01006     int yytype;
01007     YYSTYPE const * const yyvaluep;
01008 #endif
01009 {
01010   if (yytype < YYNTOKENS)
01011     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
01012   else
01013     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
01014 
01015   yy_symbol_value_print (yyoutput, yytype, yyvaluep);
01016   YYFPRINTF (yyoutput, ")");
01017 }
01018 
01019 /*------------------------------------------------------------------.
01020 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
01021 | TOP (included).                                                   |
01022 `------------------------------------------------------------------*/
01023 
01024 #if (defined __STDC__ || defined __C99__FUNC__ \
01025      || defined __cplusplus || defined _MSC_VER)
01026 static void
01027 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
01028 #else
01029 static void
01030 yy_stack_print (yybottom, yytop)
01031     yytype_int16 *yybottom;
01032     yytype_int16 *yytop;
01033 #endif
01034 {
01035   YYFPRINTF (stderr, "Stack now");
01036   for (; yybottom <= yytop; yybottom++)
01037     {
01038       int yybot = *yybottom;
01039       YYFPRINTF (stderr, " %d", yybot);
01040     }
01041   YYFPRINTF (stderr, "\n");
01042 }
01043 
01044 # define YY_STACK_PRINT(Bottom, Top)                           \
01045 do {                                                    \
01046   if (yydebug)                                                 \
01047     yy_stack_print ((Bottom), (Top));                          \
01048 } while (YYID (0))
01049 
01050 
01051 /*------------------------------------------------.
01052 | Report that the YYRULE is going to be reduced.  |
01053 `------------------------------------------------*/
01054 
01055 #if (defined __STDC__ || defined __C99__FUNC__ \
01056      || defined __cplusplus || defined _MSC_VER)
01057 static void
01058 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
01059 #else
01060 static void
01061 yy_reduce_print (yyvsp, yyrule)
01062     YYSTYPE *yyvsp;
01063     int yyrule;
01064 #endif
01065 {
01066   int yynrhs = yyr2[yyrule];
01067   int yyi;
01068   unsigned long int yylno = yyrline[yyrule];
01069   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
01070             yyrule - 1, yylno);
01071   /* The symbols being reduced.  */
01072   for (yyi = 0; yyi < yynrhs; yyi++)
01073     {
01074       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
01075       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
01076                      &(yyvsp[(yyi + 1) - (yynrhs)])
01077                                           );
01078       YYFPRINTF (stderr, "\n");
01079     }
01080 }
01081 
01082 # define YY_REDUCE_PRINT(Rule)            \
01083 do {                               \
01084   if (yydebug)                            \
01085     yy_reduce_print (yyvsp, Rule); \
01086 } while (YYID (0))
01087 
01088 /* Nonzero means print parse trace.  It is left uninitialized so that
01089    multiple parsers can coexist.  */
01090 int yydebug;
01091 #else /* !YYDEBUG */
01092 # define YYDPRINTF(Args)
01093 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
01094 # define YY_STACK_PRINT(Bottom, Top)
01095 # define YY_REDUCE_PRINT(Rule)
01096 #endif /* !YYDEBUG */
01097 
01098 
01099 /* YYINITDEPTH -- initial size of the parser's stacks.  */
01100 #ifndef       YYINITDEPTH
01101 # define YYINITDEPTH 200
01102 #endif
01103 
01104 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
01105    if the built-in stack extension method is used).
01106 
01107    Do not make this value too large; the results are undefined if
01108    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
01109    evaluated with infinite-precision integer arithmetic.  */
01110 
01111 #ifndef YYMAXDEPTH
01112 # define YYMAXDEPTH 10000
01113 #endif
01114 
01115 
01116 
01117 #if YYERROR_VERBOSE
01118 
01119 # ifndef yystrlen
01120 #  if defined __GLIBC__ && defined _STRING_H
01121 #   define yystrlen strlen
01122 #  else
01123 /* Return the length of YYSTR.  */
01124 #if (defined __STDC__ || defined __C99__FUNC__ \
01125      || defined __cplusplus || defined _MSC_VER)
01126 static YYSIZE_T
01127 yystrlen (const char *yystr)
01128 #else
01129 static YYSIZE_T
01130 yystrlen (yystr)
01131     const char *yystr;
01132 #endif
01133 {
01134   YYSIZE_T yylen;
01135   for (yylen = 0; yystr[yylen]; yylen++)
01136     continue;
01137   return yylen;
01138 }
01139 #  endif
01140 # endif
01141 
01142 # ifndef yystpcpy
01143 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
01144 #   define yystpcpy stpcpy
01145 #  else
01146 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
01147    YYDEST.  */
01148 #if (defined __STDC__ || defined __C99__FUNC__ \
01149      || defined __cplusplus || defined _MSC_VER)
01150 static char *
01151 yystpcpy (char *yydest, const char *yysrc)
01152 #else
01153 static char *
01154 yystpcpy (yydest, yysrc)
01155     char *yydest;
01156     const char *yysrc;
01157 #endif
01158 {
01159   char *yyd = yydest;
01160   const char *yys = yysrc;
01161 
01162   while ((*yyd++ = *yys++) != '\0')
01163     continue;
01164 
01165   return yyd - 1;
01166 }
01167 #  endif
01168 # endif
01169 
01170 # ifndef yytnamerr
01171 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
01172    quotes and backslashes, so that it's suitable for yyerror.  The
01173    heuristic is that double-quoting is unnecessary unless the string
01174    contains an apostrophe, a comma, or backslash (other than
01175    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
01176    null, do not copy; instead, return the length of what the result
01177    would have been.  */
01178 static YYSIZE_T
01179 yytnamerr (char *yyres, const char *yystr)
01180 {
01181   if (*yystr == '"')
01182     {
01183       YYSIZE_T yyn = 0;
01184       char const *yyp = yystr;
01185 
01186       for (;;)
01187        switch (*++yyp)
01188          {
01189          case '\'':
01190          case ',':
01191            goto do_not_strip_quotes;
01192 
01193          case '\\':
01194            if (*++yyp != '\\')
01195              goto do_not_strip_quotes;
01196            /* Fall through.  */
01197          default:
01198            if (yyres)
01199              yyres[yyn] = *yyp;
01200            yyn++;
01201            break;
01202 
01203          case '"':
01204            if (yyres)
01205              yyres[yyn] = '\0';
01206            return yyn;
01207          }
01208     do_not_strip_quotes: ;
01209     }
01210 
01211   if (! yyres)
01212     return yystrlen (yystr);
01213 
01214   return yystpcpy (yyres, yystr) - yyres;
01215 }
01216 # endif
01217 
01218 /* Copy into YYRESULT an error message about the unexpected token
01219    YYCHAR while in state YYSTATE.  Return the number of bytes copied,
01220    including the terminating null byte.  If YYRESULT is null, do not
01221    copy anything; just return the number of bytes that would be
01222    copied.  As a special case, return 0 if an ordinary "syntax error"
01223    message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
01224    size calculation.  */
01225 static YYSIZE_T
01226 yysyntax_error (char *yyresult, int yystate, int yychar)
01227 {
01228   int yyn = yypact[yystate];
01229 
01230   if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
01231     return 0;
01232   else
01233     {
01234       int yytype = YYTRANSLATE (yychar);
01235       YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
01236       YYSIZE_T yysize = yysize0;
01237       YYSIZE_T yysize1;
01238       int yysize_overflow = 0;
01239       enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
01240       char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
01241       int yyx;
01242 
01243 # if 0
01244       /* This is so xgettext sees the translatable formats that are
01245         constructed on the fly.  */
01246       YY_("syntax error, unexpected %s");
01247       YY_("syntax error, unexpected %s, expecting %s");
01248       YY_("syntax error, unexpected %s, expecting %s or %s");
01249       YY_("syntax error, unexpected %s, expecting %s or %s or %s");
01250       YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
01251 # endif
01252       char *yyfmt;
01253       char const *yyf;
01254       static char const yyunexpected[] = "syntax error, unexpected %s";
01255       static char const yyexpecting[] = ", expecting %s";
01256       static char const yyor[] = " or %s";
01257       char yyformat[sizeof yyunexpected
01258                   + sizeof yyexpecting - 1
01259                   + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
01260                      * (sizeof yyor - 1))];
01261       char const *yyprefix = yyexpecting;
01262 
01263       /* Start YYX at -YYN if negative to avoid negative indexes in
01264         YYCHECK.  */
01265       int yyxbegin = yyn < 0 ? -yyn : 0;
01266 
01267       /* Stay within bounds of both yycheck and yytname.  */
01268       int yychecklim = YYLAST - yyn + 1;
01269       int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
01270       int yycount = 1;
01271 
01272       yyarg[0] = yytname[yytype];
01273       yyfmt = yystpcpy (yyformat, yyunexpected);
01274 
01275       for (yyx = yyxbegin; yyx < yyxend; ++yyx)
01276        if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
01277          {
01278            if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
01279              {
01280               yycount = 1;
01281               yysize = yysize0;
01282               yyformat[sizeof yyunexpected - 1] = '\0';
01283               break;
01284              }
01285            yyarg[yycount++] = yytname[yyx];
01286            yysize1 = yysize + yytnamerr (0, yytname[yyx]);
01287            yysize_overflow |= (yysize1 < yysize);
01288            yysize = yysize1;
01289            yyfmt = yystpcpy (yyfmt, yyprefix);
01290            yyprefix = yyor;
01291          }
01292 
01293       yyf = YY_(yyformat);
01294       yysize1 = yysize + yystrlen (yyf);
01295       yysize_overflow |= (yysize1 < yysize);
01296       yysize = yysize1;
01297 
01298       if (yysize_overflow)
01299        return YYSIZE_MAXIMUM;
01300 
01301       if (yyresult)
01302        {
01303          /* Avoid sprintf, as that infringes on the user's name space.
01304             Don't have undefined behavior even if the translation
01305             produced a string with the wrong number of "%s"s.  */
01306          char *yyp = yyresult;
01307          int yyi = 0;
01308          while ((*yyp = *yyf) != '\0')
01309            {
01310              if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
01311               {
01312                 yyp += yytnamerr (yyp, yyarg[yyi++]);
01313                 yyf += 2;
01314               }
01315              else
01316               {
01317                 yyp++;
01318                 yyf++;
01319               }
01320            }
01321        }
01322       return yysize;
01323     }
01324 }
01325 #endif /* YYERROR_VERBOSE */
01326 
01327 
01328 /*-----------------------------------------------.
01329 | Release the memory associated to this symbol.  |
01330 `-----------------------------------------------*/
01331 
01332 /*ARGSUSED*/
01333 #if (defined __STDC__ || defined __C99__FUNC__ \
01334      || defined __cplusplus || defined _MSC_VER)
01335 static void
01336 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
01337 #else
01338 static void
01339 yydestruct (yymsg, yytype, yyvaluep)
01340     const char *yymsg;
01341     int yytype;
01342     YYSTYPE *yyvaluep;
01343 #endif
01344 {
01345   YYUSE (yyvaluep);
01346 
01347   if (!yymsg)
01348     yymsg = "Deleting";
01349   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
01350 
01351   switch (yytype)
01352     {
01353 
01354       default:
01355        break;
01356     }
01357 }
01358 
01359 /* Prevent warnings from -Wmissing-prototypes.  */
01360 #ifdef YYPARSE_PARAM
01361 #if defined __STDC__ || defined __cplusplus
01362 int yyparse (void *YYPARSE_PARAM);
01363 #else
01364 int yyparse ();
01365 #endif
01366 #else /* ! YYPARSE_PARAM */
01367 #if defined __STDC__ || defined __cplusplus
01368 int yyparse (void);
01369 #else
01370 int yyparse ();
01371 #endif
01372 #endif /* ! YYPARSE_PARAM */
01373 
01374 
01375 
01376 
01377 
01378 /*-------------------------.
01379 | yyparse or yypush_parse.  |
01380 `-------------------------*/
01381 
01382 #ifdef YYPARSE_PARAM
01383 #if (defined __STDC__ || defined __C99__FUNC__ \
01384      || defined __cplusplus || defined _MSC_VER)
01385 int
01386 yyparse (void *YYPARSE_PARAM)
01387 #else
01388 int
01389 yyparse (YYPARSE_PARAM)
01390     void *YYPARSE_PARAM;
01391 #endif
01392 #else /* ! YYPARSE_PARAM */
01393 #if (defined __STDC__ || defined __C99__FUNC__ \
01394      || defined __cplusplus || defined _MSC_VER)
01395 int
01396 yyparse (void)
01397 #else
01398 int
01399 yyparse ()
01400 
01401 #endif
01402 #endif
01403 {
01404 /* The lookahead symbol.  */
01405 int yychar;
01406 
01407 /* The semantic value of the lookahead symbol.  */
01408 YYSTYPE yylval;
01409 
01410     /* Number of syntax errors so far.  */
01411     int yynerrs;
01412 
01413     int yystate;
01414     /* Number of tokens to shift before error messages enabled.  */
01415     int yyerrstatus;
01416 
01417     /* The stacks and their tools:
01418        `yyss': related to states.
01419        `yyvs': related to semantic values.
01420 
01421        Refer to the stacks thru separate pointers, to allow yyoverflow
01422        to reallocate them elsewhere.  */
01423 
01424     /* The state stack.  */
01425     yytype_int16 yyssa[YYINITDEPTH];
01426     yytype_int16 *yyss;
01427     yytype_int16 *yyssp;
01428 
01429     /* The semantic value stack.  */
01430     YYSTYPE yyvsa[YYINITDEPTH];
01431     YYSTYPE *yyvs;
01432     YYSTYPE *yyvsp;
01433 
01434     YYSIZE_T yystacksize;
01435 
01436   int yyn;
01437   int yyresult;
01438   /* Lookahead token as an internal (translated) token number.  */
01439   int yytoken;
01440   /* The variables used to return semantic value and location from the
01441      action routines.  */
01442   YYSTYPE yyval;
01443 
01444 #if YYERROR_VERBOSE
01445   /* Buffer for error messages, and its allocated size.  */
01446   char yymsgbuf[128];
01447   char *yymsg = yymsgbuf;
01448   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
01449 #endif
01450 
01451 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
01452 
01453   /* The number of symbols on the RHS of the reduced rule.
01454      Keep to zero when no symbol should be popped.  */
01455   int yylen = 0;
01456 
01457   yytoken = 0;
01458   yyss = yyssa;
01459   yyvs = yyvsa;
01460   yystacksize = YYINITDEPTH;
01461 
01462   YYDPRINTF ((stderr, "Starting parse\n"));
01463 
01464   yystate = 0;
01465   yyerrstatus = 0;
01466   yynerrs = 0;
01467   yychar = YYEMPTY; /* Cause a token to be read.  */
01468 
01469   /* Initialize stack pointers.
01470      Waste one element of value and location stack
01471      so that they stay on the same level as the state stack.
01472      The wasted elements are never initialized.  */
01473   yyssp = yyss;
01474   yyvsp = yyvs;
01475 
01476   goto yysetstate;
01477 
01478 /*------------------------------------------------------------.
01479 | yynewstate -- Push a new state, which is found in yystate.  |
01480 `------------------------------------------------------------*/
01481  yynewstate:
01482   /* In all cases, when you get here, the value and location stacks
01483      have just been pushed.  So pushing a state here evens the stacks.  */
01484   yyssp++;
01485 
01486  yysetstate:
01487   *yyssp = yystate;
01488 
01489   if (yyss + yystacksize - 1 <= yyssp)
01490     {
01491       /* Get the current used size of the three stacks, in elements.  */
01492       YYSIZE_T yysize = yyssp - yyss + 1;
01493 
01494 #ifdef yyoverflow
01495       {
01496        /* Give user a chance to reallocate the stack.  Use copies of
01497           these so that the &'s don't force the real ones into
01498           memory.  */
01499        YYSTYPE *yyvs1 = yyvs;
01500        yytype_int16 *yyss1 = yyss;
01501 
01502        /* Each stack pointer address is followed by the size of the
01503           data in use in that stack, in bytes.  This used to be a
01504           conditional around just the two extra args, but that might
01505           be undefined if yyoverflow is a macro.  */
01506        yyoverflow (YY_("memory exhausted"),
01507                   &yyss1, yysize * sizeof (*yyssp),
01508                   &yyvs1, yysize * sizeof (*yyvsp),
01509                   &yystacksize);
01510 
01511        yyss = yyss1;
01512        yyvs = yyvs1;
01513       }
01514 #else /* no yyoverflow */
01515 # ifndef YYSTACK_RELOCATE
01516       goto yyexhaustedlab;
01517 # else
01518       /* Extend the stack our own way.  */
01519       if (YYMAXDEPTH <= yystacksize)
01520        goto yyexhaustedlab;
01521       yystacksize *= 2;
01522       if (YYMAXDEPTH < yystacksize)
01523        yystacksize = YYMAXDEPTH;
01524 
01525       {
01526        yytype_int16 *yyss1 = yyss;
01527        union yyalloc *yyptr =
01528          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
01529        if (! yyptr)
01530          goto yyexhaustedlab;
01531        YYSTACK_RELOCATE (yyss_alloc, yyss);
01532        YYSTACK_RELOCATE (yyvs_alloc, yyvs);
01533 #  undef YYSTACK_RELOCATE
01534        if (yyss1 != yyssa)
01535          YYSTACK_FREE (yyss1);
01536       }
01537 # endif
01538 #endif /* no yyoverflow */
01539 
01540       yyssp = yyss + yysize - 1;
01541       yyvsp = yyvs + yysize - 1;
01542 
01543       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
01544                 (unsigned long int) yystacksize));
01545 
01546       if (yyss + yystacksize - 1 <= yyssp)
01547        YYABORT;
01548     }
01549 
01550   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
01551 
01552   if (yystate == YYFINAL)
01553     YYACCEPT;
01554 
01555   goto yybackup;
01556 
01557 /*-----------.
01558 | yybackup.  |
01559 `-----------*/
01560 yybackup:
01561 
01562   /* Do appropriate processing given the current state.  Read a
01563      lookahead token if we need one and don't already have one.  */
01564 
01565   /* First try to decide what to do without reference to lookahead token.  */
01566   yyn = yypact[yystate];
01567   if (yyn == YYPACT_NINF)
01568     goto yydefault;
01569 
01570   /* Not known => get a lookahead token if don't already have one.  */
01571 
01572   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
01573   if (yychar == YYEMPTY)
01574     {
01575       YYDPRINTF ((stderr, "Reading a token: "));
01576       yychar = YYLEX;
01577     }
01578 
01579   if (yychar <= YYEOF)
01580     {
01581       yychar = yytoken = YYEOF;
01582       YYDPRINTF ((stderr, "Now at end of input.\n"));
01583     }
01584   else
01585     {
01586       yytoken = YYTRANSLATE (yychar);
01587       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
01588     }
01589 
01590   /* If the proper action on seeing token YYTOKEN is to reduce or to
01591      detect an error, take that action.  */
01592   yyn += yytoken;
01593   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
01594     goto yydefault;
01595   yyn = yytable[yyn];
01596   if (yyn <= 0)
01597     {
01598       if (yyn == 0 || yyn == YYTABLE_NINF)
01599        goto yyerrlab;
01600       yyn = -yyn;
01601       goto yyreduce;
01602     }
01603 
01604   /* Count tokens shifted since error; after three, turn off error
01605      status.  */
01606   if (yyerrstatus)
01607     yyerrstatus--;
01608 
01609   /* Shift the lookahead token.  */
01610   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
01611 
01612   /* Discard the shifted token.  */
01613   yychar = YYEMPTY;
01614 
01615   yystate = yyn;
01616   *++yyvsp = yylval;
01617 
01618   goto yynewstate;
01619 
01620 
01621 /*-----------------------------------------------------------.
01622 | yydefault -- do the default action for the current state.  |
01623 `-----------------------------------------------------------*/
01624 yydefault:
01625   yyn = yydefact[yystate];
01626   if (yyn == 0)
01627     goto yyerrlab;
01628   goto yyreduce;
01629 
01630 
01631 /*-----------------------------.
01632 | yyreduce -- Do a reduction.  |
01633 `-----------------------------*/
01634 yyreduce:
01635   /* yyn is the number of a rule to reduce with.  */
01636   yylen = yyr2[yyn];
01637 
01638   /* If YYLEN is nonzero, implement the default value of the action:
01639      `$$ = $1'.
01640 
01641      Otherwise, the following line sets YYVAL to garbage.
01642      This behavior is undocumented and Bison
01643      users should not rely upon it.  Assigning to YYVAL
01644      unconditionally makes the parser a bit smaller, and it avoids a
01645      GCC warning that YYVAL may be used uninitialized.  */
01646   yyval = yyvsp[1-yylen];
01647 
01648 
01649   YY_REDUCE_PRINT (yyn);
01650   switch (yyn)
01651     {
01652         case 4:
01653 
01654     {
01655 #if DEBUG_CFG_PARSER
01656                      printf("SECTION: [%s]\n", Z_STRVAL((yyvsp[(2) - (3)])));
01657 #endif
01658                      ZEND_INI_PARSER_CB(&(yyvsp[(2) - (3)]), NULL, NULL, ZEND_INI_PARSER_SECTION, ZEND_INI_PARSER_ARG TSRMLS_CC);
01659                      free(Z_STRVAL((yyvsp[(2) - (3)])));
01660               }
01661     break;
01662 
01663   case 5:
01664 
01665     {
01666 #if DEBUG_CFG_PARSER
01667                      printf("NORMAL: '%s' = '%s'\n", Z_STRVAL((yyvsp[(1) - (3)])), Z_STRVAL((yyvsp[(3) - (3)])));
01668 #endif
01669                      ZEND_INI_PARSER_CB(&(yyvsp[(1) - (3)]), &(yyvsp[(3) - (3)]), NULL, ZEND_INI_PARSER_ENTRY, ZEND_INI_PARSER_ARG TSRMLS_CC);
01670                      free(Z_STRVAL((yyvsp[(1) - (3)])));
01671                      free(Z_STRVAL((yyvsp[(3) - (3)])));
01672               }
01673     break;
01674 
01675   case 6:
01676 
01677     {
01678 #if DEBUG_CFG_PARSER
01679                      printf("OFFSET: '%s'[%s] = '%s'\n", Z_STRVAL((yyvsp[(1) - (5)])), Z_STRVAL((yyvsp[(2) - (5)])), Z_STRVAL((yyvsp[(5) - (5)])));
01680 #endif
01681                      ZEND_INI_PARSER_CB(&(yyvsp[(1) - (5)]), &(yyvsp[(5) - (5)]), &(yyvsp[(2) - (5)]), ZEND_INI_PARSER_POP_ENTRY, ZEND_INI_PARSER_ARG TSRMLS_CC);
01682                      free(Z_STRVAL((yyvsp[(1) - (5)])));
01683                      free(Z_STRVAL((yyvsp[(2) - (5)])));
01684                      free(Z_STRVAL((yyvsp[(5) - (5)])));
01685               }
01686     break;
01687 
01688   case 7:
01689 
01690     { ZEND_INI_PARSER_CB(&(yyvsp[(1) - (1)]), NULL, NULL, ZEND_INI_PARSER_ENTRY, ZEND_INI_PARSER_ARG TSRMLS_CC); free(Z_STRVAL((yyvsp[(1) - (1)]))); }
01691     break;
01692 
01693   case 9:
01694 
01695     { (yyval) = (yyvsp[(1) - (1)]); }
01696     break;
01697 
01698   case 10:
01699 
01700     { zend_ini_init_string(&(yyval)); }
01701     break;
01702 
01703   case 11:
01704 
01705     { (yyval) = (yyvsp[(1) - (1)]); }
01706     break;
01707 
01708   case 12:
01709 
01710     { (yyval) = (yyvsp[(1) - (1)]); }
01711     break;
01712 
01713   case 13:
01714 
01715     { (yyval) = (yyvsp[(1) - (1)]); }
01716     break;
01717 
01718   case 14:
01719 
01720     { zend_ini_init_string(&(yyval)); }
01721     break;
01722 
01723   case 15:
01724 
01725     { (yyval) = (yyvsp[(1) - (1)]); }
01726     break;
01727 
01728   case 16:
01729 
01730     { zend_ini_init_string(&(yyval)); }
01731     break;
01732 
01733   case 17:
01734 
01735     { zend_ini_add_string(&(yyval), &(yyvsp[(1) - (2)]), &(yyvsp[(2) - (2)])); free(Z_STRVAL((yyvsp[(2) - (2)]))); }
01736     break;
01737 
01738   case 18:
01739 
01740     { zend_ini_add_string(&(yyval), &(yyvsp[(1) - (2)]), &(yyvsp[(2) - (2)])); free(Z_STRVAL((yyvsp[(2) - (2)]))); }
01741     break;
01742 
01743   case 19:
01744 
01745     { zend_ini_init_string(&(yyval)); }
01746     break;
01747 
01748   case 20:
01749 
01750     { (yyval) = (yyvsp[(1) - (1)]); }
01751     break;
01752 
01753   case 21:
01754 
01755     { (yyval) = (yyvsp[(1) - (1)]); }
01756     break;
01757 
01758   case 22:
01759 
01760     { (yyval) = (yyvsp[(2) - (3)]); }
01761     break;
01762 
01763   case 23:
01764 
01765     { zend_ini_add_string(&(yyval), &(yyvsp[(1) - (2)]), &(yyvsp[(2) - (2)])); free(Z_STRVAL((yyvsp[(2) - (2)]))); }
01766     break;
01767 
01768   case 24:
01769 
01770     { zend_ini_add_string(&(yyval), &(yyvsp[(1) - (2)]), &(yyvsp[(2) - (2)])); free(Z_STRVAL((yyvsp[(2) - (2)]))); }
01771     break;
01772 
01773   case 25:
01774 
01775     { zend_ini_add_string(&(yyval), &(yyvsp[(1) - (4)]), &(yyvsp[(3) - (4)])); free(Z_STRVAL((yyvsp[(3) - (4)]))); }
01776     break;
01777 
01778   case 26:
01779 
01780     { (yyval) = (yyvsp[(1) - (1)]); }
01781     break;
01782 
01783   case 27:
01784 
01785     { (yyval) = (yyvsp[(1) - (1)]); }
01786     break;
01787 
01788   case 28:
01789 
01790     { (yyval) = (yyvsp[(2) - (3)]); }
01791     break;
01792 
01793   case 29:
01794 
01795     { zend_ini_add_string(&(yyval), &(yyvsp[(1) - (2)]), &(yyvsp[(2) - (2)])); free(Z_STRVAL((yyvsp[(2) - (2)]))); }
01796     break;
01797 
01798   case 30:
01799 
01800     { zend_ini_add_string(&(yyval), &(yyvsp[(1) - (2)]), &(yyvsp[(2) - (2)])); free(Z_STRVAL((yyvsp[(2) - (2)]))); }
01801     break;
01802 
01803   case 31:
01804 
01805     { zend_ini_add_string(&(yyval), &(yyvsp[(1) - (4)]), &(yyvsp[(3) - (4)])); free(Z_STRVAL((yyvsp[(3) - (4)]))); }
01806     break;
01807 
01808   case 32:
01809 
01810     { (yyval) = (yyvsp[(1) - (1)]); }
01811     break;
01812 
01813   case 33:
01814 
01815     { zend_ini_do_op('|', &(yyval), &(yyvsp[(1) - (3)]), &(yyvsp[(3) - (3)])); }
01816     break;
01817 
01818   case 34:
01819 
01820     { zend_ini_do_op('&', &(yyval), &(yyvsp[(1) - (3)]), &(yyvsp[(3) - (3)])); }
01821     break;
01822 
01823   case 35:
01824 
01825     { zend_ini_do_op('~', &(yyval), &(yyvsp[(2) - (2)]), NULL); }
01826     break;
01827 
01828   case 36:
01829 
01830     { zend_ini_do_op('!', &(yyval), &(yyvsp[(2) - (2)]), NULL); }
01831     break;
01832 
01833   case 37:
01834 
01835     { (yyval) = (yyvsp[(2) - (3)]); }
01836     break;
01837 
01838   case 38:
01839 
01840     { zend_ini_get_var(&(yyval), &(yyvsp[(2) - (3)]) TSRMLS_CC); free(Z_STRVAL((yyvsp[(2) - (3)]))); }
01841     break;
01842 
01843   case 39:
01844 
01845     { (yyval) = (yyvsp[(1) - (1)]); }
01846     break;
01847 
01848   case 40:
01849 
01850     { (yyval) = (yyvsp[(1) - (1)]); /*printf("TC_RAW: '%s'\n", Z_STRVAL($1));*/ }
01851     break;
01852 
01853   case 41:
01854 
01855     { (yyval) = (yyvsp[(1) - (1)]); /*printf("TC_NUMBER: '%s'\n", Z_STRVAL($1));*/ }
01856     break;
01857 
01858   case 42:
01859 
01860     { (yyval) = (yyvsp[(1) - (1)]); /*printf("TC_STRING: '%s'\n", Z_STRVAL($1));*/ }
01861     break;
01862 
01863   case 43:
01864 
01865     { (yyval) = (yyvsp[(1) - (1)]); /*printf("TC_WHITESPACE: '%s'\n", Z_STRVAL($1));*/ }
01866     break;
01867 
01868   case 44:
01869 
01870     { zend_ini_get_constant(&(yyval), &(yyvsp[(1) - (1)]) TSRMLS_CC); }
01871     break;
01872 
01873   case 45:
01874 
01875     { (yyval) = (yyvsp[(1) - (1)]); /*printf("TC_RAW: '%s'\n", Z_STRVAL($1));*/ }
01876     break;
01877 
01878   case 46:
01879 
01880     { (yyval) = (yyvsp[(1) - (1)]); /*printf("TC_NUMBER: '%s'\n", Z_STRVAL($1));*/ }
01881     break;
01882 
01883   case 47:
01884 
01885     { (yyval) = (yyvsp[(1) - (1)]); /*printf("TC_STRING: '%s'\n", Z_STRVAL($1));*/ }
01886     break;
01887 
01888   case 48:
01889 
01890     { (yyval) = (yyvsp[(1) - (1)]); /*printf("TC_WHITESPACE: '%s'\n", Z_STRVAL($1));*/ }
01891     break;
01892 
01893 
01894 
01895       default: break;
01896     }
01897   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
01898 
01899   YYPOPSTACK (yylen);
01900   yylen = 0;
01901   YY_STACK_PRINT (yyss, yyssp);
01902 
01903   *++yyvsp = yyval;
01904 
01905   /* Now `shift' the result of the reduction.  Determine what state
01906      that goes to, based on the state we popped back to and the rule
01907      number reduced by.  */
01908 
01909   yyn = yyr1[yyn];
01910 
01911   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
01912   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
01913     yystate = yytable[yystate];
01914   else
01915     yystate = yydefgoto[yyn - YYNTOKENS];
01916 
01917   goto yynewstate;
01918 
01919 
01920 /*------------------------------------.
01921 | yyerrlab -- here on detecting error |
01922 `------------------------------------*/
01923 yyerrlab:
01924   /* If not already recovering from an error, report this error.  */
01925   if (!yyerrstatus)
01926     {
01927       ++yynerrs;
01928 #if ! YYERROR_VERBOSE
01929       yyerror (YY_("syntax error"));
01930 #else
01931       {
01932        YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
01933        if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
01934          {
01935            YYSIZE_T yyalloc = 2 * yysize;
01936            if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
01937              yyalloc = YYSTACK_ALLOC_MAXIMUM;
01938            if (yymsg != yymsgbuf)
01939              YYSTACK_FREE (yymsg);
01940            yymsg = (char *) YYSTACK_ALLOC (yyalloc);
01941            if (yymsg)
01942              yymsg_alloc = yyalloc;
01943            else
01944              {
01945               yymsg = yymsgbuf;
01946               yymsg_alloc = sizeof yymsgbuf;
01947              }
01948          }
01949 
01950        if (0 < yysize && yysize <= yymsg_alloc)
01951          {
01952            (void) yysyntax_error (yymsg, yystate, yychar);
01953            yyerror (yymsg);
01954          }
01955        else
01956          {
01957            yyerror (YY_("syntax error"));
01958            if (yysize != 0)
01959              goto yyexhaustedlab;
01960          }
01961       }
01962 #endif
01963     }
01964 
01965 
01966 
01967   if (yyerrstatus == 3)
01968     {
01969       /* If just tried and failed to reuse lookahead token after an
01970         error, discard it.  */
01971 
01972       if (yychar <= YYEOF)
01973        {
01974          /* Return failure if at end of input.  */
01975          if (yychar == YYEOF)
01976            YYABORT;
01977        }
01978       else
01979        {
01980          yydestruct ("Error: discarding",
01981                     yytoken, &yylval);
01982          yychar = YYEMPTY;
01983        }
01984     }
01985 
01986   /* Else will try to reuse lookahead token after shifting the error
01987      token.  */
01988   goto yyerrlab1;
01989 
01990 
01991 /*---------------------------------------------------.
01992 | yyerrorlab -- error raised explicitly by YYERROR.  |
01993 `---------------------------------------------------*/
01994 yyerrorlab:
01995 
01996   /* Pacify compilers like GCC when the user code never invokes
01997      YYERROR and the label yyerrorlab therefore never appears in user
01998      code.  */
01999   if (/*CONSTCOND*/ 0)
02000      goto yyerrorlab;
02001 
02002   /* Do not reclaim the symbols of the rule which action triggered
02003      this YYERROR.  */
02004   YYPOPSTACK (yylen);
02005   yylen = 0;
02006   YY_STACK_PRINT (yyss, yyssp);
02007   yystate = *yyssp;
02008   goto yyerrlab1;
02009 
02010 
02011 /*-------------------------------------------------------------.
02012 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
02013 `-------------------------------------------------------------*/
02014 yyerrlab1:
02015   yyerrstatus = 3;   /* Each real token shifted decrements this.  */
02016 
02017   for (;;)
02018     {
02019       yyn = yypact[yystate];
02020       if (yyn != YYPACT_NINF)
02021        {
02022          yyn += YYTERROR;
02023          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
02024            {
02025              yyn = yytable[yyn];
02026              if (0 < yyn)
02027               break;
02028            }
02029        }
02030 
02031       /* Pop the current state because it cannot handle the error token.  */
02032       if (yyssp == yyss)
02033        YYABORT;
02034 
02035 
02036       yydestruct ("Error: popping",
02037                 yystos[yystate], yyvsp);
02038       YYPOPSTACK (1);
02039       yystate = *yyssp;
02040       YY_STACK_PRINT (yyss, yyssp);
02041     }
02042 
02043   *++yyvsp = yylval;
02044 
02045 
02046   /* Shift the error token.  */
02047   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
02048 
02049   yystate = yyn;
02050   goto yynewstate;
02051 
02052 
02053 /*-------------------------------------.
02054 | yyacceptlab -- YYACCEPT comes here.  |
02055 `-------------------------------------*/
02056 yyacceptlab:
02057   yyresult = 0;
02058   goto yyreturn;
02059 
02060 /*-----------------------------------.
02061 | yyabortlab -- YYABORT comes here.  |
02062 `-----------------------------------*/
02063 yyabortlab:
02064   yyresult = 1;
02065   goto yyreturn;
02066 
02067 #if !defined(yyoverflow) || YYERROR_VERBOSE
02068 /*-------------------------------------------------.
02069 | yyexhaustedlab -- memory exhaustion comes here.  |
02070 `-------------------------------------------------*/
02071 yyexhaustedlab:
02072   yyerror (YY_("memory exhausted"));
02073   yyresult = 2;
02074   /* Fall through.  */
02075 #endif
02076 
02077 yyreturn:
02078   if (yychar != YYEMPTY)
02079      yydestruct ("Cleanup: discarding lookahead",
02080                yytoken, &yylval);
02081   /* Do not reclaim the symbols of the rule which action triggered
02082      this YYABORT or YYACCEPT.  */
02083   YYPOPSTACK (yylen);
02084   YY_STACK_PRINT (yyss, yyssp);
02085   while (yyssp != yyss)
02086     {
02087       yydestruct ("Cleanup: popping",
02088                 yystos[*yyssp], yyvsp);
02089       YYPOPSTACK (1);
02090     }
02091 #ifndef yyoverflow
02092   if (yyss != yyssa)
02093     YYSTACK_FREE (yyss);
02094 #endif
02095 #if YYERROR_VERBOSE
02096   if (yymsg != yymsgbuf)
02097     YYSTACK_FREE (yymsg);
02098 #endif
02099   /* Make sure YYID is used.  */
02100   return YYID (yyresult);
02101 }
02102 
02103 
02104