Annotation of embedaddon/lighttpd/src/configparser.c, revision 1.1
1.1 ! misho 1: /* Driver template for the LEMON parser generator.
! 2: ** The author disclaims copyright to this source code.
! 3: */
! 4: /* First off, code is include which follows the "include" declaration
! 5: ** in the input file. */
! 6: #include <stdio.h>
! 7: #line 5 "../../src/configparser.y"
! 8:
! 9: #include "configfile.h"
! 10: #include "buffer.h"
! 11: #include "array.h"
! 12:
! 13: #include <assert.h>
! 14: #include <stdio.h>
! 15: #include <string.h>
! 16:
! 17: static void configparser_push(config_t *ctx, data_config *dc, int isnew) {
! 18: if (isnew) {
! 19: dc->context_ndx = ctx->all_configs->used;
! 20: assert(dc->context_ndx > ctx->current->context_ndx);
! 21: array_insert_unique(ctx->all_configs, (data_unset *)dc);
! 22: dc->parent = ctx->current;
! 23: array_insert_unique(dc->parent->childs, (data_unset *)dc);
! 24: }
! 25: if (ctx->configs_stack->used > 0 && ctx->current->context_ndx == 0) {
! 26: fprintf(stderr, "Cannot use conditionals inside a global { ... } block\n");
! 27: exit(-1);
! 28: }
! 29: array_insert_unique(ctx->configs_stack, (data_unset *)ctx->current);
! 30: ctx->current = dc;
! 31: }
! 32:
! 33: static data_config *configparser_pop(config_t *ctx) {
! 34: data_config *old = ctx->current;
! 35: ctx->current = (data_config *) array_pop(ctx->configs_stack);
! 36: return old;
! 37: }
! 38:
! 39: /* return a copied variable */
! 40: static data_unset *configparser_get_variable(config_t *ctx, const buffer *key) {
! 41: data_unset *du;
! 42: data_config *dc;
! 43:
! 44: #if 0
! 45: fprintf(stderr, "get var %s\n", key->ptr);
! 46: #endif
! 47: for (dc = ctx->current; dc; dc = dc->parent) {
! 48: #if 0
! 49: fprintf(stderr, "get var on block: %s\n", dc->key->ptr);
! 50: array_print(dc->value, 0);
! 51: #endif
! 52: if (NULL != (du = array_get_element(dc->value, key->ptr))) {
! 53: return du->copy(du);
! 54: }
! 55: }
! 56: return NULL;
! 57: }
! 58:
! 59: /* op1 is to be eat/return by this function if success, op1->key is not cared
! 60: op2 is left untouch, unreferenced
! 61: */
! 62: data_unset *configparser_merge_data(data_unset *op1, const data_unset *op2) {
! 63: /* type mismatch */
! 64: if (op1->type != op2->type) {
! 65: if (op1->type == TYPE_STRING && op2->type == TYPE_INTEGER) {
! 66: data_string *ds = (data_string *)op1;
! 67: buffer_append_long(ds->value, ((data_integer*)op2)->value);
! 68: return op1;
! 69: } else if (op1->type == TYPE_INTEGER && op2->type == TYPE_STRING) {
! 70: data_string *ds = data_string_init();
! 71: buffer_append_long(ds->value, ((data_integer*)op1)->value);
! 72: buffer_append_string_buffer(ds->value, ((data_string*)op2)->value);
! 73: op1->free(op1);
! 74: return (data_unset *)ds;
! 75: } else {
! 76: fprintf(stderr, "data type mismatch, cannot merge\n");
! 77: return NULL;
! 78: }
! 79: }
! 80:
! 81: switch (op1->type) {
! 82: case TYPE_STRING:
! 83: buffer_append_string_buffer(((data_string *)op1)->value, ((data_string *)op2)->value);
! 84: break;
! 85: case TYPE_INTEGER:
! 86: ((data_integer *)op1)->value += ((data_integer *)op2)->value;
! 87: break;
! 88: case TYPE_ARRAY: {
! 89: array *dst = ((data_array *)op1)->value;
! 90: array *src = ((data_array *)op2)->value;
! 91: data_unset *du;
! 92: size_t i;
! 93:
! 94: for (i = 0; i < src->used; i ++) {
! 95: du = (data_unset *)src->data[i];
! 96: if (du) {
! 97: array_insert_unique(dst, du->copy(du));
! 98: }
! 99: }
! 100: break;
! 101: default:
! 102: assert(0);
! 103: break;
! 104: }
! 105: }
! 106: return op1;
! 107: }
! 108:
! 109:
! 110: #line 111 "configparser.c"
! 111: /* Next is all token values, in a form suitable for use by makeheaders.
! 112: ** This section will be null unless lemon is run with the -m switch.
! 113: */
! 114: /*
! 115: ** These constants (all generated automatically by the parser generator)
! 116: ** specify the various kinds of tokens (terminals) that the parser
! 117: ** understands.
! 118: **
! 119: ** Each symbol here is a terminal symbol in the grammar.
! 120: */
! 121: /* Make sure the INTERFACE macro is defined.
! 122: */
! 123: #ifndef INTERFACE
! 124: # define INTERFACE 1
! 125: #endif
! 126: /* The next thing included is series of defines which control
! 127: ** various aspects of the generated parser.
! 128: ** YYCODETYPE is the data type used for storing terminal
! 129: ** and nonterminal numbers. "unsigned char" is
! 130: ** used if there are fewer than 250 terminals
! 131: ** and nonterminals. "int" is used otherwise.
! 132: ** YYNOCODE is a number of type YYCODETYPE which corresponds
! 133: ** to no legal terminal or nonterminal number. This
! 134: ** number is used to fill in empty slots of the hash
! 135: ** table.
! 136: ** YYFALLBACK If defined, this indicates that one or more tokens
! 137: ** have fall-back values which should be used if the
! 138: ** original value of the token will not parse.
! 139: ** YYACTIONTYPE is the data type used for storing terminal
! 140: ** and nonterminal numbers. "unsigned char" is
! 141: ** used if there are fewer than 250 rules and
! 142: ** states combined. "int" is used otherwise.
! 143: ** configparserTOKENTYPE is the data type used for minor tokens given
! 144: ** directly to the parser from the tokenizer.
! 145: ** YYMINORTYPE is the data type used for all minor tokens.
! 146: ** This is typically a union of many types, one of
! 147: ** which is configparserTOKENTYPE. The entry in the union
! 148: ** for base tokens is called "yy0".
! 149: ** YYSTACKDEPTH is the maximum depth of the parser's stack.
! 150: ** configparserARG_SDECL A static variable declaration for the %extra_argument
! 151: ** configparserARG_PDECL A parameter declaration for the %extra_argument
! 152: ** configparserARG_STORE Code to store %extra_argument into yypParser
! 153: ** configparserARG_FETCH Code to extract %extra_argument from yypParser
! 154: ** YYNSTATE the combined number of states.
! 155: ** YYNRULE the number of rules in the grammar
! 156: ** YYERRORSYMBOL is the code number of the error symbol. If not
! 157: ** defined, then do no error processing.
! 158: */
! 159: /* & */
! 160: #define YYCODETYPE unsigned char
! 161: #define YYNOCODE 48
! 162: #define YYACTIONTYPE unsigned char
! 163: #define configparserTOKENTYPE buffer *
! 164: typedef union {
! 165: configparserTOKENTYPE yy0;
! 166: config_cond_t yy27;
! 167: array * yy40;
! 168: data_unset * yy41;
! 169: buffer * yy43;
! 170: data_config * yy78;
! 171: int yy95;
! 172: } YYMINORTYPE;
! 173: #define YYSTACKDEPTH 100
! 174: #define configparserARG_SDECL config_t *ctx;
! 175: #define configparserARG_PDECL ,config_t *ctx
! 176: #define configparserARG_FETCH config_t *ctx = yypParser->ctx
! 177: #define configparserARG_STORE yypParser->ctx = ctx
! 178: #define YYNSTATE 63
! 179: #define YYNRULE 40
! 180: #define YYERRORSYMBOL 26
! 181: #define YYERRSYMDT yy95
! 182: #define YY_NO_ACTION (YYNSTATE+YYNRULE+2)
! 183: #define YY_ACCEPT_ACTION (YYNSTATE+YYNRULE+1)
! 184: #define YY_ERROR_ACTION (YYNSTATE+YYNRULE)
! 185:
! 186: /* Next are that tables used to determine what action to take based on the
! 187: ** current state and lookahead token. These tables are used to implement
! 188: ** functions that take a state number and lookahead value and return an
! 189: ** action integer.
! 190: **
! 191: ** Suppose the action integer is N. Then the action is determined as
! 192: ** follows
! 193: **
! 194: ** 0 <= N < YYNSTATE Shift N. That is, push the lookahead
! 195: ** token onto the stack and goto state N.
! 196: **
! 197: ** YYNSTATE <= N < YYNSTATE+YYNRULE Reduce by rule N-YYNSTATE.
! 198: **
! 199: ** N == YYNSTATE+YYNRULE A syntax error has occurred.
! 200: **
! 201: ** N == YYNSTATE+YYNRULE+1 The parser accepts its input.
! 202: **
! 203: ** N == YYNSTATE+YYNRULE+2 No such action. Denotes unused
! 204: ** slots in the yy_action[] table.
! 205: **
! 206: ** The action table is constructed as a single large table named yy_action[].
! 207: ** Given state S and lookahead X, the action is computed as
! 208: **
! 209: ** yy_action[ yy_shift_ofst[S] + X ]
! 210: **
! 211: ** If the index value yy_shift_ofst[S]+X is out of range or if the value
! 212: ** yy_lookahead[yy_shift_ofst[S]+X] is not equal to X or if yy_shift_ofst[S]
! 213: ** is equal to YY_SHIFT_USE_DFLT, it means that the action is not in the table
! 214: ** and that yy_default[S] should be used instead.
! 215: **
! 216: ** The formula above is for computing the action when the lookahead is
! 217: ** a terminal symbol. If the lookahead is a non-terminal (as occurs after
! 218: ** a reduce action) then the yy_reduce_ofst[] array is used in place of
! 219: ** the yy_shift_ofst[] array and YY_REDUCE_USE_DFLT is used in place of
! 220: ** YY_SHIFT_USE_DFLT.
! 221: **
! 222: ** The following are the tables generated in this section:
! 223: **
! 224: ** yy_action[] A single table containing all actions.
! 225: ** yy_lookahead[] A table containing the lookahead for each entry in
! 226: ** yy_action. Used to detect hash collisions.
! 227: ** yy_shift_ofst[] For each state, the offset into yy_action for
! 228: ** shifting terminals.
! 229: ** yy_reduce_ofst[] For each state, the offset into yy_action for
! 230: ** shifting non-terminals after a reduce.
! 231: ** yy_default[] Default action for each state.
! 232: */
! 233: static YYACTIONTYPE yy_action[] = {
! 234: /* 0 */ 2, 3, 4, 5, 13, 14, 63, 15, 7, 45,
! 235: /* 10 */ 20, 88, 16, 46, 28, 49, 41, 10, 40, 25,
! 236: /* 20 */ 22, 50, 46, 8, 15, 104, 1, 20, 28, 18,
! 237: /* 30 */ 58, 60, 6, 25, 22, 40, 47, 62, 11, 46,
! 238: /* 40 */ 20, 9, 23, 24, 26, 29, 89, 58, 60, 10,
! 239: /* 50 */ 17, 38, 28, 27, 37, 19, 30, 25, 22, 34,
! 240: /* 60 */ 15, 100, 20, 20, 23, 24, 26, 12, 19, 31,
! 241: /* 70 */ 32, 40, 19, 44, 43, 46, 95, 35, 90, 89,
! 242: /* 80 */ 28, 49, 42, 58, 60, 25, 22, 59, 28, 27,
! 243: /* 90 */ 33, 48, 52, 25, 22, 34, 28, 49, 51, 28,
! 244: /* 100 */ 36, 25, 22, 61, 25, 22, 89, 28, 39, 89,
! 245: /* 110 */ 89, 89, 25, 22, 54, 55, 56, 57, 89, 28,
! 246: /* 120 */ 53, 21, 89, 89, 25, 22, 25, 22,
! 247: };
! 248: static YYCODETYPE yy_lookahead[] = {
! 249: /* 0 */ 29, 30, 31, 32, 33, 34, 0, 1, 44, 38,
! 250: /* 10 */ 4, 15, 41, 16, 35, 36, 45, 46, 12, 40,
! 251: /* 20 */ 41, 42, 16, 15, 1, 27, 28, 4, 35, 36,
! 252: /* 30 */ 24, 25, 1, 40, 41, 12, 17, 14, 13, 16,
! 253: /* 40 */ 4, 38, 6, 7, 8, 9, 15, 24, 25, 46,
! 254: /* 50 */ 2, 3, 35, 36, 37, 5, 39, 40, 41, 42,
! 255: /* 60 */ 1, 11, 4, 4, 6, 7, 8, 28, 5, 9,
! 256: /* 70 */ 10, 12, 5, 14, 28, 16, 13, 11, 13, 47,
! 257: /* 80 */ 35, 36, 13, 24, 25, 40, 41, 42, 35, 36,
! 258: /* 90 */ 37, 18, 43, 40, 41, 42, 35, 36, 19, 35,
! 259: /* 100 */ 36, 40, 41, 42, 40, 41, 47, 35, 36, 47,
! 260: /* 110 */ 47, 47, 40, 41, 20, 21, 22, 23, 47, 35,
! 261: /* 120 */ 36, 35, 47, 47, 40, 41, 40, 41,
! 262: };
! 263: #define YY_SHIFT_USE_DFLT (-5)
! 264: static signed char yy_shift_ofst[] = {
! 265: /* 0 */ -5, 6, -5, -5, -5, 31, -4, 8, -3, -5,
! 266: /* 10 */ 25, -5, 23, -5, -5, -5, 48, 58, 67, 58,
! 267: /* 20 */ -5, -5, -5, -5, -5, -5, 36, 50, -5, -5,
! 268: /* 30 */ 60, -5, 58, -5, 66, 58, 67, -5, 58, 67,
! 269: /* 40 */ 65, 69, -5, 59, -5, -5, 19, 73, 58, 67,
! 270: /* 50 */ 79, 94, 58, 63, -5, -5, -5, -5, 58, -5,
! 271: /* 60 */ 58, -5, -5,
! 272: };
! 273: #define YY_REDUCE_USE_DFLT (-37)
! 274: static signed char yy_reduce_ofst[] = {
! 275: /* 0 */ -2, -29, -37, -37, -37, -36, -37, -37, 3, -37,
! 276: /* 10 */ -37, 39, -29, -37, -37, -37, -37, -7, -37, 86,
! 277: /* 20 */ -37, -37, -37, -37, -37, -37, 17, -37, -37, -37,
! 278: /* 30 */ -37, -37, 53, -37, -37, 64, -37, -37, 72, -37,
! 279: /* 40 */ -37, -37, 46, -29, -37, -37, -37, -37, -21, -37,
! 280: /* 50 */ -37, 49, 84, -37, -37, -37, -37, -37, 45, -37,
! 281: /* 60 */ 61, -37, -37,
! 282: };
! 283: static YYACTIONTYPE yy_default[] = {
! 284: /* 0 */ 65, 103, 64, 66, 67, 103, 68, 103, 103, 92,
! 285: /* 10 */ 103, 65, 103, 69, 70, 71, 103, 103, 72, 103,
! 286: /* 20 */ 74, 75, 77, 78, 79, 80, 103, 86, 76, 81,
! 287: /* 30 */ 103, 82, 84, 83, 103, 103, 87, 85, 103, 73,
! 288: /* 40 */ 103, 103, 65, 103, 91, 93, 103, 103, 103, 100,
! 289: /* 50 */ 103, 103, 103, 103, 96, 97, 98, 99, 103, 101,
! 290: /* 60 */ 103, 102, 94,
! 291: };
! 292: #define YY_SZ_ACTTAB (sizeof(yy_action)/sizeof(yy_action[0]))
! 293:
! 294: /* The next table maps tokens into fallback tokens. If a construct
! 295: ** like the following:
! 296: **
! 297: ** %fallback ID X Y Z.
! 298: **
! 299: ** appears in the grammer, then ID becomes a fallback token for X, Y,
! 300: ** and Z. Whenever one of the tokens X, Y, or Z is input to the parser
! 301: ** but it does not parse, the type of the token is changed to ID and
! 302: ** the parse is retried before an error is thrown.
! 303: */
! 304: #ifdef YYFALLBACK
! 305: static const YYCODETYPE yyFallback[] = {
! 306: };
! 307: #endif /* YYFALLBACK */
! 308:
! 309: /* The following structure represents a single element of the
! 310: ** parser's stack. Information stored includes:
! 311: **
! 312: ** + The state number for the parser at this level of the stack.
! 313: **
! 314: ** + The value of the token stored at this level of the stack.
! 315: ** (In other words, the "major" token.)
! 316: **
! 317: ** + The semantic value stored at this level of the stack. This is
! 318: ** the information used by the action routines in the grammar.
! 319: ** It is sometimes called the "minor" token.
! 320: */
! 321: struct yyStackEntry {
! 322: int stateno; /* The state-number */
! 323: int major; /* The major token value. This is the code
! 324: ** number for the token at this stack level */
! 325: YYMINORTYPE minor; /* The user-supplied minor token value. This
! 326: ** is the value of the token */
! 327: };
! 328: typedef struct yyStackEntry yyStackEntry;
! 329:
! 330: /* The state of the parser is completely contained in an instance of
! 331: ** the following structure */
! 332: struct yyParser {
! 333: int yyidx; /* Index of top element in stack */
! 334: int yyerrcnt; /* Shifts left before out of the error */
! 335: configparserARG_SDECL /* A place to hold %extra_argument */
! 336: yyStackEntry yystack[YYSTACKDEPTH]; /* The parser's stack */
! 337: };
! 338: typedef struct yyParser yyParser;
! 339:
! 340: #ifndef NDEBUG
! 341: #include <stdio.h>
! 342: static FILE *yyTraceFILE = NULL;
! 343: static char *yyTracePrompt = NULL;
! 344: #endif /* NDEBUG */
! 345:
! 346: #ifndef NDEBUG
! 347: /*
! 348: ** Turn parser tracing on by giving a stream to which to write the trace
! 349: ** and a prompt to preface each trace message. Tracing is turned off
! 350: ** by making either argument NULL
! 351: **
! 352: ** Inputs:
! 353: ** <ul>
! 354: ** <li> A FILE* to which trace output should be written.
! 355: ** If NULL, then tracing is turned off.
! 356: ** <li> A prefix string written at the beginning of every
! 357: ** line of trace output. If NULL, then tracing is
! 358: ** turned off.
! 359: ** </ul>
! 360: **
! 361: ** Outputs:
! 362: ** None.
! 363: */
! 364: #if 0
! 365: void configparserTrace(FILE *TraceFILE, char *zTracePrompt){
! 366: yyTraceFILE = TraceFILE;
! 367: yyTracePrompt = zTracePrompt;
! 368: if( yyTraceFILE==0 ) yyTracePrompt = 0;
! 369: else if( yyTracePrompt==0 ) yyTraceFILE = 0;
! 370: }
! 371: #endif
! 372: #endif /* NDEBUG */
! 373:
! 374: #ifndef NDEBUG
! 375: /* For tracing shifts, the names of all terminals and nonterminals
! 376: ** are required. The following table supplies these names */
! 377: static const char *yyTokenName[] = {
! 378: "$", "EOL", "ASSIGN", "APPEND",
! 379: "LKEY", "PLUS", "STRING", "INTEGER",
! 380: "LPARAN", "RPARAN", "COMMA", "ARRAY_ASSIGN",
! 381: "GLOBAL", "LCURLY", "RCURLY", "ELSE",
! 382: "DOLLAR", "SRVVARNAME", "LBRACKET", "RBRACKET",
! 383: "EQ", "MATCH", "NE", "NOMATCH",
! 384: "INCLUDE", "INCLUDE_SHELL", "error", "input",
! 385: "metalines", "metaline", "varline", "global",
! 386: "condlines", "include", "include_shell", "value",
! 387: "expression", "aelement", "condline", "aelements",
! 388: "array", "key", "stringop", "cond",
! 389: "eols", "globalstart", "context",
! 390: };
! 391: #endif /* NDEBUG */
! 392:
! 393: #ifndef NDEBUG
! 394: /* For tracing reduce actions, the names of all rules are required.
! 395: */
! 396: static const char *yyRuleName[] = {
! 397: /* 0 */ "input ::= metalines",
! 398: /* 1 */ "metalines ::= metalines metaline",
! 399: /* 2 */ "metalines ::=",
! 400: /* 3 */ "metaline ::= varline",
! 401: /* 4 */ "metaline ::= global",
! 402: /* 5 */ "metaline ::= condlines EOL",
! 403: /* 6 */ "metaline ::= include",
! 404: /* 7 */ "metaline ::= include_shell",
! 405: /* 8 */ "metaline ::= EOL",
! 406: /* 9 */ "varline ::= key ASSIGN expression",
! 407: /* 10 */ "varline ::= key APPEND expression",
! 408: /* 11 */ "key ::= LKEY",
! 409: /* 12 */ "expression ::= expression PLUS value",
! 410: /* 13 */ "expression ::= value",
! 411: /* 14 */ "value ::= key",
! 412: /* 15 */ "value ::= STRING",
! 413: /* 16 */ "value ::= INTEGER",
! 414: /* 17 */ "value ::= array",
! 415: /* 18 */ "array ::= LPARAN RPARAN",
! 416: /* 19 */ "array ::= LPARAN aelements RPARAN",
! 417: /* 20 */ "aelements ::= aelements COMMA aelement",
! 418: /* 21 */ "aelements ::= aelements COMMA",
! 419: /* 22 */ "aelements ::= aelement",
! 420: /* 23 */ "aelement ::= expression",
! 421: /* 24 */ "aelement ::= stringop ARRAY_ASSIGN expression",
! 422: /* 25 */ "eols ::= EOL",
! 423: /* 26 */ "eols ::=",
! 424: /* 27 */ "globalstart ::= GLOBAL",
! 425: /* 28 */ "global ::= globalstart LCURLY metalines RCURLY",
! 426: /* 29 */ "condlines ::= condlines eols ELSE condline",
! 427: /* 30 */ "condlines ::= condline",
! 428: /* 31 */ "condline ::= context LCURLY metalines RCURLY",
! 429: /* 32 */ "context ::= DOLLAR SRVVARNAME LBRACKET stringop RBRACKET cond expression",
! 430: /* 33 */ "cond ::= EQ",
! 431: /* 34 */ "cond ::= MATCH",
! 432: /* 35 */ "cond ::= NE",
! 433: /* 36 */ "cond ::= NOMATCH",
! 434: /* 37 */ "stringop ::= expression",
! 435: /* 38 */ "include ::= INCLUDE stringop",
! 436: /* 39 */ "include_shell ::= INCLUDE_SHELL stringop",
! 437: };
! 438: #endif /* NDEBUG */
! 439:
! 440: /*
! 441: ** This function returns the symbolic name associated with a token
! 442: ** value.
! 443: */
! 444: #if 0
! 445: const char *configparserTokenName(int tokenType){
! 446: #ifndef NDEBUG
! 447: if( tokenType>0 && (size_t)tokenType<(sizeof(yyTokenName)/sizeof(yyTokenName[0])) ){
! 448: return yyTokenName[tokenType];
! 449: }else{
! 450: return "Unknown";
! 451: }
! 452: #else
! 453: return "";
! 454: #endif
! 455: }
! 456: #endif
! 457:
! 458: /*
! 459: ** This function allocates a new parser.
! 460: ** The only argument is a pointer to a function which works like
! 461: ** malloc.
! 462: **
! 463: ** Inputs:
! 464: ** A pointer to the function used to allocate memory.
! 465: **
! 466: ** Outputs:
! 467: ** A pointer to a parser. This pointer is used in subsequent calls
! 468: ** to configparser and configparserFree.
! 469: */
! 470: void *configparserAlloc(void *(*mallocProc)(size_t)){
! 471: yyParser *pParser;
! 472: pParser = (yyParser*)(*mallocProc)( (size_t)sizeof(yyParser) );
! 473: if( pParser ){
! 474: pParser->yyidx = -1;
! 475: }
! 476: return pParser;
! 477: }
! 478:
! 479: /* The following function deletes the value associated with a
! 480: ** symbol. The symbol can be either a terminal or nonterminal.
! 481: ** "yymajor" is the symbol code, and "yypminor" is a pointer to
! 482: ** the value.
! 483: */
! 484: static void yy_destructor(YYCODETYPE yymajor, YYMINORTYPE *yypminor){
! 485: switch( yymajor ){
! 486: /* Here is inserted the actions which take place when a
! 487: ** terminal or non-terminal is destroyed. This can happen
! 488: ** when the symbol is popped from the stack during a
! 489: ** reduce or during error processing or when a parser is
! 490: ** being destroyed before it is finished parsing.
! 491: **
! 492: ** Note: during a reduce, the only symbols destroyed are those
! 493: ** which appear on the RHS of the rule, but which are not used
! 494: ** inside the C code.
! 495: */
! 496: case 1:
! 497: case 2:
! 498: case 3:
! 499: case 4:
! 500: case 5:
! 501: case 6:
! 502: case 7:
! 503: case 8:
! 504: case 9:
! 505: case 10:
! 506: case 11:
! 507: case 12:
! 508: case 13:
! 509: case 14:
! 510: case 15:
! 511: case 16:
! 512: case 17:
! 513: case 18:
! 514: case 19:
! 515: case 20:
! 516: case 21:
! 517: case 22:
! 518: case 23:
! 519: case 24:
! 520: case 25:
! 521: #line 144 "../../src/configparser.y"
! 522: { buffer_free((yypminor->yy0)); }
! 523: #line 523 "configparser.c"
! 524: break;
! 525: case 35:
! 526: #line 135 "../../src/configparser.y"
! 527: { (yypminor->yy41)->free((yypminor->yy41)); }
! 528: #line 528 "configparser.c"
! 529: break;
! 530: case 36:
! 531: #line 136 "../../src/configparser.y"
! 532: { (yypminor->yy41)->free((yypminor->yy41)); }
! 533: #line 533 "configparser.c"
! 534: break;
! 535: case 37:
! 536: #line 137 "../../src/configparser.y"
! 537: { (yypminor->yy41)->free((yypminor->yy41)); }
! 538: #line 538 "configparser.c"
! 539: break;
! 540: case 39:
! 541: #line 138 "../../src/configparser.y"
! 542: { array_free((yypminor->yy40)); }
! 543: #line 543 "configparser.c"
! 544: break;
! 545: case 40:
! 546: #line 139 "../../src/configparser.y"
! 547: { array_free((yypminor->yy40)); }
! 548: #line 548 "configparser.c"
! 549: break;
! 550: case 41:
! 551: #line 140 "../../src/configparser.y"
! 552: { buffer_free((yypminor->yy43)); }
! 553: #line 553 "configparser.c"
! 554: break;
! 555: case 42:
! 556: #line 141 "../../src/configparser.y"
! 557: { buffer_free((yypminor->yy43)); }
! 558: #line 558 "configparser.c"
! 559: break;
! 560: default: break; /* If no destructor action specified: do nothing */
! 561: }
! 562: }
! 563:
! 564: /*
! 565: ** Pop the parser's stack once.
! 566: **
! 567: ** If there is a destructor routine associated with the token which
! 568: ** is popped from the stack, then call it.
! 569: **
! 570: ** Return the major token number for the symbol popped.
! 571: */
! 572: static int yy_pop_parser_stack(yyParser *pParser){
! 573: YYCODETYPE yymajor;
! 574: yyStackEntry *yytos = &pParser->yystack[pParser->yyidx];
! 575:
! 576: if( pParser->yyidx<0 ) return 0;
! 577: #ifndef NDEBUG
! 578: if( yyTraceFILE && pParser->yyidx>=0 ){
! 579: fprintf(yyTraceFILE,"%sPopping %s\n",
! 580: yyTracePrompt,
! 581: yyTokenName[yytos->major]);
! 582: }
! 583: #endif
! 584: yymajor = yytos->major;
! 585: yy_destructor( yymajor, &yytos->minor);
! 586: pParser->yyidx--;
! 587: return yymajor;
! 588: }
! 589:
! 590: /*
! 591: ** Deallocate and destroy a parser. Destructors are all called for
! 592: ** all stack elements before shutting the parser down.
! 593: **
! 594: ** Inputs:
! 595: ** <ul>
! 596: ** <li> A pointer to the parser. This should be a pointer
! 597: ** obtained from configparserAlloc.
! 598: ** <li> A pointer to a function used to reclaim memory obtained
! 599: ** from malloc.
! 600: ** </ul>
! 601: */
! 602: void configparserFree(
! 603: void *p, /* The parser to be deleted */
! 604: void (*freeProc)(void*) /* Function used to reclaim memory */
! 605: ){
! 606: yyParser *pParser = (yyParser*)p;
! 607: if( pParser==NULL ) return;
! 608: while( pParser->yyidx>=0 ) yy_pop_parser_stack(pParser);
! 609: (*freeProc)((void*)pParser);
! 610: }
! 611:
! 612: /*
! 613: ** Find the appropriate action for a parser given the terminal
! 614: ** look-ahead token iLookAhead.
! 615: **
! 616: ** If the look-ahead token is YYNOCODE, then check to see if the action is
! 617: ** independent of the look-ahead. If it is, return the action, otherwise
! 618: ** return YY_NO_ACTION.
! 619: */
! 620: static int yy_find_shift_action(
! 621: yyParser *pParser, /* The parser */
! 622: int iLookAhead /* The look-ahead token */
! 623: ){
! 624: int i;
! 625: int stateno = pParser->yystack[pParser->yyidx].stateno;
! 626:
! 627: /* if( pParser->yyidx<0 ) return YY_NO_ACTION; */
! 628: i = yy_shift_ofst[stateno];
! 629: if( i==YY_SHIFT_USE_DFLT ){
! 630: return yy_default[stateno];
! 631: }
! 632: if( iLookAhead==YYNOCODE ){
! 633: return YY_NO_ACTION;
! 634: }
! 635: i += iLookAhead;
! 636: if( i<0 || (size_t)i>=YY_SZ_ACTTAB || yy_lookahead[i]!=iLookAhead ){
! 637: #ifdef YYFALLBACK
! 638: int iFallback; /* Fallback token */
! 639: if( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0])
! 640: && (iFallback = yyFallback[iLookAhead])!=0 ){
! 641: #ifndef NDEBUG
! 642: if( yyTraceFILE ){
! 643: fprintf(yyTraceFILE, "%sFALLBACK %s => %s\n",
! 644: yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[iFallback]);
! 645: }
! 646: #endif
! 647: return yy_find_shift_action(pParser, iFallback);
! 648: }
! 649: #endif
! 650: return yy_default[stateno];
! 651: }else{
! 652: return yy_action[i];
! 653: }
! 654: }
! 655:
! 656: /*
! 657: ** Find the appropriate action for a parser given the non-terminal
! 658: ** look-ahead token iLookAhead.
! 659: **
! 660: ** If the look-ahead token is YYNOCODE, then check to see if the action is
! 661: ** independent of the look-ahead. If it is, return the action, otherwise
! 662: ** return YY_NO_ACTION.
! 663: */
! 664: static int yy_find_reduce_action(
! 665: yyParser *pParser, /* The parser */
! 666: int iLookAhead /* The look-ahead token */
! 667: ){
! 668: int i;
! 669: int stateno = pParser->yystack[pParser->yyidx].stateno;
! 670:
! 671: i = yy_reduce_ofst[stateno];
! 672: if( i==YY_REDUCE_USE_DFLT ){
! 673: return yy_default[stateno];
! 674: }
! 675: if( iLookAhead==YYNOCODE ){
! 676: return YY_NO_ACTION;
! 677: }
! 678: i += iLookAhead;
! 679: if( i<0 || (size_t)i>=YY_SZ_ACTTAB || yy_lookahead[i]!=iLookAhead ){
! 680: return yy_default[stateno];
! 681: }else{
! 682: return yy_action[i];
! 683: }
! 684: }
! 685:
! 686: /*
! 687: ** Perform a shift action.
! 688: */
! 689: static void yy_shift(
! 690: yyParser *yypParser, /* The parser to be shifted */
! 691: int yyNewState, /* The new state to shift in */
! 692: int yyMajor, /* The major token to shift in */
! 693: YYMINORTYPE *yypMinor /* Pointer ot the minor token to shift in */
! 694: ){
! 695: yyStackEntry *yytos;
! 696: yypParser->yyidx++;
! 697: if( yypParser->yyidx>=YYSTACKDEPTH ){
! 698: configparserARG_FETCH;
! 699: yypParser->yyidx--;
! 700: #ifndef NDEBUG
! 701: if( yyTraceFILE ){
! 702: fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt);
! 703: }
! 704: #endif
! 705: while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);
! 706: /* Here code is inserted which will execute if the parser
! 707: ** stack every overflows */
! 708: configparserARG_STORE; /* Suppress warning about unused %extra_argument var */
! 709: return;
! 710: }
! 711: yytos = &yypParser->yystack[yypParser->yyidx];
! 712: yytos->stateno = yyNewState;
! 713: yytos->major = yyMajor;
! 714: yytos->minor = *yypMinor;
! 715: #ifndef NDEBUG
! 716: if( yyTraceFILE && yypParser->yyidx>0 ){
! 717: int i;
! 718: fprintf(yyTraceFILE,"%sShift %d\n",yyTracePrompt,yyNewState);
! 719: fprintf(yyTraceFILE,"%sStack:",yyTracePrompt);
! 720: for(i=1; i<=yypParser->yyidx; i++)
! 721: fprintf(yyTraceFILE," %s",yyTokenName[yypParser->yystack[i].major]);
! 722: fprintf(yyTraceFILE,"\n");
! 723: }
! 724: #endif
! 725: }
! 726:
! 727: /* The following table contains information about every rule that
! 728: ** is used during the reduce.
! 729: */
! 730: static struct {
! 731: YYCODETYPE lhs; /* Symbol on the left-hand side of the rule */
! 732: unsigned char nrhs; /* Number of right-hand side symbols in the rule */
! 733: } yyRuleInfo[] = {
! 734: { 27, 1 },
! 735: { 28, 2 },
! 736: { 28, 0 },
! 737: { 29, 1 },
! 738: { 29, 1 },
! 739: { 29, 2 },
! 740: { 29, 1 },
! 741: { 29, 1 },
! 742: { 29, 1 },
! 743: { 30, 3 },
! 744: { 30, 3 },
! 745: { 41, 1 },
! 746: { 36, 3 },
! 747: { 36, 1 },
! 748: { 35, 1 },
! 749: { 35, 1 },
! 750: { 35, 1 },
! 751: { 35, 1 },
! 752: { 40, 2 },
! 753: { 40, 3 },
! 754: { 39, 3 },
! 755: { 39, 2 },
! 756: { 39, 1 },
! 757: { 37, 1 },
! 758: { 37, 3 },
! 759: { 44, 1 },
! 760: { 44, 0 },
! 761: { 45, 1 },
! 762: { 31, 4 },
! 763: { 32, 4 },
! 764: { 32, 1 },
! 765: { 38, 4 },
! 766: { 46, 7 },
! 767: { 43, 1 },
! 768: { 43, 1 },
! 769: { 43, 1 },
! 770: { 43, 1 },
! 771: { 42, 1 },
! 772: { 33, 2 },
! 773: { 34, 2 },
! 774: };
! 775:
! 776: static void yy_accept(yyParser*); /* Forward Declaration */
! 777:
! 778: /*
! 779: ** Perform a reduce action and the shift that must immediately
! 780: ** follow the reduce.
! 781: */
! 782: static void yy_reduce(
! 783: yyParser *yypParser, /* The parser */
! 784: int yyruleno /* Number of the rule by which to reduce */
! 785: ){
! 786: int yygoto; /* The next state */
! 787: int yyact; /* The next action */
! 788: YYMINORTYPE yygotominor; /* The LHS of the rule reduced */
! 789: yyStackEntry *yymsp; /* The top of the parser's stack */
! 790: int yysize; /* Amount to pop the stack */
! 791: configparserARG_FETCH;
! 792: yymsp = &yypParser->yystack[yypParser->yyidx];
! 793: #ifndef NDEBUG
! 794: if( yyTraceFILE && yyruleno>=0
! 795: && (size_t)yyruleno<sizeof(yyRuleName)/sizeof(yyRuleName[0]) ){
! 796: fprintf(yyTraceFILE, "%sReduce [%s].\n", yyTracePrompt,
! 797: yyRuleName[yyruleno]);
! 798: }
! 799: #endif /* NDEBUG */
! 800:
! 801: switch( yyruleno ){
! 802: /* Beginning here are the reduction cases. A typical example
! 803: ** follows:
! 804: ** case 0:
! 805: ** #line <lineno> <grammarfile>
! 806: ** { ... } // User supplied code
! 807: ** #line <lineno> <thisfile>
! 808: ** break;
! 809: */
! 810: case 0:
! 811: /* No destructor defined for metalines */
! 812: break;
! 813: case 1:
! 814: /* No destructor defined for metalines */
! 815: /* No destructor defined for metaline */
! 816: break;
! 817: case 2:
! 818: break;
! 819: case 3:
! 820: /* No destructor defined for varline */
! 821: break;
! 822: case 4:
! 823: /* No destructor defined for global */
! 824: break;
! 825: case 5:
! 826: #line 117 "../../src/configparser.y"
! 827: { yymsp[-1].minor.yy78 = NULL; }
! 828: #line 828 "configparser.c"
! 829: yy_destructor(1,&yymsp[0].minor);
! 830: break;
! 831: case 6:
! 832: /* No destructor defined for include */
! 833: break;
! 834: case 7:
! 835: /* No destructor defined for include_shell */
! 836: break;
! 837: case 8:
! 838: yy_destructor(1,&yymsp[0].minor);
! 839: break;
! 840: case 9:
! 841: #line 146 "../../src/configparser.y"
! 842: {
! 843: if (ctx->ok) {
! 844: buffer_copy_string_buffer(yymsp[0].minor.yy41->key, yymsp[-2].minor.yy43);
! 845: if (strncmp(yymsp[-2].minor.yy43->ptr, "env.", sizeof("env.") - 1) == 0) {
! 846: fprintf(stderr, "Setting env variable is not supported in conditional %d %s: %s\n",
! 847: ctx->current->context_ndx,
! 848: ctx->current->key->ptr, yymsp[-2].minor.yy43->ptr);
! 849: ctx->ok = 0;
! 850: } else if (NULL == array_get_element(ctx->current->value, yymsp[0].minor.yy41->key->ptr)) {
! 851: array_insert_unique(ctx->current->value, yymsp[0].minor.yy41);
! 852: yymsp[0].minor.yy41 = NULL;
! 853: } else {
! 854: fprintf(stderr, "Duplicate config variable in conditional %d %s: %s\n",
! 855: ctx->current->context_ndx,
! 856: ctx->current->key->ptr, yymsp[0].minor.yy41->key->ptr);
! 857: ctx->ok = 0;
! 858: yymsp[0].minor.yy41->free(yymsp[0].minor.yy41);
! 859: yymsp[0].minor.yy41 = NULL;
! 860: }
! 861: }
! 862: buffer_free(yymsp[-2].minor.yy43);
! 863: yymsp[-2].minor.yy43 = NULL;
! 864: }
! 865: #line 865 "configparser.c"
! 866: yy_destructor(2,&yymsp[-1].minor);
! 867: break;
! 868: case 10:
! 869: #line 170 "../../src/configparser.y"
! 870: {
! 871: array *vars = ctx->current->value;
! 872: data_unset *du;
! 873:
! 874: if (strncmp(yymsp[-2].minor.yy43->ptr, "env.", sizeof("env.") - 1) == 0) {
! 875: fprintf(stderr, "Appending env variable is not supported in conditional %d %s: %s\n",
! 876: ctx->current->context_ndx,
! 877: ctx->current->key->ptr, yymsp[-2].minor.yy43->ptr);
! 878: ctx->ok = 0;
! 879: } else if (NULL != (du = array_get_element(vars, yymsp[-2].minor.yy43->ptr))) {
! 880: /* exists in current block */
! 881: du = configparser_merge_data(du, yymsp[0].minor.yy41);
! 882: if (NULL == du) {
! 883: ctx->ok = 0;
! 884: }
! 885: else {
! 886: buffer_copy_string_buffer(du->key, yymsp[-2].minor.yy43);
! 887: array_replace(vars, du);
! 888: }
! 889: yymsp[0].minor.yy41->free(yymsp[0].minor.yy41);
! 890: } else if (NULL != (du = configparser_get_variable(ctx, yymsp[-2].minor.yy43))) {
! 891: du = configparser_merge_data(du, yymsp[0].minor.yy41);
! 892: if (NULL == du) {
! 893: ctx->ok = 0;
! 894: }
! 895: else {
! 896: buffer_copy_string_buffer(du->key, yymsp[-2].minor.yy43);
! 897: array_insert_unique(ctx->current->value, du);
! 898: }
! 899: yymsp[0].minor.yy41->free(yymsp[0].minor.yy41);
! 900: } else {
! 901: buffer_copy_string_buffer(yymsp[0].minor.yy41->key, yymsp[-2].minor.yy43);
! 902: array_insert_unique(ctx->current->value, yymsp[0].minor.yy41);
! 903: }
! 904: buffer_free(yymsp[-2].minor.yy43);
! 905: yymsp[-2].minor.yy43 = NULL;
! 906: yymsp[0].minor.yy41 = NULL;
! 907: }
! 908: #line 908 "configparser.c"
! 909: yy_destructor(3,&yymsp[-1].minor);
! 910: break;
! 911: case 11:
! 912: #line 209 "../../src/configparser.y"
! 913: {
! 914: if (strchr(yymsp[0].minor.yy0->ptr, '.') == NULL) {
! 915: yygotominor.yy43 = buffer_init_string("var.");
! 916: buffer_append_string_buffer(yygotominor.yy43, yymsp[0].minor.yy0);
! 917: buffer_free(yymsp[0].minor.yy0);
! 918: yymsp[0].minor.yy0 = NULL;
! 919: } else {
! 920: yygotominor.yy43 = yymsp[0].minor.yy0;
! 921: yymsp[0].minor.yy0 = NULL;
! 922: }
! 923: }
! 924: #line 924 "configparser.c"
! 925: break;
! 926: case 12:
! 927: #line 221 "../../src/configparser.y"
! 928: {
! 929: yygotominor.yy41 = configparser_merge_data(yymsp[-2].minor.yy41, yymsp[0].minor.yy41);
! 930: if (NULL == yygotominor.yy41) {
! 931: ctx->ok = 0;
! 932: }
! 933: yymsp[-2].minor.yy41 = NULL;
! 934: yymsp[0].minor.yy41->free(yymsp[0].minor.yy41);
! 935: yymsp[0].minor.yy41 = NULL;
! 936: }
! 937: #line 937 "configparser.c"
! 938: yy_destructor(5,&yymsp[-1].minor);
! 939: break;
! 940: case 13:
! 941: #line 231 "../../src/configparser.y"
! 942: {
! 943: yygotominor.yy41 = yymsp[0].minor.yy41;
! 944: yymsp[0].minor.yy41 = NULL;
! 945: }
! 946: #line 946 "configparser.c"
! 947: break;
! 948: case 14:
! 949: #line 236 "../../src/configparser.y"
! 950: {
! 951: yygotominor.yy41 = NULL;
! 952: if (strncmp(yymsp[0].minor.yy43->ptr, "env.", sizeof("env.") - 1) == 0) {
! 953: char *env;
! 954:
! 955: if (NULL != (env = getenv(yymsp[0].minor.yy43->ptr + 4))) {
! 956: data_string *ds;
! 957: ds = data_string_init();
! 958: buffer_append_string(ds->value, env);
! 959: yygotominor.yy41 = (data_unset *)ds;
! 960: }
! 961: else {
! 962: fprintf(stderr, "Undefined env variable: %s\n", yymsp[0].minor.yy43->ptr + 4);
! 963: ctx->ok = 0;
! 964: }
! 965: } else if (NULL == (yygotominor.yy41 = configparser_get_variable(ctx, yymsp[0].minor.yy43))) {
! 966: fprintf(stderr, "Undefined config variable: %s\n", yymsp[0].minor.yy43->ptr);
! 967: ctx->ok = 0;
! 968: }
! 969: if (!yygotominor.yy41) {
! 970: /* make a dummy so it won't crash */
! 971: yygotominor.yy41 = (data_unset *)data_string_init();
! 972: }
! 973: buffer_free(yymsp[0].minor.yy43);
! 974: yymsp[0].minor.yy43 = NULL;
! 975: }
! 976: #line 976 "configparser.c"
! 977: break;
! 978: case 15:
! 979: #line 263 "../../src/configparser.y"
! 980: {
! 981: yygotominor.yy41 = (data_unset *)data_string_init();
! 982: buffer_copy_string_buffer(((data_string *)(yygotominor.yy41))->value, yymsp[0].minor.yy0);
! 983: buffer_free(yymsp[0].minor.yy0);
! 984: yymsp[0].minor.yy0 = NULL;
! 985: }
! 986: #line 986 "configparser.c"
! 987: break;
! 988: case 16:
! 989: #line 270 "../../src/configparser.y"
! 990: {
! 991: yygotominor.yy41 = (data_unset *)data_integer_init();
! 992: ((data_integer *)(yygotominor.yy41))->value = strtol(yymsp[0].minor.yy0->ptr, NULL, 10);
! 993: buffer_free(yymsp[0].minor.yy0);
! 994: yymsp[0].minor.yy0 = NULL;
! 995: }
! 996: #line 996 "configparser.c"
! 997: break;
! 998: case 17:
! 999: #line 276 "../../src/configparser.y"
! 1000: {
! 1001: yygotominor.yy41 = (data_unset *)data_array_init();
! 1002: array_free(((data_array *)(yygotominor.yy41))->value);
! 1003: ((data_array *)(yygotominor.yy41))->value = yymsp[0].minor.yy40;
! 1004: yymsp[0].minor.yy40 = NULL;
! 1005: }
! 1006: #line 1006 "configparser.c"
! 1007: break;
! 1008: case 18:
! 1009: #line 282 "../../src/configparser.y"
! 1010: {
! 1011: yygotominor.yy40 = array_init();
! 1012: }
! 1013: #line 1013 "configparser.c"
! 1014: yy_destructor(8,&yymsp[-1].minor);
! 1015: yy_destructor(9,&yymsp[0].minor);
! 1016: break;
! 1017: case 19:
! 1018: #line 285 "../../src/configparser.y"
! 1019: {
! 1020: yygotominor.yy40 = yymsp[-1].minor.yy40;
! 1021: yymsp[-1].minor.yy40 = NULL;
! 1022: }
! 1023: #line 1023 "configparser.c"
! 1024: yy_destructor(8,&yymsp[-2].minor);
! 1025: yy_destructor(9,&yymsp[0].minor);
! 1026: break;
! 1027: case 20:
! 1028: #line 290 "../../src/configparser.y"
! 1029: {
! 1030: if (buffer_is_empty(yymsp[0].minor.yy41->key) ||
! 1031: NULL == array_get_element(yymsp[-2].minor.yy40, yymsp[0].minor.yy41->key->ptr)) {
! 1032: array_insert_unique(yymsp[-2].minor.yy40, yymsp[0].minor.yy41);
! 1033: yymsp[0].minor.yy41 = NULL;
! 1034: } else {
! 1035: fprintf(stderr, "Duplicate array-key: %s\n",
! 1036: yymsp[0].minor.yy41->key->ptr);
! 1037: ctx->ok = 0;
! 1038: yymsp[0].minor.yy41->free(yymsp[0].minor.yy41);
! 1039: yymsp[0].minor.yy41 = NULL;
! 1040: }
! 1041:
! 1042: yygotominor.yy40 = yymsp[-2].minor.yy40;
! 1043: yymsp[-2].minor.yy40 = NULL;
! 1044: }
! 1045: #line 1045 "configparser.c"
! 1046: yy_destructor(10,&yymsp[-1].minor);
! 1047: break;
! 1048: case 21:
! 1049: #line 307 "../../src/configparser.y"
! 1050: {
! 1051: yygotominor.yy40 = yymsp[-1].minor.yy40;
! 1052: yymsp[-1].minor.yy40 = NULL;
! 1053: }
! 1054: #line 1054 "configparser.c"
! 1055: yy_destructor(10,&yymsp[0].minor);
! 1056: break;
! 1057: case 22:
! 1058: #line 312 "../../src/configparser.y"
! 1059: {
! 1060: yygotominor.yy40 = array_init();
! 1061: array_insert_unique(yygotominor.yy40, yymsp[0].minor.yy41);
! 1062: yymsp[0].minor.yy41 = NULL;
! 1063: }
! 1064: #line 1064 "configparser.c"
! 1065: break;
! 1066: case 23:
! 1067: #line 318 "../../src/configparser.y"
! 1068: {
! 1069: yygotominor.yy41 = yymsp[0].minor.yy41;
! 1070: yymsp[0].minor.yy41 = NULL;
! 1071: }
! 1072: #line 1072 "configparser.c"
! 1073: break;
! 1074: case 24:
! 1075: #line 322 "../../src/configparser.y"
! 1076: {
! 1077: buffer_copy_string_buffer(yymsp[0].minor.yy41->key, yymsp[-2].minor.yy43);
! 1078: buffer_free(yymsp[-2].minor.yy43);
! 1079: yymsp[-2].minor.yy43 = NULL;
! 1080:
! 1081: yygotominor.yy41 = yymsp[0].minor.yy41;
! 1082: yymsp[0].minor.yy41 = NULL;
! 1083: }
! 1084: #line 1084 "configparser.c"
! 1085: yy_destructor(11,&yymsp[-1].minor);
! 1086: break;
! 1087: case 25:
! 1088: yy_destructor(1,&yymsp[0].minor);
! 1089: break;
! 1090: case 26:
! 1091: break;
! 1092: case 27:
! 1093: #line 334 "../../src/configparser.y"
! 1094: {
! 1095: data_config *dc;
! 1096: dc = (data_config *)array_get_element(ctx->srv->config_context, "global");
! 1097: assert(dc);
! 1098: configparser_push(ctx, dc, 0);
! 1099: }
! 1100: #line 1100 "configparser.c"
! 1101: yy_destructor(12,&yymsp[0].minor);
! 1102: break;
! 1103: case 28:
! 1104: #line 341 "../../src/configparser.y"
! 1105: {
! 1106: data_config *cur;
! 1107:
! 1108: cur = ctx->current;
! 1109: configparser_pop(ctx);
! 1110:
! 1111: assert(cur && ctx->current);
! 1112:
! 1113: yygotominor.yy78 = cur;
! 1114: }
! 1115: #line 1115 "configparser.c"
! 1116: /* No destructor defined for globalstart */
! 1117: yy_destructor(13,&yymsp[-2].minor);
! 1118: /* No destructor defined for metalines */
! 1119: yy_destructor(14,&yymsp[0].minor);
! 1120: break;
! 1121: case 29:
! 1122: #line 352 "../../src/configparser.y"
! 1123: {
! 1124: if (yymsp[-3].minor.yy78->context_ndx >= yymsp[0].minor.yy78->context_ndx) {
! 1125: fprintf(stderr, "unreachable else condition\n");
! 1126: ctx->ok = 0;
! 1127: }
! 1128: yymsp[0].minor.yy78->prev = yymsp[-3].minor.yy78;
! 1129: yymsp[-3].minor.yy78->next = yymsp[0].minor.yy78;
! 1130: yygotominor.yy78 = yymsp[0].minor.yy78;
! 1131: yymsp[-3].minor.yy78 = NULL;
! 1132: yymsp[0].minor.yy78 = NULL;
! 1133: }
! 1134: #line 1134 "configparser.c"
! 1135: /* No destructor defined for eols */
! 1136: yy_destructor(15,&yymsp[-1].minor);
! 1137: break;
! 1138: case 30:
! 1139: #line 364 "../../src/configparser.y"
! 1140: {
! 1141: yygotominor.yy78 = yymsp[0].minor.yy78;
! 1142: yymsp[0].minor.yy78 = NULL;
! 1143: }
! 1144: #line 1144 "configparser.c"
! 1145: break;
! 1146: case 31:
! 1147: #line 369 "../../src/configparser.y"
! 1148: {
! 1149: data_config *cur;
! 1150:
! 1151: cur = ctx->current;
! 1152: configparser_pop(ctx);
! 1153:
! 1154: assert(cur && ctx->current);
! 1155:
! 1156: yygotominor.yy78 = cur;
! 1157: }
! 1158: #line 1158 "configparser.c"
! 1159: /* No destructor defined for context */
! 1160: yy_destructor(13,&yymsp[-2].minor);
! 1161: /* No destructor defined for metalines */
! 1162: yy_destructor(14,&yymsp[0].minor);
! 1163: break;
! 1164: case 32:
! 1165: #line 380 "../../src/configparser.y"
! 1166: {
! 1167: data_config *dc;
! 1168: buffer *b, *rvalue, *op;
! 1169:
! 1170: if (ctx->ok && yymsp[0].minor.yy41->type != TYPE_STRING) {
! 1171: fprintf(stderr, "rvalue must be string");
! 1172: ctx->ok = 0;
! 1173: }
! 1174:
! 1175: switch(yymsp[-1].minor.yy27) {
! 1176: case CONFIG_COND_NE:
! 1177: op = buffer_init_string("!=");
! 1178: break;
! 1179: case CONFIG_COND_EQ:
! 1180: op = buffer_init_string("==");
! 1181: break;
! 1182: case CONFIG_COND_NOMATCH:
! 1183: op = buffer_init_string("!~");
! 1184: break;
! 1185: case CONFIG_COND_MATCH:
! 1186: op = buffer_init_string("=~");
! 1187: break;
! 1188: default:
! 1189: assert(0);
! 1190: return;
! 1191: }
! 1192:
! 1193: b = buffer_init();
! 1194: buffer_copy_string_buffer(b, ctx->current->key);
! 1195: buffer_append_string(b, "/");
! 1196: buffer_append_string_buffer(b, yymsp[-5].minor.yy0);
! 1197: buffer_append_string_buffer(b, yymsp[-3].minor.yy43);
! 1198: buffer_append_string_buffer(b, op);
! 1199: rvalue = ((data_string*)yymsp[0].minor.yy41)->value;
! 1200: buffer_append_string_buffer(b, rvalue);
! 1201:
! 1202: if (NULL != (dc = (data_config *)array_get_element(ctx->all_configs, b->ptr))) {
! 1203: configparser_push(ctx, dc, 0);
! 1204: } else {
! 1205: struct {
! 1206: comp_key_t comp;
! 1207: char *comp_key;
! 1208: size_t len;
! 1209: } comps[] = {
! 1210: { COMP_SERVER_SOCKET, CONST_STR_LEN("SERVER[\"socket\"]" ) },
! 1211: { COMP_HTTP_URL, CONST_STR_LEN("HTTP[\"url\"]" ) },
! 1212: { COMP_HTTP_HOST, CONST_STR_LEN("HTTP[\"host\"]" ) },
! 1213: { COMP_HTTP_REFERER, CONST_STR_LEN("HTTP[\"referer\"]" ) },
! 1214: { COMP_HTTP_USER_AGENT, CONST_STR_LEN("HTTP[\"useragent\"]" ) },
! 1215: { COMP_HTTP_USER_AGENT, CONST_STR_LEN("HTTP[\"user-agent\"]" ) },
! 1216: { COMP_HTTP_LANGUAGE, CONST_STR_LEN("HTTP[\"language\"]" ) },
! 1217: { COMP_HTTP_COOKIE, CONST_STR_LEN("HTTP[\"cookie\"]" ) },
! 1218: { COMP_HTTP_REMOTE_IP, CONST_STR_LEN("HTTP[\"remoteip\"]" ) },
! 1219: { COMP_HTTP_REMOTE_IP, CONST_STR_LEN("HTTP[\"remote-ip\"]" ) },
! 1220: { COMP_HTTP_QUERY_STRING, CONST_STR_LEN("HTTP[\"querystring\"]") },
! 1221: { COMP_HTTP_QUERY_STRING, CONST_STR_LEN("HTTP[\"query-string\"]") },
! 1222: { COMP_HTTP_REQUEST_METHOD, CONST_STR_LEN("HTTP[\"request-method\"]") },
! 1223: { COMP_HTTP_SCHEME, CONST_STR_LEN("HTTP[\"scheme\"]" ) },
! 1224: { COMP_UNSET, NULL, 0 },
! 1225: };
! 1226: size_t i;
! 1227:
! 1228: dc = data_config_init();
! 1229:
! 1230: buffer_copy_string_buffer(dc->key, b);
! 1231: buffer_copy_string_buffer(dc->op, op);
! 1232: buffer_copy_string_buffer(dc->comp_key, yymsp[-5].minor.yy0);
! 1233: buffer_append_string_len(dc->comp_key, CONST_STR_LEN("[\""));
! 1234: buffer_append_string_buffer(dc->comp_key, yymsp[-3].minor.yy43);
! 1235: buffer_append_string_len(dc->comp_key, CONST_STR_LEN("\"]"));
! 1236: dc->cond = yymsp[-1].minor.yy27;
! 1237:
! 1238: for (i = 0; comps[i].comp_key; i ++) {
! 1239: if (buffer_is_equal_string(
! 1240: dc->comp_key, comps[i].comp_key, comps[i].len)) {
! 1241: dc->comp = comps[i].comp;
! 1242: break;
! 1243: }
! 1244: }
! 1245: if (COMP_UNSET == dc->comp) {
! 1246: fprintf(stderr, "error comp_key %s", dc->comp_key->ptr);
! 1247: ctx->ok = 0;
! 1248: }
! 1249:
! 1250: switch(yymsp[-1].minor.yy27) {
! 1251: case CONFIG_COND_NE:
! 1252: case CONFIG_COND_EQ:
! 1253: dc->string = buffer_init_buffer(rvalue);
! 1254: break;
! 1255: case CONFIG_COND_NOMATCH:
! 1256: case CONFIG_COND_MATCH: {
! 1257: #ifdef HAVE_PCRE_H
! 1258: const char *errptr;
! 1259: int erroff, captures;
! 1260:
! 1261: if (NULL == (dc->regex =
! 1262: pcre_compile(rvalue->ptr, 0, &errptr, &erroff, NULL))) {
! 1263: dc->string = buffer_init_string(errptr);
! 1264: dc->cond = CONFIG_COND_UNSET;
! 1265:
! 1266: fprintf(stderr, "parsing regex failed: %s -> %s at offset %d\n",
! 1267: rvalue->ptr, errptr, erroff);
! 1268:
! 1269: ctx->ok = 0;
! 1270: } else if (NULL == (dc->regex_study =
! 1271: pcre_study(dc->regex, 0, &errptr)) &&
! 1272: errptr != NULL) {
! 1273: fprintf(stderr, "studying regex failed: %s -> %s\n",
! 1274: rvalue->ptr, errptr);
! 1275: ctx->ok = 0;
! 1276: } else if (0 != (pcre_fullinfo(dc->regex, dc->regex_study, PCRE_INFO_CAPTURECOUNT, &captures))) {
! 1277: fprintf(stderr, "getting capture count for regex failed: %s\n",
! 1278: rvalue->ptr);
! 1279: ctx->ok = 0;
! 1280: } else if (captures > 9) {
! 1281: fprintf(stderr, "Too many captures in regex, use (?:...) instead of (...): %s\n",
! 1282: rvalue->ptr);
! 1283: ctx->ok = 0;
! 1284: } else {
! 1285: dc->string = buffer_init_buffer(rvalue);
! 1286: }
! 1287: #else
! 1288: fprintf(stderr, "can't handle '$%s[%s] =~ ...' as you compiled without pcre support. \n"
! 1289: "(perhaps just a missing pcre-devel package ?) \n",
! 1290: yymsp[-5].minor.yy0->ptr, yymsp[-3].minor.yy43->ptr);
! 1291: ctx->ok = 0;
! 1292: #endif
! 1293: break;
! 1294: }
! 1295:
! 1296: default:
! 1297: fprintf(stderr, "unknown condition for $%s[%s]\n",
! 1298: yymsp[-5].minor.yy0->ptr, yymsp[-3].minor.yy43->ptr);
! 1299: ctx->ok = 0;
! 1300: break;
! 1301: }
! 1302:
! 1303: configparser_push(ctx, dc, 1);
! 1304: }
! 1305:
! 1306: buffer_free(b);
! 1307: buffer_free(op);
! 1308: buffer_free(yymsp[-5].minor.yy0);
! 1309: yymsp[-5].minor.yy0 = NULL;
! 1310: buffer_free(yymsp[-3].minor.yy43);
! 1311: yymsp[-3].minor.yy43 = NULL;
! 1312: yymsp[0].minor.yy41->free(yymsp[0].minor.yy41);
! 1313: yymsp[0].minor.yy41 = NULL;
! 1314: }
! 1315: #line 1315 "configparser.c"
! 1316: yy_destructor(16,&yymsp[-6].minor);
! 1317: yy_destructor(18,&yymsp[-4].minor);
! 1318: yy_destructor(19,&yymsp[-2].minor);
! 1319: break;
! 1320: case 33:
! 1321: #line 529 "../../src/configparser.y"
! 1322: {
! 1323: yygotominor.yy27 = CONFIG_COND_EQ;
! 1324: }
! 1325: #line 1325 "configparser.c"
! 1326: yy_destructor(20,&yymsp[0].minor);
! 1327: break;
! 1328: case 34:
! 1329: #line 532 "../../src/configparser.y"
! 1330: {
! 1331: yygotominor.yy27 = CONFIG_COND_MATCH;
! 1332: }
! 1333: #line 1333 "configparser.c"
! 1334: yy_destructor(21,&yymsp[0].minor);
! 1335: break;
! 1336: case 35:
! 1337: #line 535 "../../src/configparser.y"
! 1338: {
! 1339: yygotominor.yy27 = CONFIG_COND_NE;
! 1340: }
! 1341: #line 1341 "configparser.c"
! 1342: yy_destructor(22,&yymsp[0].minor);
! 1343: break;
! 1344: case 36:
! 1345: #line 538 "../../src/configparser.y"
! 1346: {
! 1347: yygotominor.yy27 = CONFIG_COND_NOMATCH;
! 1348: }
! 1349: #line 1349 "configparser.c"
! 1350: yy_destructor(23,&yymsp[0].minor);
! 1351: break;
! 1352: case 37:
! 1353: #line 542 "../../src/configparser.y"
! 1354: {
! 1355: yygotominor.yy43 = NULL;
! 1356: if (ctx->ok) {
! 1357: if (yymsp[0].minor.yy41->type == TYPE_STRING) {
! 1358: yygotominor.yy43 = buffer_init_buffer(((data_string*)yymsp[0].minor.yy41)->value);
! 1359: } else if (yymsp[0].minor.yy41->type == TYPE_INTEGER) {
! 1360: yygotominor.yy43 = buffer_init();
! 1361: buffer_copy_long(yygotominor.yy43, ((data_integer *)yymsp[0].minor.yy41)->value);
! 1362: } else {
! 1363: fprintf(stderr, "operand must be string");
! 1364: ctx->ok = 0;
! 1365: }
! 1366: }
! 1367: yymsp[0].minor.yy41->free(yymsp[0].minor.yy41);
! 1368: yymsp[0].minor.yy41 = NULL;
! 1369: }
! 1370: #line 1370 "configparser.c"
! 1371: break;
! 1372: case 38:
! 1373: #line 559 "../../src/configparser.y"
! 1374: {
! 1375: if (ctx->ok) {
! 1376: if (0 != config_parse_file(ctx->srv, ctx, yymsp[0].minor.yy43->ptr)) {
! 1377: ctx->ok = 0;
! 1378: }
! 1379: buffer_free(yymsp[0].minor.yy43);
! 1380: yymsp[0].minor.yy43 = NULL;
! 1381: }
! 1382: }
! 1383: #line 1383 "configparser.c"
! 1384: yy_destructor(24,&yymsp[-1].minor);
! 1385: break;
! 1386: case 39:
! 1387: #line 569 "../../src/configparser.y"
! 1388: {
! 1389: if (ctx->ok) {
! 1390: if (0 != config_parse_cmd(ctx->srv, ctx, yymsp[0].minor.yy43->ptr)) {
! 1391: ctx->ok = 0;
! 1392: }
! 1393: buffer_free(yymsp[0].minor.yy43);
! 1394: yymsp[0].minor.yy43 = NULL;
! 1395: }
! 1396: }
! 1397: #line 1397 "configparser.c"
! 1398: yy_destructor(25,&yymsp[-1].minor);
! 1399: break;
! 1400: };
! 1401: yygoto = yyRuleInfo[yyruleno].lhs;
! 1402: yysize = yyRuleInfo[yyruleno].nrhs;
! 1403: yypParser->yyidx -= yysize;
! 1404: yyact = yy_find_reduce_action(yypParser,yygoto);
! 1405: if( yyact < YYNSTATE ){
! 1406: yy_shift(yypParser,yyact,yygoto,&yygotominor);
! 1407: }else if( yyact == YYNSTATE + YYNRULE + 1 ){
! 1408: yy_accept(yypParser);
! 1409: }
! 1410: }
! 1411:
! 1412: /*
! 1413: ** The following code executes when the parse fails
! 1414: */
! 1415: static void yy_parse_failed(
! 1416: yyParser *yypParser /* The parser */
! 1417: ){
! 1418: configparserARG_FETCH;
! 1419: #ifndef NDEBUG
! 1420: if( yyTraceFILE ){
! 1421: fprintf(yyTraceFILE,"%sFail!\n",yyTracePrompt);
! 1422: }
! 1423: #endif
! 1424: while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);
! 1425: /* Here code is inserted which will be executed whenever the
! 1426: ** parser fails */
! 1427: #line 108 "../../src/configparser.y"
! 1428:
! 1429: ctx->ok = 0;
! 1430:
! 1431: #line 1431 "configparser.c"
! 1432: configparserARG_STORE; /* Suppress warning about unused %extra_argument variable */
! 1433: }
! 1434:
! 1435: /*
! 1436: ** The following code executes when a syntax error first occurs.
! 1437: */
! 1438: static void yy_syntax_error(
! 1439: yyParser *yypParser, /* The parser */
! 1440: int yymajor, /* The major type of the error token */
! 1441: YYMINORTYPE yyminor /* The minor type of the error token */
! 1442: ){
! 1443: configparserARG_FETCH;
! 1444: UNUSED(yymajor);
! 1445: UNUSED(yyminor);
! 1446: #define TOKEN (yyminor.yy0)
! 1447: configparserARG_STORE; /* Suppress warning about unused %extra_argument variable */
! 1448: }
! 1449:
! 1450: /*
! 1451: ** The following is executed when the parser accepts
! 1452: */
! 1453: static void yy_accept(
! 1454: yyParser *yypParser /* The parser */
! 1455: ){
! 1456: configparserARG_FETCH;
! 1457: #ifndef NDEBUG
! 1458: if( yyTraceFILE ){
! 1459: fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt);
! 1460: }
! 1461: #endif
! 1462: while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);
! 1463: /* Here code is inserted which will be executed whenever the
! 1464: ** parser accepts */
! 1465: configparserARG_STORE; /* Suppress warning about unused %extra_argument variable */
! 1466: }
! 1467:
! 1468: /* The main parser program.
! 1469: ** The first argument is a pointer to a structure obtained from
! 1470: ** "configparserAlloc" which describes the current state of the parser.
! 1471: ** The second argument is the major token number. The third is
! 1472: ** the minor token. The fourth optional argument is whatever the
! 1473: ** user wants (and specified in the grammar) and is available for
! 1474: ** use by the action routines.
! 1475: **
! 1476: ** Inputs:
! 1477: ** <ul>
! 1478: ** <li> A pointer to the parser (an opaque structure.)
! 1479: ** <li> The major token number.
! 1480: ** <li> The minor token number.
! 1481: ** <li> An option argument of a grammar-specified type.
! 1482: ** </ul>
! 1483: **
! 1484: ** Outputs:
! 1485: ** None.
! 1486: */
! 1487: void configparser(
! 1488: void *yyp, /* The parser */
! 1489: int yymajor, /* The major token code number */
! 1490: configparserTOKENTYPE yyminor /* The value for the token */
! 1491: configparserARG_PDECL /* Optional %extra_argument parameter */
! 1492: ){
! 1493: YYMINORTYPE yyminorunion;
! 1494: int yyact; /* The parser action. */
! 1495: int yyendofinput; /* True if we are at the end of input */
! 1496: int yyerrorhit = 0; /* True if yymajor has invoked an error */
! 1497: yyParser *yypParser; /* The parser */
! 1498:
! 1499: /* (re)initialize the parser, if necessary */
! 1500: yypParser = (yyParser*)yyp;
! 1501: if( yypParser->yyidx<0 ){
! 1502: if( yymajor==0 ) return;
! 1503: yypParser->yyidx = 0;
! 1504: yypParser->yyerrcnt = -1;
! 1505: yypParser->yystack[0].stateno = 0;
! 1506: yypParser->yystack[0].major = 0;
! 1507: }
! 1508: yyminorunion.yy0 = yyminor;
! 1509: yyendofinput = (yymajor==0);
! 1510: configparserARG_STORE;
! 1511:
! 1512: #ifndef NDEBUG
! 1513: if( yyTraceFILE ){
! 1514: fprintf(yyTraceFILE,"%sInput %s\n",yyTracePrompt,yyTokenName[yymajor]);
! 1515: }
! 1516: #endif
! 1517:
! 1518: do{
! 1519: yyact = yy_find_shift_action(yypParser,yymajor);
! 1520: if( yyact<YYNSTATE ){
! 1521: yy_shift(yypParser,yyact,yymajor,&yyminorunion);
! 1522: yypParser->yyerrcnt--;
! 1523: if( yyendofinput && yypParser->yyidx>=0 ){
! 1524: yymajor = 0;
! 1525: }else{
! 1526: yymajor = YYNOCODE;
! 1527: }
! 1528: }else if( yyact < YYNSTATE + YYNRULE ){
! 1529: yy_reduce(yypParser,yyact-YYNSTATE);
! 1530: }else if( yyact == YY_ERROR_ACTION ){
! 1531: int yymx;
! 1532: #ifndef NDEBUG
! 1533: if( yyTraceFILE ){
! 1534: fprintf(yyTraceFILE,"%sSyntax Error!\n",yyTracePrompt);
! 1535: }
! 1536: #endif
! 1537: #ifdef YYERRORSYMBOL
! 1538: /* A syntax error has occurred.
! 1539: ** The response to an error depends upon whether or not the
! 1540: ** grammar defines an error token "ERROR".
! 1541: **
! 1542: ** This is what we do if the grammar does define ERROR:
! 1543: **
! 1544: ** * Call the %syntax_error function.
! 1545: **
! 1546: ** * Begin popping the stack until we enter a state where
! 1547: ** it is legal to shift the error symbol, then shift
! 1548: ** the error symbol.
! 1549: **
! 1550: ** * Set the error count to three.
! 1551: **
! 1552: ** * Begin accepting and shifting new tokens. No new error
! 1553: ** processing will occur until three tokens have been
! 1554: ** shifted successfully.
! 1555: **
! 1556: */
! 1557: if( yypParser->yyerrcnt<0 ){
! 1558: yy_syntax_error(yypParser,yymajor,yyminorunion);
! 1559: }
! 1560: yymx = yypParser->yystack[yypParser->yyidx].major;
! 1561: if( yymx==YYERRORSYMBOL || yyerrorhit ){
! 1562: #ifndef NDEBUG
! 1563: if( yyTraceFILE ){
! 1564: fprintf(yyTraceFILE,"%sDiscard input token %s\n",
! 1565: yyTracePrompt,yyTokenName[yymajor]);
! 1566: }
! 1567: #endif
! 1568: yy_destructor(yymajor,&yyminorunion);
! 1569: yymajor = YYNOCODE;
! 1570: }else{
! 1571: while(
! 1572: yypParser->yyidx >= 0 &&
! 1573: yymx != YYERRORSYMBOL &&
! 1574: (yyact = yy_find_shift_action(yypParser,YYERRORSYMBOL)) >= YYNSTATE
! 1575: ){
! 1576: yy_pop_parser_stack(yypParser);
! 1577: }
! 1578: if( yypParser->yyidx < 0 || yymajor==0 ){
! 1579: yy_destructor(yymajor,&yyminorunion);
! 1580: yy_parse_failed(yypParser);
! 1581: yymajor = YYNOCODE;
! 1582: }else if( yymx!=YYERRORSYMBOL ){
! 1583: YYMINORTYPE u2;
! 1584: u2.YYERRSYMDT = 0;
! 1585: yy_shift(yypParser,yyact,YYERRORSYMBOL,&u2);
! 1586: }
! 1587: }
! 1588: yypParser->yyerrcnt = 3;
! 1589: yyerrorhit = 1;
! 1590: #else /* YYERRORSYMBOL is not defined */
! 1591: /* This is what we do if the grammar does not define ERROR:
! 1592: **
! 1593: ** * Report an error message, and throw away the input token.
! 1594: **
! 1595: ** * If the input token is $, then fail the parse.
! 1596: **
! 1597: ** As before, subsequent error messages are suppressed until
! 1598: ** three input tokens have been successfully shifted.
! 1599: */
! 1600: if( yypParser->yyerrcnt<=0 ){
! 1601: yy_syntax_error(yypParser,yymajor,yyminorunion);
! 1602: }
! 1603: yypParser->yyerrcnt = 3;
! 1604: yy_destructor(yymajor,&yyminorunion);
! 1605: if( yyendofinput ){
! 1606: yy_parse_failed(yypParser);
! 1607: }
! 1608: yymajor = YYNOCODE;
! 1609: #endif
! 1610: }else{
! 1611: yy_accept(yypParser);
! 1612: yymajor = YYNOCODE;
! 1613: }
! 1614: }while( yymajor!=YYNOCODE && yypParser->yyidx>=0 );
! 1615: return;
! 1616: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to configparser.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / lighttpd / src