tool/lempar.c

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