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