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