Annotation of embedaddon/lighttpd/src/mod_ssi_exprparser.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 6 "../../src/mod_ssi_exprparser.y"
! 8:
! 9: #include "mod_ssi_expr.h"
! 10: #include "buffer.h"
! 11:
! 12: #include <assert.h>
! 13: #include <string.h>
! 14:
! 15: #line 16 "mod_ssi_exprparser.c"
! 16: /* Next is all token values, in a form suitable for use by makeheaders.
! 17: ** This section will be null unless lemon is run with the -m switch.
! 18: */
! 19: /*
! 20: ** These constants (all generated automatically by the parser generator)
! 21: ** specify the various kinds of tokens (terminals) that the parser
! 22: ** understands.
! 23: **
! 24: ** Each symbol here is a terminal symbol in the grammar.
! 25: */
! 26: /* Make sure the INTERFACE macro is defined.
! 27: */
! 28: #ifndef INTERFACE
! 29: # define INTERFACE 1
! 30: #endif
! 31: /* The next thing included is series of defines which control
! 32: ** various aspects of the generated parser.
! 33: ** YYCODETYPE is the data type used for storing terminal
! 34: ** and nonterminal numbers. "unsigned char" is
! 35: ** used if there are fewer than 250 terminals
! 36: ** and nonterminals. "int" is used otherwise.
! 37: ** YYNOCODE is a number of type YYCODETYPE which corresponds
! 38: ** to no legal terminal or nonterminal number. This
! 39: ** number is used to fill in empty slots of the hash
! 40: ** table.
! 41: ** YYFALLBACK If defined, this indicates that one or more tokens
! 42: ** have fall-back values which should be used if the
! 43: ** original value of the token will not parse.
! 44: ** YYACTIONTYPE is the data type used for storing terminal
! 45: ** and nonterminal numbers. "unsigned char" is
! 46: ** used if there are fewer than 250 rules and
! 47: ** states combined. "int" is used otherwise.
! 48: ** ssiexprparserTOKENTYPE is the data type used for minor tokens given
! 49: ** directly to the parser from the tokenizer.
! 50: ** YYMINORTYPE is the data type used for all minor tokens.
! 51: ** This is typically a union of many types, one of
! 52: ** which is ssiexprparserTOKENTYPE. The entry in the union
! 53: ** for base tokens is called "yy0".
! 54: ** YYSTACKDEPTH is the maximum depth of the parser's stack.
! 55: ** ssiexprparserARG_SDECL A static variable declaration for the %extra_argument
! 56: ** ssiexprparserARG_PDECL A parameter declaration for the %extra_argument
! 57: ** ssiexprparserARG_STORE Code to store %extra_argument into yypParser
! 58: ** ssiexprparserARG_FETCH Code to extract %extra_argument from yypParser
! 59: ** YYNSTATE the combined number of states.
! 60: ** YYNRULE the number of rules in the grammar
! 61: ** YYERRORSYMBOL is the code number of the error symbol. If not
! 62: ** defined, then do no error processing.
! 63: */
! 64: /* & */
! 65: #define YYCODETYPE unsigned char
! 66: #define YYNOCODE 20
! 67: #define YYACTIONTYPE unsigned char
! 68: #define ssiexprparserTOKENTYPE buffer *
! 69: typedef union {
! 70: ssiexprparserTOKENTYPE yy0;
! 71: int yy8;
! 72: buffer * yy19;
! 73: ssi_val_t * yy29;
! 74: int yy39;
! 75: } YYMINORTYPE;
! 76: #define YYSTACKDEPTH 100
! 77: #define ssiexprparserARG_SDECL ssi_ctx_t *ctx;
! 78: #define ssiexprparserARG_PDECL ,ssi_ctx_t *ctx
! 79: #define ssiexprparserARG_FETCH ssi_ctx_t *ctx = yypParser->ctx
! 80: #define ssiexprparserARG_STORE yypParser->ctx = ctx
! 81: #define YYNSTATE 23
! 82: #define YYNRULE 16
! 83: #define YYERRORSYMBOL 13
! 84: #define YYERRSYMDT yy39
! 85: #define YY_NO_ACTION (YYNSTATE+YYNRULE+2)
! 86: #define YY_ACCEPT_ACTION (YYNSTATE+YYNRULE+1)
! 87: #define YY_ERROR_ACTION (YYNSTATE+YYNRULE)
! 88:
! 89: /* Next are that tables used to determine what action to take based on the
! 90: ** current state and lookahead token. These tables are used to implement
! 91: ** functions that take a state number and lookahead value and return an
! 92: ** action integer.
! 93: **
! 94: ** Suppose the action integer is N. Then the action is determined as
! 95: ** follows
! 96: **
! 97: ** 0 <= N < YYNSTATE Shift N. That is, push the lookahead
! 98: ** token onto the stack and goto state N.
! 99: **
! 100: ** YYNSTATE <= N < YYNSTATE+YYNRULE Reduce by rule N-YYNSTATE.
! 101: **
! 102: ** N == YYNSTATE+YYNRULE A syntax error has occurred.
! 103: **
! 104: ** N == YYNSTATE+YYNRULE+1 The parser accepts its input.
! 105: **
! 106: ** N == YYNSTATE+YYNRULE+2 No such action. Denotes unused
! 107: ** slots in the yy_action[] table.
! 108: **
! 109: ** The action table is constructed as a single large table named yy_action[].
! 110: ** Given state S and lookahead X, the action is computed as
! 111: **
! 112: ** yy_action[ yy_shift_ofst[S] + X ]
! 113: **
! 114: ** If the index value yy_shift_ofst[S]+X is out of range or if the value
! 115: ** yy_lookahead[yy_shift_ofst[S]+X] is not equal to X or if yy_shift_ofst[S]
! 116: ** is equal to YY_SHIFT_USE_DFLT, it means that the action is not in the table
! 117: ** and that yy_default[S] should be used instead.
! 118: **
! 119: ** The formula above is for computing the action when the lookahead is
! 120: ** a terminal symbol. If the lookahead is a non-terminal (as occurs after
! 121: ** a reduce action) then the yy_reduce_ofst[] array is used in place of
! 122: ** the yy_shift_ofst[] array and YY_REDUCE_USE_DFLT is used in place of
! 123: ** YY_SHIFT_USE_DFLT.
! 124: **
! 125: ** The following are the tables generated in this section:
! 126: **
! 127: ** yy_action[] A single table containing all actions.
! 128: ** yy_lookahead[] A table containing the lookahead for each entry in
! 129: ** yy_action. Used to detect hash collisions.
! 130: ** yy_shift_ofst[] For each state, the offset into yy_action for
! 131: ** shifting terminals.
! 132: ** yy_reduce_ofst[] For each state, the offset into yy_action for
! 133: ** shifting non-terminals after a reduce.
! 134: ** yy_default[] Default action for each state.
! 135: */
! 136: static YYACTIONTYPE yy_action[] = {
! 137: /* 0 */ 5, 7, 17, 18, 22, 20, 21, 19, 2, 14,
! 138: /* 10 */ 1, 23, 40, 9, 11, 3, 16, 2, 14, 12,
! 139: /* 20 */ 4, 14, 5, 7, 6, 14, 7, 8, 14, 10,
! 140: /* 30 */ 14, 13, 37, 37, 15,
! 141: };
! 142: static YYCODETYPE yy_lookahead[] = {
! 143: /* 0 */ 1, 2, 3, 4, 5, 6, 7, 8, 14, 15,
! 144: /* 10 */ 16, 0, 18, 9, 10, 17, 12, 14, 15, 16,
! 145: /* 20 */ 14, 15, 1, 2, 14, 15, 2, 14, 15, 14,
! 146: /* 30 */ 15, 11, 19, 19, 12,
! 147: };
! 148: #define YY_SHIFT_USE_DFLT (-2)
! 149: static signed char yy_shift_ofst[] = {
! 150: /* 0 */ 4, 11, -1, 4, 21, 4, 24, 4, -2, 4,
! 151: /* 10 */ -2, 4, 20, -2, 22, -2, -2, -2, -2, -2,
! 152: /* 20 */ -2, -2, -2,
! 153: };
! 154: #define YY_REDUCE_USE_DFLT (-7)
! 155: static signed char yy_reduce_ofst[] = {
! 156: /* 0 */ -6, -7, -2, 6, -7, 10, -7, 13, -7, 15,
! 157: /* 10 */ -7, 3, -7, -7, -7, -7, -7, -7, -7, -7,
! 158: /* 20 */ -7, -7, -7,
! 159: };
! 160: static YYACTIONTYPE yy_default[] = {
! 161: /* 0 */ 39, 39, 25, 39, 24, 39, 26, 39, 27, 39,
! 162: /* 10 */ 28, 39, 39, 29, 30, 32, 31, 33, 34, 35,
! 163: /* 20 */ 36, 37, 38,
! 164: };
! 165: #define YY_SZ_ACTTAB (sizeof(yy_action)/sizeof(yy_action[0]))
! 166:
! 167: /* The next table maps tokens into fallback tokens. If a construct
! 168: ** like the following:
! 169: **
! 170: ** %fallback ID X Y Z.
! 171: **
! 172: ** appears in the grammer, then ID becomes a fallback token for X, Y,
! 173: ** and Z. Whenever one of the tokens X, Y, or Z is input to the parser
! 174: ** but it does not parse, the type of the token is changed to ID and
! 175: ** the parse is retried before an error is thrown.
! 176: */
! 177: #ifdef YYFALLBACK
! 178: static const YYCODETYPE yyFallback[] = {
! 179: };
! 180: #endif /* YYFALLBACK */
! 181:
! 182: /* The following structure represents a single element of the
! 183: ** parser's stack. Information stored includes:
! 184: **
! 185: ** + The state number for the parser at this level of the stack.
! 186: **
! 187: ** + The value of the token stored at this level of the stack.
! 188: ** (In other words, the "major" token.)
! 189: **
! 190: ** + The semantic value stored at this level of the stack. This is
! 191: ** the information used by the action routines in the grammar.
! 192: ** It is sometimes called the "minor" token.
! 193: */
! 194: struct yyStackEntry {
! 195: int stateno; /* The state-number */
! 196: int major; /* The major token value. This is the code
! 197: ** number for the token at this stack level */
! 198: YYMINORTYPE minor; /* The user-supplied minor token value. This
! 199: ** is the value of the token */
! 200: };
! 201: typedef struct yyStackEntry yyStackEntry;
! 202:
! 203: /* The state of the parser is completely contained in an instance of
! 204: ** the following structure */
! 205: struct yyParser {
! 206: int yyidx; /* Index of top element in stack */
! 207: int yyerrcnt; /* Shifts left before out of the error */
! 208: ssiexprparserARG_SDECL /* A place to hold %extra_argument */
! 209: yyStackEntry yystack[YYSTACKDEPTH]; /* The parser's stack */
! 210: };
! 211: typedef struct yyParser yyParser;
! 212:
! 213: #ifndef NDEBUG
! 214: #include <stdio.h>
! 215: static FILE *yyTraceFILE = NULL;
! 216: static char *yyTracePrompt = NULL;
! 217: #endif /* NDEBUG */
! 218:
! 219: #ifndef NDEBUG
! 220: /*
! 221: ** Turn parser tracing on by giving a stream to which to write the trace
! 222: ** and a prompt to preface each trace message. Tracing is turned off
! 223: ** by making either argument NULL
! 224: **
! 225: ** Inputs:
! 226: ** <ul>
! 227: ** <li> A FILE* to which trace output should be written.
! 228: ** If NULL, then tracing is turned off.
! 229: ** <li> A prefix string written at the beginning of every
! 230: ** line of trace output. If NULL, then tracing is
! 231: ** turned off.
! 232: ** </ul>
! 233: **
! 234: ** Outputs:
! 235: ** None.
! 236: */
! 237: #if 0
! 238: void ssiexprparserTrace(FILE *TraceFILE, char *zTracePrompt){
! 239: yyTraceFILE = TraceFILE;
! 240: yyTracePrompt = zTracePrompt;
! 241: if( yyTraceFILE==0 ) yyTracePrompt = 0;
! 242: else if( yyTracePrompt==0 ) yyTraceFILE = 0;
! 243: }
! 244: #endif
! 245: #endif /* NDEBUG */
! 246:
! 247: #ifndef NDEBUG
! 248: /* For tracing shifts, the names of all terminals and nonterminals
! 249: ** are required. The following table supplies these names */
! 250: static const char *yyTokenName[] = {
! 251: "$", "AND", "OR", "EQ",
! 252: "NE", "GT", "GE", "LT",
! 253: "LE", "NOT", "LPARAN", "RPARAN",
! 254: "VALUE", "error", "expr", "value",
! 255: "exprline", "cond", "input",
! 256: };
! 257: #endif /* NDEBUG */
! 258:
! 259: #ifndef NDEBUG
! 260: /* For tracing reduce actions, the names of all rules are required.
! 261: */
! 262: static const char *yyRuleName[] = {
! 263: /* 0 */ "input ::= exprline",
! 264: /* 1 */ "exprline ::= expr cond expr",
! 265: /* 2 */ "exprline ::= expr",
! 266: /* 3 */ "expr ::= expr AND expr",
! 267: /* 4 */ "expr ::= expr OR expr",
! 268: /* 5 */ "expr ::= NOT expr",
! 269: /* 6 */ "expr ::= LPARAN exprline RPARAN",
! 270: /* 7 */ "expr ::= value",
! 271: /* 8 */ "value ::= VALUE",
! 272: /* 9 */ "value ::= value VALUE",
! 273: /* 10 */ "cond ::= EQ",
! 274: /* 11 */ "cond ::= NE",
! 275: /* 12 */ "cond ::= LE",
! 276: /* 13 */ "cond ::= GE",
! 277: /* 14 */ "cond ::= LT",
! 278: /* 15 */ "cond ::= GT",
! 279: };
! 280: #endif /* NDEBUG */
! 281:
! 282: /*
! 283: ** This function returns the symbolic name associated with a token
! 284: ** value.
! 285: */
! 286: #if 0
! 287: const char *ssiexprparserTokenName(int tokenType){
! 288: #ifndef NDEBUG
! 289: if( tokenType>0 && (size_t)tokenType<(sizeof(yyTokenName)/sizeof(yyTokenName[0])) ){
! 290: return yyTokenName[tokenType];
! 291: }else{
! 292: return "Unknown";
! 293: }
! 294: #else
! 295: return "";
! 296: #endif
! 297: }
! 298: #endif
! 299:
! 300: /*
! 301: ** This function allocates a new parser.
! 302: ** The only argument is a pointer to a function which works like
! 303: ** malloc.
! 304: **
! 305: ** Inputs:
! 306: ** A pointer to the function used to allocate memory.
! 307: **
! 308: ** Outputs:
! 309: ** A pointer to a parser. This pointer is used in subsequent calls
! 310: ** to ssiexprparser and ssiexprparserFree.
! 311: */
! 312: void *ssiexprparserAlloc(void *(*mallocProc)(size_t)){
! 313: yyParser *pParser;
! 314: pParser = (yyParser*)(*mallocProc)( (size_t)sizeof(yyParser) );
! 315: if( pParser ){
! 316: pParser->yyidx = -1;
! 317: }
! 318: return pParser;
! 319: }
! 320:
! 321: /* The following function deletes the value associated with a
! 322: ** symbol. The symbol can be either a terminal or nonterminal.
! 323: ** "yymajor" is the symbol code, and "yypminor" is a pointer to
! 324: ** the value.
! 325: */
! 326: static void yy_destructor(YYCODETYPE yymajor, YYMINORTYPE *yypminor){
! 327: switch( yymajor ){
! 328: /* Here is inserted the actions which take place when a
! 329: ** terminal or non-terminal is destroyed. This can happen
! 330: ** when the symbol is popped from the stack during a
! 331: ** reduce or during error processing or when a parser is
! 332: ** being destroyed before it is finished parsing.
! 333: **
! 334: ** Note: during a reduce, the only symbols destroyed are those
! 335: ** which appear on the RHS of the rule, but which are not used
! 336: ** inside the C code.
! 337: */
! 338: case 1:
! 339: case 2:
! 340: case 3:
! 341: case 4:
! 342: case 5:
! 343: case 6:
! 344: case 7:
! 345: case 8:
! 346: case 9:
! 347: case 10:
! 348: case 11:
! 349: case 12:
! 350: #line 22 "../../src/mod_ssi_exprparser.y"
! 351: { buffer_free((yypminor->yy0)); }
! 352: #line 352 "mod_ssi_exprparser.c"
! 353: break;
! 354: default: break; /* If no destructor action specified: do nothing */
! 355: }
! 356: }
! 357:
! 358: /*
! 359: ** Pop the parser's stack once.
! 360: **
! 361: ** If there is a destructor routine associated with the token which
! 362: ** is popped from the stack, then call it.
! 363: **
! 364: ** Return the major token number for the symbol popped.
! 365: */
! 366: static int yy_pop_parser_stack(yyParser *pParser){
! 367: YYCODETYPE yymajor;
! 368: yyStackEntry *yytos = &pParser->yystack[pParser->yyidx];
! 369:
! 370: if( pParser->yyidx<0 ) return 0;
! 371: #ifndef NDEBUG
! 372: if( yyTraceFILE && pParser->yyidx>=0 ){
! 373: fprintf(yyTraceFILE,"%sPopping %s\n",
! 374: yyTracePrompt,
! 375: yyTokenName[yytos->major]);
! 376: }
! 377: #endif
! 378: yymajor = yytos->major;
! 379: yy_destructor( yymajor, &yytos->minor);
! 380: pParser->yyidx--;
! 381: return yymajor;
! 382: }
! 383:
! 384: /*
! 385: ** Deallocate and destroy a parser. Destructors are all called for
! 386: ** all stack elements before shutting the parser down.
! 387: **
! 388: ** Inputs:
! 389: ** <ul>
! 390: ** <li> A pointer to the parser. This should be a pointer
! 391: ** obtained from ssiexprparserAlloc.
! 392: ** <li> A pointer to a function used to reclaim memory obtained
! 393: ** from malloc.
! 394: ** </ul>
! 395: */
! 396: void ssiexprparserFree(
! 397: void *p, /* The parser to be deleted */
! 398: void (*freeProc)(void*) /* Function used to reclaim memory */
! 399: ){
! 400: yyParser *pParser = (yyParser*)p;
! 401: if( pParser==NULL ) return;
! 402: while( pParser->yyidx>=0 ) yy_pop_parser_stack(pParser);
! 403: (*freeProc)((void*)pParser);
! 404: }
! 405:
! 406: /*
! 407: ** Find the appropriate action for a parser given the terminal
! 408: ** look-ahead token iLookAhead.
! 409: **
! 410: ** If the look-ahead token is YYNOCODE, then check to see if the action is
! 411: ** independent of the look-ahead. If it is, return the action, otherwise
! 412: ** return YY_NO_ACTION.
! 413: */
! 414: static int yy_find_shift_action(
! 415: yyParser *pParser, /* The parser */
! 416: int iLookAhead /* The look-ahead token */
! 417: ){
! 418: int i;
! 419: int stateno = pParser->yystack[pParser->yyidx].stateno;
! 420:
! 421: /* if( pParser->yyidx<0 ) return YY_NO_ACTION; */
! 422: i = yy_shift_ofst[stateno];
! 423: if( i==YY_SHIFT_USE_DFLT ){
! 424: return yy_default[stateno];
! 425: }
! 426: if( iLookAhead==YYNOCODE ){
! 427: return YY_NO_ACTION;
! 428: }
! 429: i += iLookAhead;
! 430: if( i<0 || (size_t)i>=YY_SZ_ACTTAB || yy_lookahead[i]!=iLookAhead ){
! 431: #ifdef YYFALLBACK
! 432: int iFallback; /* Fallback token */
! 433: if( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0])
! 434: && (iFallback = yyFallback[iLookAhead])!=0 ){
! 435: #ifndef NDEBUG
! 436: if( yyTraceFILE ){
! 437: fprintf(yyTraceFILE, "%sFALLBACK %s => %s\n",
! 438: yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[iFallback]);
! 439: }
! 440: #endif
! 441: return yy_find_shift_action(pParser, iFallback);
! 442: }
! 443: #endif
! 444: return yy_default[stateno];
! 445: }else{
! 446: return yy_action[i];
! 447: }
! 448: }
! 449:
! 450: /*
! 451: ** Find the appropriate action for a parser given the non-terminal
! 452: ** look-ahead token iLookAhead.
! 453: **
! 454: ** If the look-ahead token is YYNOCODE, then check to see if the action is
! 455: ** independent of the look-ahead. If it is, return the action, otherwise
! 456: ** return YY_NO_ACTION.
! 457: */
! 458: static int yy_find_reduce_action(
! 459: yyParser *pParser, /* The parser */
! 460: int iLookAhead /* The look-ahead token */
! 461: ){
! 462: int i;
! 463: int stateno = pParser->yystack[pParser->yyidx].stateno;
! 464:
! 465: i = yy_reduce_ofst[stateno];
! 466: if( i==YY_REDUCE_USE_DFLT ){
! 467: return yy_default[stateno];
! 468: }
! 469: if( iLookAhead==YYNOCODE ){
! 470: return YY_NO_ACTION;
! 471: }
! 472: i += iLookAhead;
! 473: if( i<0 || (size_t)i>=YY_SZ_ACTTAB || yy_lookahead[i]!=iLookAhead ){
! 474: return yy_default[stateno];
! 475: }else{
! 476: return yy_action[i];
! 477: }
! 478: }
! 479:
! 480: /*
! 481: ** Perform a shift action.
! 482: */
! 483: static void yy_shift(
! 484: yyParser *yypParser, /* The parser to be shifted */
! 485: int yyNewState, /* The new state to shift in */
! 486: int yyMajor, /* The major token to shift in */
! 487: YYMINORTYPE *yypMinor /* Pointer ot the minor token to shift in */
! 488: ){
! 489: yyStackEntry *yytos;
! 490: yypParser->yyidx++;
! 491: if( yypParser->yyidx>=YYSTACKDEPTH ){
! 492: ssiexprparserARG_FETCH;
! 493: yypParser->yyidx--;
! 494: #ifndef NDEBUG
! 495: if( yyTraceFILE ){
! 496: fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt);
! 497: }
! 498: #endif
! 499: while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);
! 500: /* Here code is inserted which will execute if the parser
! 501: ** stack every overflows */
! 502: ssiexprparserARG_STORE; /* Suppress warning about unused %extra_argument var */
! 503: return;
! 504: }
! 505: yytos = &yypParser->yystack[yypParser->yyidx];
! 506: yytos->stateno = yyNewState;
! 507: yytos->major = yyMajor;
! 508: yytos->minor = *yypMinor;
! 509: #ifndef NDEBUG
! 510: if( yyTraceFILE && yypParser->yyidx>0 ){
! 511: int i;
! 512: fprintf(yyTraceFILE,"%sShift %d\n",yyTracePrompt,yyNewState);
! 513: fprintf(yyTraceFILE,"%sStack:",yyTracePrompt);
! 514: for(i=1; i<=yypParser->yyidx; i++)
! 515: fprintf(yyTraceFILE," %s",yyTokenName[yypParser->yystack[i].major]);
! 516: fprintf(yyTraceFILE,"\n");
! 517: }
! 518: #endif
! 519: }
! 520:
! 521: /* The following table contains information about every rule that
! 522: ** is used during the reduce.
! 523: */
! 524: static struct {
! 525: YYCODETYPE lhs; /* Symbol on the left-hand side of the rule */
! 526: unsigned char nrhs; /* Number of right-hand side symbols in the rule */
! 527: } yyRuleInfo[] = {
! 528: { 18, 1 },
! 529: { 16, 3 },
! 530: { 16, 1 },
! 531: { 14, 3 },
! 532: { 14, 3 },
! 533: { 14, 2 },
! 534: { 14, 3 },
! 535: { 14, 1 },
! 536: { 15, 1 },
! 537: { 15, 2 },
! 538: { 17, 1 },
! 539: { 17, 1 },
! 540: { 17, 1 },
! 541: { 17, 1 },
! 542: { 17, 1 },
! 543: { 17, 1 },
! 544: };
! 545:
! 546: static void yy_accept(yyParser*); /* Forward Declaration */
! 547:
! 548: /*
! 549: ** Perform a reduce action and the shift that must immediately
! 550: ** follow the reduce.
! 551: */
! 552: static void yy_reduce(
! 553: yyParser *yypParser, /* The parser */
! 554: int yyruleno /* Number of the rule by which to reduce */
! 555: ){
! 556: int yygoto; /* The next state */
! 557: int yyact; /* The next action */
! 558: YYMINORTYPE yygotominor; /* The LHS of the rule reduced */
! 559: yyStackEntry *yymsp; /* The top of the parser's stack */
! 560: int yysize; /* Amount to pop the stack */
! 561: ssiexprparserARG_FETCH;
! 562: yymsp = &yypParser->yystack[yypParser->yyidx];
! 563: #ifndef NDEBUG
! 564: if( yyTraceFILE && yyruleno>=0
! 565: && (size_t)yyruleno<sizeof(yyRuleName)/sizeof(yyRuleName[0]) ){
! 566: fprintf(yyTraceFILE, "%sReduce [%s].\n", yyTracePrompt,
! 567: yyRuleName[yyruleno]);
! 568: }
! 569: #endif /* NDEBUG */
! 570:
! 571: switch( yyruleno ){
! 572: /* Beginning here are the reduction cases. A typical example
! 573: ** follows:
! 574: ** case 0:
! 575: ** #line <lineno> <grammarfile>
! 576: ** { ... } // User supplied code
! 577: ** #line <lineno> <thisfile>
! 578: ** break;
! 579: */
! 580: case 0:
! 581: #line 29 "../../src/mod_ssi_exprparser.y"
! 582: {
! 583: ctx->val.bo = ssi_val_tobool(yymsp[0].minor.yy29);
! 584: ctx->val.type = SSI_TYPE_BOOL;
! 585:
! 586: ssi_val_free(yymsp[0].minor.yy29);
! 587: }
! 588: #line 588 "mod_ssi_exprparser.c"
! 589: break;
! 590: case 1:
! 591: #line 36 "../../src/mod_ssi_exprparser.y"
! 592: {
! 593: int cmp;
! 594:
! 595: if (yymsp[-2].minor.yy29->type == SSI_TYPE_STRING &&
! 596: yymsp[0].minor.yy29->type == SSI_TYPE_STRING) {
! 597: cmp = strcmp(yymsp[-2].minor.yy29->str->ptr, yymsp[0].minor.yy29->str->ptr);
! 598: } else {
! 599: cmp = ssi_val_tobool(yymsp[-2].minor.yy29) - ssi_val_tobool(yymsp[0].minor.yy29);
! 600: }
! 601:
! 602: yygotominor.yy29 = yymsp[-2].minor.yy29;
! 603:
! 604: switch(yymsp[-1].minor.yy8) {
! 605: case SSI_COND_EQ: yygotominor.yy29->bo = (cmp == 0) ? 1 : 0; break;
! 606: case SSI_COND_NE: yygotominor.yy29->bo = (cmp != 0) ? 1 : 0; break;
! 607: case SSI_COND_GE: yygotominor.yy29->bo = (cmp >= 0) ? 1 : 0; break;
! 608: case SSI_COND_GT: yygotominor.yy29->bo = (cmp > 0) ? 1 : 0; break;
! 609: case SSI_COND_LE: yygotominor.yy29->bo = (cmp <= 0) ? 1 : 0; break;
! 610: case SSI_COND_LT: yygotominor.yy29->bo = (cmp < 0) ? 1 : 0; break;
! 611: }
! 612:
! 613: yygotominor.yy29->type = SSI_TYPE_BOOL;
! 614:
! 615: ssi_val_free(yymsp[0].minor.yy29);
! 616: }
! 617: #line 617 "mod_ssi_exprparser.c"
! 618: break;
! 619: case 2:
! 620: #line 61 "../../src/mod_ssi_exprparser.y"
! 621: {
! 622: yygotominor.yy29 = yymsp[0].minor.yy29;
! 623: }
! 624: #line 624 "mod_ssi_exprparser.c"
! 625: break;
! 626: case 3:
! 627: #line 64 "../../src/mod_ssi_exprparser.y"
! 628: {
! 629: int e;
! 630:
! 631: e = ssi_val_tobool(yymsp[-2].minor.yy29) && ssi_val_tobool(yymsp[0].minor.yy29);
! 632:
! 633: yygotominor.yy29 = yymsp[-2].minor.yy29;
! 634: yygotominor.yy29->bo = e;
! 635: yygotominor.yy29->type = SSI_TYPE_BOOL;
! 636: ssi_val_free(yymsp[0].minor.yy29);
! 637: }
! 638: #line 638 "mod_ssi_exprparser.c"
! 639: yy_destructor(1,&yymsp[-1].minor);
! 640: break;
! 641: case 4:
! 642: #line 75 "../../src/mod_ssi_exprparser.y"
! 643: {
! 644: int e;
! 645:
! 646: e = ssi_val_tobool(yymsp[-2].minor.yy29) || ssi_val_tobool(yymsp[0].minor.yy29);
! 647:
! 648: yygotominor.yy29 = yymsp[-2].minor.yy29;
! 649: yygotominor.yy29->bo = e;
! 650: yygotominor.yy29->type = SSI_TYPE_BOOL;
! 651: ssi_val_free(yymsp[0].minor.yy29);
! 652: }
! 653: #line 653 "mod_ssi_exprparser.c"
! 654: yy_destructor(2,&yymsp[-1].minor);
! 655: break;
! 656: case 5:
! 657: #line 86 "../../src/mod_ssi_exprparser.y"
! 658: {
! 659: int e;
! 660:
! 661: e = !ssi_val_tobool(yymsp[0].minor.yy29);
! 662:
! 663: yygotominor.yy29 = yymsp[0].minor.yy29;
! 664: yygotominor.yy29->bo = e;
! 665: yygotominor.yy29->type = SSI_TYPE_BOOL;
! 666: }
! 667: #line 667 "mod_ssi_exprparser.c"
! 668: yy_destructor(9,&yymsp[-1].minor);
! 669: break;
! 670: case 6:
! 671: #line 95 "../../src/mod_ssi_exprparser.y"
! 672: {
! 673: yygotominor.yy29 = yymsp[-1].minor.yy29;
! 674: }
! 675: #line 675 "mod_ssi_exprparser.c"
! 676: yy_destructor(10,&yymsp[-2].minor);
! 677: yy_destructor(11,&yymsp[0].minor);
! 678: break;
! 679: case 7:
! 680: #line 99 "../../src/mod_ssi_exprparser.y"
! 681: {
! 682: yygotominor.yy29 = ssi_val_init();
! 683: yygotominor.yy29->str = yymsp[0].minor.yy19;
! 684: yygotominor.yy29->type = SSI_TYPE_STRING;
! 685: }
! 686: #line 686 "mod_ssi_exprparser.c"
! 687: break;
! 688: case 8:
! 689: #line 105 "../../src/mod_ssi_exprparser.y"
! 690: {
! 691: yygotominor.yy19 = yymsp[0].minor.yy0;
! 692: }
! 693: #line 693 "mod_ssi_exprparser.c"
! 694: break;
! 695: case 9:
! 696: #line 109 "../../src/mod_ssi_exprparser.y"
! 697: {
! 698: yygotominor.yy19 = yymsp[-1].minor.yy19;
! 699: buffer_append_string_buffer(yygotominor.yy19, yymsp[0].minor.yy0);
! 700: buffer_free(yymsp[0].minor.yy0);
! 701: }
! 702: #line 702 "mod_ssi_exprparser.c"
! 703: break;
! 704: case 10:
! 705: #line 115 "../../src/mod_ssi_exprparser.y"
! 706: { yygotominor.yy8 = SSI_COND_EQ; }
! 707: #line 707 "mod_ssi_exprparser.c"
! 708: yy_destructor(3,&yymsp[0].minor);
! 709: break;
! 710: case 11:
! 711: #line 116 "../../src/mod_ssi_exprparser.y"
! 712: { yygotominor.yy8 = SSI_COND_NE; }
! 713: #line 713 "mod_ssi_exprparser.c"
! 714: yy_destructor(4,&yymsp[0].minor);
! 715: break;
! 716: case 12:
! 717: #line 117 "../../src/mod_ssi_exprparser.y"
! 718: { yygotominor.yy8 = SSI_COND_LE; }
! 719: #line 719 "mod_ssi_exprparser.c"
! 720: yy_destructor(8,&yymsp[0].minor);
! 721: break;
! 722: case 13:
! 723: #line 118 "../../src/mod_ssi_exprparser.y"
! 724: { yygotominor.yy8 = SSI_COND_GE; }
! 725: #line 725 "mod_ssi_exprparser.c"
! 726: yy_destructor(6,&yymsp[0].minor);
! 727: break;
! 728: case 14:
! 729: #line 119 "../../src/mod_ssi_exprparser.y"
! 730: { yygotominor.yy8 = SSI_COND_LT; }
! 731: #line 731 "mod_ssi_exprparser.c"
! 732: yy_destructor(7,&yymsp[0].minor);
! 733: break;
! 734: case 15:
! 735: #line 120 "../../src/mod_ssi_exprparser.y"
! 736: { yygotominor.yy8 = SSI_COND_GT; }
! 737: #line 737 "mod_ssi_exprparser.c"
! 738: yy_destructor(5,&yymsp[0].minor);
! 739: break;
! 740: };
! 741: yygoto = yyRuleInfo[yyruleno].lhs;
! 742: yysize = yyRuleInfo[yyruleno].nrhs;
! 743: yypParser->yyidx -= yysize;
! 744: yyact = yy_find_reduce_action(yypParser,yygoto);
! 745: if( yyact < YYNSTATE ){
! 746: yy_shift(yypParser,yyact,yygoto,&yygotominor);
! 747: }else if( yyact == YYNSTATE + YYNRULE + 1 ){
! 748: yy_accept(yypParser);
! 749: }
! 750: }
! 751:
! 752: /*
! 753: ** The following code executes when the parse fails
! 754: */
! 755: static void yy_parse_failed(
! 756: yyParser *yypParser /* The parser */
! 757: ){
! 758: ssiexprparserARG_FETCH;
! 759: #ifndef NDEBUG
! 760: if( yyTraceFILE ){
! 761: fprintf(yyTraceFILE,"%sFail!\n",yyTracePrompt);
! 762: }
! 763: #endif
! 764: while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);
! 765: /* Here code is inserted which will be executed whenever the
! 766: ** parser fails */
! 767: #line 14 "../../src/mod_ssi_exprparser.y"
! 768:
! 769: ctx->ok = 0;
! 770:
! 771: #line 771 "mod_ssi_exprparser.c"
! 772: ssiexprparserARG_STORE; /* Suppress warning about unused %extra_argument variable */
! 773: }
! 774:
! 775: /*
! 776: ** The following code executes when a syntax error first occurs.
! 777: */
! 778: static void yy_syntax_error(
! 779: yyParser *yypParser, /* The parser */
! 780: int yymajor, /* The major type of the error token */
! 781: YYMINORTYPE yyminor /* The minor type of the error token */
! 782: ){
! 783: ssiexprparserARG_FETCH;
! 784: UNUSED(yymajor);
! 785: UNUSED(yyminor);
! 786: #define TOKEN (yyminor.yy0)
! 787: ssiexprparserARG_STORE; /* Suppress warning about unused %extra_argument variable */
! 788: }
! 789:
! 790: /*
! 791: ** The following is executed when the parser accepts
! 792: */
! 793: static void yy_accept(
! 794: yyParser *yypParser /* The parser */
! 795: ){
! 796: ssiexprparserARG_FETCH;
! 797: #ifndef NDEBUG
! 798: if( yyTraceFILE ){
! 799: fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt);
! 800: }
! 801: #endif
! 802: while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);
! 803: /* Here code is inserted which will be executed whenever the
! 804: ** parser accepts */
! 805: ssiexprparserARG_STORE; /* Suppress warning about unused %extra_argument variable */
! 806: }
! 807:
! 808: /* The main parser program.
! 809: ** The first argument is a pointer to a structure obtained from
! 810: ** "ssiexprparserAlloc" which describes the current state of the parser.
! 811: ** The second argument is the major token number. The third is
! 812: ** the minor token. The fourth optional argument is whatever the
! 813: ** user wants (and specified in the grammar) and is available for
! 814: ** use by the action routines.
! 815: **
! 816: ** Inputs:
! 817: ** <ul>
! 818: ** <li> A pointer to the parser (an opaque structure.)
! 819: ** <li> The major token number.
! 820: ** <li> The minor token number.
! 821: ** <li> An option argument of a grammar-specified type.
! 822: ** </ul>
! 823: **
! 824: ** Outputs:
! 825: ** None.
! 826: */
! 827: void ssiexprparser(
! 828: void *yyp, /* The parser */
! 829: int yymajor, /* The major token code number */
! 830: ssiexprparserTOKENTYPE yyminor /* The value for the token */
! 831: ssiexprparserARG_PDECL /* Optional %extra_argument parameter */
! 832: ){
! 833: YYMINORTYPE yyminorunion;
! 834: int yyact; /* The parser action. */
! 835: int yyendofinput; /* True if we are at the end of input */
! 836: int yyerrorhit = 0; /* True if yymajor has invoked an error */
! 837: yyParser *yypParser; /* The parser */
! 838:
! 839: /* (re)initialize the parser, if necessary */
! 840: yypParser = (yyParser*)yyp;
! 841: if( yypParser->yyidx<0 ){
! 842: if( yymajor==0 ) return;
! 843: yypParser->yyidx = 0;
! 844: yypParser->yyerrcnt = -1;
! 845: yypParser->yystack[0].stateno = 0;
! 846: yypParser->yystack[0].major = 0;
! 847: }
! 848: yyminorunion.yy0 = yyminor;
! 849: yyendofinput = (yymajor==0);
! 850: ssiexprparserARG_STORE;
! 851:
! 852: #ifndef NDEBUG
! 853: if( yyTraceFILE ){
! 854: fprintf(yyTraceFILE,"%sInput %s\n",yyTracePrompt,yyTokenName[yymajor]);
! 855: }
! 856: #endif
! 857:
! 858: do{
! 859: yyact = yy_find_shift_action(yypParser,yymajor);
! 860: if( yyact<YYNSTATE ){
! 861: yy_shift(yypParser,yyact,yymajor,&yyminorunion);
! 862: yypParser->yyerrcnt--;
! 863: if( yyendofinput && yypParser->yyidx>=0 ){
! 864: yymajor = 0;
! 865: }else{
! 866: yymajor = YYNOCODE;
! 867: }
! 868: }else if( yyact < YYNSTATE + YYNRULE ){
! 869: yy_reduce(yypParser,yyact-YYNSTATE);
! 870: }else if( yyact == YY_ERROR_ACTION ){
! 871: int yymx;
! 872: #ifndef NDEBUG
! 873: if( yyTraceFILE ){
! 874: fprintf(yyTraceFILE,"%sSyntax Error!\n",yyTracePrompt);
! 875: }
! 876: #endif
! 877: #ifdef YYERRORSYMBOL
! 878: /* A syntax error has occurred.
! 879: ** The response to an error depends upon whether or not the
! 880: ** grammar defines an error token "ERROR".
! 881: **
! 882: ** This is what we do if the grammar does define ERROR:
! 883: **
! 884: ** * Call the %syntax_error function.
! 885: **
! 886: ** * Begin popping the stack until we enter a state where
! 887: ** it is legal to shift the error symbol, then shift
! 888: ** the error symbol.
! 889: **
! 890: ** * Set the error count to three.
! 891: **
! 892: ** * Begin accepting and shifting new tokens. No new error
! 893: ** processing will occur until three tokens have been
! 894: ** shifted successfully.
! 895: **
! 896: */
! 897: if( yypParser->yyerrcnt<0 ){
! 898: yy_syntax_error(yypParser,yymajor,yyminorunion);
! 899: }
! 900: yymx = yypParser->yystack[yypParser->yyidx].major;
! 901: if( yymx==YYERRORSYMBOL || yyerrorhit ){
! 902: #ifndef NDEBUG
! 903: if( yyTraceFILE ){
! 904: fprintf(yyTraceFILE,"%sDiscard input token %s\n",
! 905: yyTracePrompt,yyTokenName[yymajor]);
! 906: }
! 907: #endif
! 908: yy_destructor(yymajor,&yyminorunion);
! 909: yymajor = YYNOCODE;
! 910: }else{
! 911: while(
! 912: yypParser->yyidx >= 0 &&
! 913: yymx != YYERRORSYMBOL &&
! 914: (yyact = yy_find_shift_action(yypParser,YYERRORSYMBOL)) >= YYNSTATE
! 915: ){
! 916: yy_pop_parser_stack(yypParser);
! 917: }
! 918: if( yypParser->yyidx < 0 || yymajor==0 ){
! 919: yy_destructor(yymajor,&yyminorunion);
! 920: yy_parse_failed(yypParser);
! 921: yymajor = YYNOCODE;
! 922: }else if( yymx!=YYERRORSYMBOL ){
! 923: YYMINORTYPE u2;
! 924: u2.YYERRSYMDT = 0;
! 925: yy_shift(yypParser,yyact,YYERRORSYMBOL,&u2);
! 926: }
! 927: }
! 928: yypParser->yyerrcnt = 3;
! 929: yyerrorhit = 1;
! 930: #else /* YYERRORSYMBOL is not defined */
! 931: /* This is what we do if the grammar does not define ERROR:
! 932: **
! 933: ** * Report an error message, and throw away the input token.
! 934: **
! 935: ** * If the input token is $, then fail the parse.
! 936: **
! 937: ** As before, subsequent error messages are suppressed until
! 938: ** three input tokens have been successfully shifted.
! 939: */
! 940: if( yypParser->yyerrcnt<=0 ){
! 941: yy_syntax_error(yypParser,yymajor,yyminorunion);
! 942: }
! 943: yypParser->yyerrcnt = 3;
! 944: yy_destructor(yymajor,&yyminorunion);
! 945: if( yyendofinput ){
! 946: yy_parse_failed(yypParser);
! 947: }
! 948: yymajor = YYNOCODE;
! 949: #endif
! 950: }else{
! 951: yy_accept(yypParser);
! 952: yymajor = YYNOCODE;
! 953: }
! 954: }while( yymajor!=YYNOCODE && yypParser->yyidx>=0 );
! 955: return;
! 956: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to mod_ssi_exprparser.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