rename_debug.c revision 264790
1/* original parser id follows */ 2/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ 3/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */ 4 5#define YYBYACC 1 6#define YYMAJOR 1 7#define YYMINOR 9 8#define YYCHECK "yyyymmdd" 9 10#define YYEMPTY (-1) 11#define yyclearin (yychar = YYEMPTY) 12#define yyerrok (yyerrflag = 0) 13#define YYRECOVERING() (yyerrflag != 0) 14#define YYENOMEM (-2) 15#define YYEOF 0 16#undef YYBTYACC 17#define YYBTYACC 0 18#define YYDEBUGSTR YYPREFIX "debug" 19#line 20 "rename_debug.c" 20#include "rename_debug.i" 21#include "rename_debug.h" 22typedef short YYINT; 23static const YYINT yylhs[] = { -1, 24 0, 25}; 26static const YYINT yylen[] = { 2, 27 1, 28}; 29static const YYINT yydefred[] = { 0, 30 1, 0, 31}; 32static const YYINT yystos[] = { 0, 33 256, 258, 34}; 35static const YYINT yydgoto[] = { 2, 36}; 37static const YYINT yysindex[] = { -256, 38 0, 0, 39}; 40static const YYINT yyrindex[] = { 0, 41 0, 0, 42}; 43#if YYBTYACC 44static const YYINT yycindex[] = { 0, 45 0, 0, 46}; 47#endif 48static const YYINT yygindex[] = { 0, 49}; 50#define YYTABLESIZE 0 51static const YYINT yytable[] = { 1, 52}; 53static const YYINT yycheck[] = { 256, 54}; 55#define YYFINAL 2 56#ifndef YYDEBUG 57#define YYDEBUG 1 58#endif 59#define YYMAXTOKEN 256 60#define YYUNDFTOKEN 259 61#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a)) 62#if YYDEBUG 63static const char *const yyname[] = { 64 65"$end",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 660,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 670,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 680,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 690,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 700,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 710,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"error","$accept","S","illegal-symbol", 72}; 73static const char *const yyrule[] = { 74"$accept : S", 75"S : error", 76 77}; 78#endif 79 80int yydebug; 81int yynerrs; 82 83int yyerrflag; 84int yychar; 85YYSTYPE yyval; 86YYSTYPE yylval; 87#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 88YYLTYPE yyloc; /* position returned by actions */ 89YYLTYPE yylloc; /* position from the lexer */ 90#endif 91 92#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 93#ifndef YYLLOC_DEFAULT 94#define YYLLOC_DEFAULT(loc, rhs, n) \ 95do \ 96{ \ 97 if (n == 0) \ 98 { \ 99 (loc).first_line = ((rhs)[-1]).last_line; \ 100 (loc).first_column = ((rhs)[-1]).last_column; \ 101 (loc).last_line = ((rhs)[-1]).last_line; \ 102 (loc).last_column = ((rhs)[-1]).last_column; \ 103 } \ 104 else \ 105 { \ 106 (loc).first_line = ((rhs)[ 0 ]).first_line; \ 107 (loc).first_column = ((rhs)[ 0 ]).first_column; \ 108 (loc).last_line = ((rhs)[n-1]).last_line; \ 109 (loc).last_column = ((rhs)[n-1]).last_column; \ 110 } \ 111} while (0) 112#endif /* YYLLOC_DEFAULT */ 113#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 114#if YYBTYACC 115 116#ifndef YYLVQUEUEGROWTH 117#define YYLVQUEUEGROWTH 32 118#endif 119#endif /* YYBTYACC */ 120 121/* define the initial stack-sizes */ 122#ifdef YYSTACKSIZE 123#undef YYMAXDEPTH 124#define YYMAXDEPTH YYSTACKSIZE 125#else 126#ifdef YYMAXDEPTH 127#define YYSTACKSIZE YYMAXDEPTH 128#else 129#define YYSTACKSIZE 10000 130#define YYMAXDEPTH 10000 131#endif 132#endif 133 134#ifndef YYINITSTACKSIZE 135#define YYINITSTACKSIZE 200 136#endif 137 138typedef struct { 139 unsigned stacksize; 140 short *s_base; 141 short *s_mark; 142 short *s_last; 143 YYSTYPE *l_base; 144 YYSTYPE *l_mark; 145#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 146 YYLTYPE *p_base; 147 YYLTYPE *p_mark; 148#endif 149} YYSTACKDATA; 150#if YYBTYACC 151 152struct YYParseState_s 153{ 154 struct YYParseState_s *save; /* Previously saved parser state */ 155 YYSTACKDATA yystack; /* saved parser stack */ 156 int state; /* saved parser state */ 157 int errflag; /* saved error recovery status */ 158 int lexeme; /* saved index of the conflict lexeme in the lexical queue */ 159 YYINT ctry; /* saved index in yyctable[] for this conflict */ 160}; 161typedef struct YYParseState_s YYParseState; 162#endif /* YYBTYACC */ 163/* variables for the parser stack */ 164static YYSTACKDATA yystack; 165#if YYBTYACC 166 167/* Current parser state */ 168static YYParseState *yyps = 0; 169 170/* yypath != NULL: do the full parse, starting at *yypath parser state. */ 171static YYParseState *yypath = 0; 172 173/* Base of the lexical value queue */ 174static YYSTYPE *yylvals = 0; 175 176/* Current position at lexical value queue */ 177static YYSTYPE *yylvp = 0; 178 179/* End position of lexical value queue */ 180static YYSTYPE *yylve = 0; 181 182/* The last allocated position at the lexical value queue */ 183static YYSTYPE *yylvlim = 0; 184 185#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 186/* Base of the lexical position queue */ 187static YYLTYPE *yylpsns = 0; 188 189/* Current position at lexical position queue */ 190static YYLTYPE *yylpp = 0; 191 192/* End position of lexical position queue */ 193static YYLTYPE *yylpe = 0; 194 195/* The last allocated position at the lexical position queue */ 196static YYLTYPE *yylplim = 0; 197#endif 198 199/* Current position at lexical token queue */ 200static short *yylexp = 0; 201 202static short *yylexemes = 0; 203#endif /* YYBTYACC */ 204#line 12 "code_debug.y" 205 206#include <stdio.h> 207 208#ifdef YYBYACC 209extern int YYLEX_DECL(); 210#endif 211 212int 213main(void) 214{ 215 printf("yyparse() = %d\n", yyparse()); 216 return 0; 217} 218 219int 220yylex(void) 221{ 222 return -1; 223} 224 225static void 226yyerror(const char* s) 227{ 228 printf("%s\n", s); 229} 230#line 232 "rename_debug.c" 231 232/* For use in generated program */ 233#define yydepth (int)(yystack.s_mark - yystack.s_base) 234#if YYBTYACC 235#define yytrial (yyps->save) 236#endif /* YYBTYACC */ 237 238#if YYDEBUG 239#include <stdio.h> /* needed for printf */ 240#endif 241 242#include <stdlib.h> /* needed for malloc, etc */ 243#include <string.h> /* needed for memset */ 244 245/* allocate initial stack or double stack size, up to YYMAXDEPTH */ 246static int yygrowstack(YYSTACKDATA *data) 247{ 248 int i; 249 unsigned newsize; 250 short *newss; 251 YYSTYPE *newvs; 252#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 253 YYLTYPE *newps; 254#endif 255 256 if ((newsize = data->stacksize) == 0) 257 newsize = YYINITSTACKSIZE; 258 else if (newsize >= YYMAXDEPTH) 259 return YYENOMEM; 260 else if ((newsize *= 2) > YYMAXDEPTH) 261 newsize = YYMAXDEPTH; 262 263 i = (int) (data->s_mark - data->s_base); 264 newss = (short *)realloc(data->s_base, newsize * sizeof(*newss)); 265 if (newss == 0) 266 return YYENOMEM; 267 268 data->s_base = newss; 269 data->s_mark = newss + i; 270 271 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs)); 272 if (newvs == 0) 273 return YYENOMEM; 274 275 data->l_base = newvs; 276 data->l_mark = newvs + i; 277 278#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 279 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps)); 280 if (newps == 0) 281 return YYENOMEM; 282 283 data->p_base = newps; 284 data->p_mark = newps + i; 285#endif 286 287 data->stacksize = newsize; 288 data->s_last = data->s_base + newsize - 1; 289 290#if YYDEBUG 291 if (yydebug) 292 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize); 293#endif 294 return 0; 295} 296 297#if YYPURE || defined(YY_NO_LEAKS) 298static void yyfreestack(YYSTACKDATA *data) 299{ 300 free(data->s_base); 301 free(data->l_base); 302#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 303 free(data->p_base); 304#endif 305 memset(data, 0, sizeof(*data)); 306} 307#else 308#define yyfreestack(data) /* nothing */ 309#endif /* YYPURE || defined(YY_NO_LEAKS) */ 310#if YYBTYACC 311 312static YYParseState * 313yyNewState(unsigned size) 314{ 315 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState)); 316 if (p == NULL) return NULL; 317 318 p->yystack.stacksize = size; 319 if (size == 0) 320 { 321 p->yystack.s_base = NULL; 322 p->yystack.l_base = NULL; 323#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 324 p->yystack.p_base = NULL; 325#endif 326 return p; 327 } 328 p->yystack.s_base = (short *) malloc(size * sizeof(short)); 329 if (p->yystack.s_base == NULL) return NULL; 330 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE)); 331 if (p->yystack.l_base == NULL) return NULL; 332 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE)); 333#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 334 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE)); 335 if (p->yystack.p_base == NULL) return NULL; 336 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE)); 337#endif 338 339 return p; 340} 341 342static void 343yyFreeState(YYParseState *p) 344{ 345 yyfreestack(&p->yystack); 346 free(p); 347} 348#endif /* YYBTYACC */ 349 350#define YYABORT goto yyabort 351#define YYREJECT goto yyabort 352#define YYACCEPT goto yyaccept 353#define YYERROR goto yyerrlab 354#if YYBTYACC 355#define YYVALID do { if (yyps->save) goto yyvalid; } while(0) 356#define YYVALID_NESTED do { if (yyps->save && \ 357 yyps->save->save == 0) goto yyvalid; } while(0) 358#endif /* YYBTYACC */ 359 360int 361YYPARSE_DECL() 362{ 363 int yym, yyn, yystate, yyresult; 364#if YYBTYACC 365 int yynewerrflag; 366 YYParseState *yyerrctx = NULL; 367#endif /* YYBTYACC */ 368#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 369 YYLTYPE yyerror_loc_range[2]; /* position of error start & end */ 370#endif 371#if YYDEBUG 372 const char *yys; 373 374 if ((yys = getenv("YYDEBUG")) != 0) 375 { 376 yyn = *yys; 377 if (yyn >= '0' && yyn <= '9') 378 yydebug = yyn - '0'; 379 } 380 if (yydebug) 381 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX); 382#endif 383 384#if YYBTYACC 385 yyps = yyNewState(0); if (yyps == 0) goto yyenomem; 386 yyps->save = 0; 387#endif /* YYBTYACC */ 388 yynerrs = 0; 389 yyerrflag = 0; 390 yychar = YYEMPTY; 391 yystate = 0; 392 393#if YYPURE 394 memset(&yystack, 0, sizeof(yystack)); 395#endif 396 397 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 398 yystack.s_mark = yystack.s_base; 399 yystack.l_mark = yystack.l_base; 400#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 401 yystack.p_mark = yystack.p_base; 402#endif 403 yystate = 0; 404 *yystack.s_mark = 0; 405 406yyloop: 407 if ((yyn = yydefred[yystate]) != 0) goto yyreduce; 408 if (yychar < 0) 409 { 410#if YYBTYACC 411 do { 412 if (yylvp < yylve) 413 { 414 /* we're currently re-reading tokens */ 415 yylval = *yylvp++; 416#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 417 yylloc = *yylpp++; 418#endif 419 yychar = *yylexp++; 420 break; 421 } 422 if (yyps->save) 423 { 424 /* in trial mode; save scanner results for future parse attempts */ 425 if (yylvp == yylvlim) 426 { /* Enlarge lexical value queue */ 427 int p = yylvp - yylvals; 428 int s = yylvlim - yylvals; 429 430 s += YYLVQUEUEGROWTH; 431 if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; 432 if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem; 433#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 434 if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem; 435#endif 436 yylvp = yylve = yylvals + p; 437 yylvlim = yylvals + s; 438#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 439 yylpp = yylpe = yylpsns + p; 440 yylplim = yylpsns + s; 441#endif 442 yylexp = yylexemes + p; 443 } 444 *yylexp = (short) YYLEX; 445 *yylvp++ = yylval; 446 yylve++; 447#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 448 *yylpp++ = yylloc; 449 yylpe++; 450#endif 451 yychar = *yylexp++; 452 break; 453 } 454 /* normal operation, no conflict encountered */ 455#endif /* YYBTYACC */ 456 yychar = YYLEX; 457#if YYBTYACC 458 } while (0); 459#endif /* YYBTYACC */ 460 if (yychar < 0) yychar = YYEOF; 461 /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */ 462#if YYDEBUG 463 if (yydebug) 464 { 465 yys = yyname[YYTRANSLATE(yychar)]; 466 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)", 467 YYDEBUGSTR, yydepth, yystate, yychar, yys); 468#ifdef YYSTYPE_TOSTRING 469#if YYBTYACC 470 if (!yytrial) 471#endif /* YYBTYACC */ 472 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval)); 473#endif 474 fputc('\n', stderr); 475 } 476#endif 477 } 478#if YYBTYACC 479 480 /* Do we have a conflict? */ 481 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 && 482 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 483 { 484 YYINT ctry; 485 486 if (yypath) 487 { 488 YYParseState *save; 489#if YYDEBUG 490 if (yydebug) 491 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n", 492 YYDEBUGSTR, yydepth, yystate); 493#endif 494 /* Switch to the next conflict context */ 495 save = yypath; 496 yypath = save->save; 497 save->save = NULL; 498 ctry = save->ctry; 499 if (save->state != yystate) YYABORT; 500 yyFreeState(save); 501 502 } 503 else 504 { 505 506 /* Unresolved conflict - start/continue trial parse */ 507 YYParseState *save; 508#if YYDEBUG 509 if (yydebug) 510 { 511 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate); 512 if (yyps->save) 513 fputs("ALREADY in conflict, continuing trial parse.\n", stderr); 514 else 515 fputs("Starting trial parse.\n", stderr); 516 } 517#endif 518 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 519 if (save == NULL) goto yyenomem; 520 save->save = yyps->save; 521 save->state = yystate; 522 save->errflag = yyerrflag; 523 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 524 memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 525 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base); 526 memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 527#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 528 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 529 memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 530#endif 531 ctry = yytable[yyn]; 532 if (yyctable[ctry] == -1) 533 { 534#if YYDEBUG 535 if (yydebug && yychar >= YYEOF) 536 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth); 537#endif 538 ctry++; 539 } 540 save->ctry = ctry; 541 if (yyps->save == NULL) 542 { 543 /* If this is a first conflict in the stack, start saving lexemes */ 544 if (!yylexemes) 545 { 546 yylexemes = (short *) malloc((YYLVQUEUEGROWTH) * sizeof(short)); 547 if (yylexemes == NULL) goto yyenomem; 548 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE)); 549 if (yylvals == NULL) goto yyenomem; 550 yylvlim = yylvals + YYLVQUEUEGROWTH; 551#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 552 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE)); 553 if (yylpsns == NULL) goto yyenomem; 554 yylplim = yylpsns + YYLVQUEUEGROWTH; 555#endif 556 } 557 if (yylvp == yylve) 558 { 559 yylvp = yylve = yylvals; 560#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 561 yylpp = yylpe = yylpsns; 562#endif 563 yylexp = yylexemes; 564 if (yychar >= YYEOF) 565 { 566 *yylve++ = yylval; 567#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 568 *yylpe++ = yylloc; 569#endif 570 *yylexp = (short) yychar; 571 yychar = YYEMPTY; 572 } 573 } 574 } 575 if (yychar >= YYEOF) 576 { 577 yylvp--; 578#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 579 yylpp--; 580#endif 581 yylexp--; 582 yychar = YYEMPTY; 583 } 584 save->lexeme = yylvp - yylvals; 585 yyps->save = save; 586 } 587 if (yytable[yyn] == ctry) 588 { 589#if YYDEBUG 590 if (yydebug) 591 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 592 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]); 593#endif 594 if (yychar < 0) 595 { 596 yylvp++; 597#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 598 yylpp++; 599#endif 600 yylexp++; 601 } 602 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) 603 goto yyoverflow; 604 yystate = yyctable[ctry]; 605 *++yystack.s_mark = (short) yystate; 606 *++yystack.l_mark = yylval; 607#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 608 *++yystack.p_mark = yylloc; 609#endif 610 yychar = YYEMPTY; 611 if (yyerrflag > 0) --yyerrflag; 612 goto yyloop; 613 } 614 else 615 { 616 yyn = yyctable[ctry]; 617 goto yyreduce; 618 } 619 } /* End of code dealing with conflicts */ 620#endif /* YYBTYACC */ 621 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 && 622 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 623 { 624#if YYDEBUG 625 if (yydebug) 626 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 627 YYDEBUGSTR, yydepth, yystate, yytable[yyn]); 628#endif 629 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 630 yystate = yytable[yyn]; 631 *++yystack.s_mark = yytable[yyn]; 632 *++yystack.l_mark = yylval; 633#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 634 *++yystack.p_mark = yylloc; 635#endif 636 yychar = YYEMPTY; 637 if (yyerrflag > 0) --yyerrflag; 638 goto yyloop; 639 } 640 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 && 641 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 642 { 643 yyn = yytable[yyn]; 644 goto yyreduce; 645 } 646 if (yyerrflag != 0) goto yyinrecovery; 647#if YYBTYACC 648 649 yynewerrflag = 1; 650 goto yyerrhandler; 651 goto yyerrlab; 652 653yyerrlab: 654 yynewerrflag = 0; 655yyerrhandler: 656 while (yyps->save) 657 { 658 int ctry; 659 YYParseState *save = yyps->save; 660#if YYDEBUG 661 if (yydebug) 662 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n", 663 YYDEBUGSTR, yydepth, yystate, yyps->save->state, 664 (int)(yylvp - yylvals - yyps->save->lexeme)); 665#endif 666 /* Memorize most forward-looking error state in case it's really an error. */ 667 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals) 668 { 669 /* Free old saved error context state */ 670 if (yyerrctx) yyFreeState(yyerrctx); 671 /* Create and fill out new saved error context state */ 672 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 673 if (yyerrctx == NULL) goto yyenomem; 674 yyerrctx->save = yyps->save; 675 yyerrctx->state = yystate; 676 yyerrctx->errflag = yyerrflag; 677 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 678 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 679 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base); 680 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 681#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 682 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 683 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 684#endif 685 yyerrctx->lexeme = yylvp - yylvals; 686 } 687 yylvp = yylvals + save->lexeme; 688#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 689 yylpp = yylpsns + save->lexeme; 690#endif 691 yylexp = yylexemes + save->lexeme; 692 yychar = YYEMPTY; 693 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 694 memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 695 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base); 696 memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 697#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 698 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 699 memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 700#endif 701 ctry = ++save->ctry; 702 yystate = save->state; 703 /* We tried shift, try reduce now */ 704 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce; 705 yyps->save = save->save; 706 save->save = NULL; 707 yyFreeState(save); 708 709 /* Nothing left on the stack -- error */ 710 if (!yyps->save) 711 { 712#if YYDEBUG 713 if (yydebug) 714 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n", 715 YYPREFIX, yydepth); 716#endif 717 /* Restore state as it was in the most forward-advanced error */ 718 yylvp = yylvals + yyerrctx->lexeme; 719#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 720 yylpp = yylpsns + yyerrctx->lexeme; 721#endif 722 yylexp = yylexemes + yyerrctx->lexeme; 723 yychar = yylexp[-1]; 724 yylval = yylvp[-1]; 725#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 726 yylloc = yylpp[-1]; 727#endif 728 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 729 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 730 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base); 731 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 732#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 733 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 734 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 735#endif 736 yystate = yyerrctx->state; 737 yyFreeState(yyerrctx); 738 yyerrctx = NULL; 739 } 740 yynewerrflag = 1; 741 } 742 if (yynewerrflag == 0) goto yyinrecovery; 743#endif /* YYBTYACC */ 744 745 YYERROR_CALL("syntax error"); 746#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 747 yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */ 748#endif 749 750#if !YYBTYACC 751 goto yyerrlab; 752yyerrlab: 753#endif 754 ++yynerrs; 755 756yyinrecovery: 757 if (yyerrflag < 3) 758 { 759 yyerrflag = 3; 760 for (;;) 761 { 762 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 && 763 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE) 764 { 765#if YYDEBUG 766 if (yydebug) 767 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n", 768 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]); 769#endif 770 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 771 yystate = yytable[yyn]; 772 *++yystack.s_mark = yytable[yyn]; 773 *++yystack.l_mark = yylval; 774#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 775 /* lookahead position is error end position */ 776 yyerror_loc_range[1] = yylloc; 777 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */ 778 *++yystack.p_mark = yyloc; 779#endif 780 goto yyloop; 781 } 782 else 783 { 784#if YYDEBUG 785 if (yydebug) 786 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n", 787 YYDEBUGSTR, yydepth, *yystack.s_mark); 788#endif 789 if (yystack.s_mark <= yystack.s_base) goto yyabort; 790#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 791 /* the current TOS position is the error start position */ 792 yyerror_loc_range[0] = *yystack.p_mark; 793#endif 794#if defined(YYDESTRUCT_CALL) 795#if YYBTYACC 796 if (!yytrial) 797#endif /* YYBTYACC */ 798#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 799 YYDESTRUCT_CALL("error: discarding state", 800 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark); 801#else 802 YYDESTRUCT_CALL("error: discarding state", 803 yystos[*yystack.s_mark], yystack.l_mark); 804#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 805#endif /* defined(YYDESTRUCT_CALL) */ 806 --yystack.s_mark; 807 --yystack.l_mark; 808#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 809 --yystack.p_mark; 810#endif 811 } 812 } 813 } 814 else 815 { 816 if (yychar == YYEOF) goto yyabort; 817#if YYDEBUG 818 if (yydebug) 819 { 820 yys = yyname[YYTRANSLATE(yychar)]; 821 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n", 822 YYDEBUGSTR, yydepth, yystate, yychar, yys); 823 } 824#endif 825#if defined(YYDESTRUCT_CALL) 826#if YYBTYACC 827 if (!yytrial) 828#endif /* YYBTYACC */ 829#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 830 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc); 831#else 832 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval); 833#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 834#endif /* defined(YYDESTRUCT_CALL) */ 835 yychar = YYEMPTY; 836 goto yyloop; 837 } 838 839yyreduce: 840 yym = yylen[yyn]; 841#if YYDEBUG 842 if (yydebug) 843 { 844 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)", 845 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]); 846#ifdef YYSTYPE_TOSTRING 847#if YYBTYACC 848 if (!yytrial) 849#endif /* YYBTYACC */ 850 if (yym > 0) 851 { 852 int i; 853 fputc('<', stderr); 854 for (i = yym; i > 0; i--) 855 { 856 if (i != yym) fputs(", ", stderr); 857 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]], 858 yystack.l_mark[1-i]), stderr); 859 } 860 fputc('>', stderr); 861 } 862#endif 863 fputc('\n', stderr); 864 } 865#endif 866 if (yym > 0) 867 yyval = yystack.l_mark[1-yym]; 868 else 869 memset(&yyval, 0, sizeof yyval); 870#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 871 872 /* Perform position reduction */ 873 memset(&yyloc, 0, sizeof(yyloc)); 874#if YYBTYACC 875 if (!yytrial) 876#endif /* YYBTYACC */ 877 { 878 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym); 879 /* just in case YYERROR is invoked within the action, save 880 the start of the rhs as the error start position */ 881 yyerror_loc_range[0] = yystack.p_mark[1-yym]; 882 } 883#endif 884 885 switch (yyn) 886 { 887 default: 888 break; 889 } 890 yystack.s_mark -= yym; 891 yystate = *yystack.s_mark; 892 yystack.l_mark -= yym; 893#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 894 yystack.p_mark -= yym; 895#endif 896 yym = yylhs[yyn]; 897 if (yystate == 0 && yym == 0) 898 { 899#if YYDEBUG 900 if (yydebug) 901 { 902 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 903#ifdef YYSTYPE_TOSTRING 904#if YYBTYACC 905 if (!yytrial) 906#endif /* YYBTYACC */ 907 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval)); 908#endif 909 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL); 910 } 911#endif 912 yystate = YYFINAL; 913 *++yystack.s_mark = YYFINAL; 914 *++yystack.l_mark = yyval; 915#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 916 *++yystack.p_mark = yyloc; 917#endif 918 if (yychar < 0) 919 { 920#if YYBTYACC 921 do { 922 if (yylvp < yylve) 923 { 924 /* we're currently re-reading tokens */ 925 yylval = *yylvp++; 926#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 927 yylloc = *yylpp++; 928#endif 929 yychar = *yylexp++; 930 break; 931 } 932 if (yyps->save) 933 { 934 /* in trial mode; save scanner results for future parse attempts */ 935 if (yylvp == yylvlim) 936 { /* Enlarge lexical value queue */ 937 int p = yylvp - yylvals; 938 int s = yylvlim - yylvals; 939 940 s += YYLVQUEUEGROWTH; 941 if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) 942 goto yyenomem; 943 if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) 944 goto yyenomem; 945#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 946 if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) 947 goto yyenomem; 948#endif 949 yylvp = yylve = yylvals + p; 950 yylvlim = yylvals + s; 951#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 952 yylpp = yylpe = yylpsns + p; 953 yylplim = yylpsns + s; 954#endif 955 yylexp = yylexemes + p; 956 } 957 *yylexp = (short) YYLEX; 958 *yylvp++ = yylval; 959 yylve++; 960#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 961 *yylpp++ = yylloc; 962 yylpe++; 963#endif 964 yychar = *yylexp++; 965 break; 966 } 967 /* normal operation, no conflict encountered */ 968#endif /* YYBTYACC */ 969 yychar = YYLEX; 970#if YYBTYACC 971 } while (0); 972#endif /* YYBTYACC */ 973 if (yychar < 0) yychar = YYEOF; 974 /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */ 975#if YYDEBUG 976 if (yydebug) 977 { 978 yys = yyname[YYTRANSLATE(yychar)]; 979 fprintf(stderr, "%s[%d]: state %d, reading %d (%s)\n", 980 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys); 981 } 982#endif 983 } 984 if (yychar == YYEOF) goto yyaccept; 985 goto yyloop; 986 } 987 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 && 988 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate) 989 yystate = yytable[yyn]; 990 else 991 yystate = yydgoto[yym]; 992#if YYDEBUG 993 if (yydebug) 994 { 995 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 996#ifdef YYSTYPE_TOSTRING 997#if YYBTYACC 998 if (!yytrial) 999#endif /* YYBTYACC */ 1000 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval)); 1001#endif 1002 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate); 1003 } 1004#endif 1005 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1006 *++yystack.s_mark = (short) yystate; 1007 *++yystack.l_mark = yyval; 1008#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1009 *++yystack.p_mark = yyloc; 1010#endif 1011 goto yyloop; 1012#if YYBTYACC 1013 1014 /* Reduction declares that this path is valid. Set yypath and do a full parse */ 1015yyvalid: 1016 if (yypath) YYABORT; 1017 while (yyps->save) 1018 { 1019 YYParseState *save = yyps->save; 1020 yyps->save = save->save; 1021 save->save = yypath; 1022 yypath = save; 1023 } 1024#if YYDEBUG 1025 if (yydebug) 1026 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n", 1027 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme)); 1028#endif 1029 if (yyerrctx) 1030 { 1031 yyFreeState(yyerrctx); 1032 yyerrctx = NULL; 1033 } 1034 yylvp = yylvals + yypath->lexeme; 1035#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1036 yylpp = yylpsns + yypath->lexeme; 1037#endif 1038 yylexp = yylexemes + yypath->lexeme; 1039 yychar = YYEMPTY; 1040 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 1041 memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 1042 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base); 1043 memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1044#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1045 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 1046 memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1047#endif 1048 yystate = yypath->state; 1049 goto yyloop; 1050#endif /* YYBTYACC */ 1051 1052yyoverflow: 1053 YYERROR_CALL("yacc stack overflow"); 1054#if YYBTYACC 1055 goto yyabort_nomem; 1056yyenomem: 1057 YYERROR_CALL("memory exhausted"); 1058yyabort_nomem: 1059#endif /* YYBTYACC */ 1060 yyresult = 2; 1061 goto yyreturn; 1062 1063yyabort: 1064 yyresult = 1; 1065 goto yyreturn; 1066 1067yyaccept: 1068#if YYBTYACC 1069 if (yyps->save) goto yyvalid; 1070#endif /* YYBTYACC */ 1071 yyresult = 0; 1072 1073yyreturn: 1074#if defined(YYDESTRUCT_CALL) 1075 if (yychar != YYEOF && yychar != YYEMPTY) 1076#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1077 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc); 1078#else 1079 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval); 1080#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1081 1082 { 1083 YYSTYPE *pv; 1084#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1085 YYLTYPE *pp; 1086 1087 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp) 1088 YYDESTRUCT_CALL("cleanup: discarding state", 1089 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp); 1090#else 1091 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv) 1092 YYDESTRUCT_CALL("cleanup: discarding state", 1093 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv); 1094#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1095 } 1096#endif /* defined(YYDESTRUCT_CALL) */ 1097 1098#if YYBTYACC 1099 if (yyerrctx) 1100 { 1101 yyFreeState(yyerrctx); 1102 yyerrctx = NULL; 1103 } 1104 while (yyps) 1105 { 1106 YYParseState *save = yyps; 1107 yyps = save->save; 1108 save->save = NULL; 1109 yyFreeState(save); 1110 } 1111 while (yypath) 1112 { 1113 YYParseState *save = yypath; 1114 yypath = save->save; 1115 save->save = NULL; 1116 yyFreeState(save); 1117 } 1118#endif /* YYBTYACC */ 1119 yyfreestack(&yystack); 1120 return (yyresult); 1121} 1122