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