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 126static 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*/ 143struct 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}; 150typedef struct yyStackEntry yyStackEntry; 151 152/* The state of the parser is completely contained in an instance of 153** the following structure */ 154struct 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}; 160typedef struct yyParser yyParser; 161 162#ifndef NDEBUG 163#include <stdio.h> 164static FILE *yyTraceFILE = 0; 165static 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*/ 186void 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 */ 197static 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*/ 205static const char *yyRuleName[] = { 206%% 207}; 208#endif /* NDEBUG */ 209 210/* 211** This function returns the symbolic name associated with a token 212** value. 213*/ 214const 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*/ 238void *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*/ 252static 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*/ 277static 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*/ 307void 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*/ 325static 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*/ 369static 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*/ 394static 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*/ 436static 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 443static void yy_accept(yyParser*); /* Forward Declaration */ 444 445/* 446** Perform a reduce action and the shift that must immediately 447** follow the reduce. 448*/ 449static 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*/ 493static 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*/ 512static 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*/ 526static 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*/ 561void 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