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