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