![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to yyrecover.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / cmd / pascal / pxp|
Return to yyrecover.c CVS log | Up to [Research Unix] / researchv10dc / cmd / pascal / pxp |
1.1 ! root 1: static char *sccsid = "@(#)yyrecover.c 1.1 (Berkeley) 3/2/81"; ! 2: /* Copyright (c) 1979 Regents of the University of California */ ! 3: # ! 4: /* ! 5: * pi - Pascal interpreter code translator ! 6: * ! 7: * Charles Haley, Bill Joy UCB ! 8: * Version 1.1 February 1978 ! 9: * ! 10: * ! 11: * pxp - Pascal execution profiler ! 12: * ! 13: * Bill Joy UCB ! 14: * Version 1.1 February 1978 ! 15: */ ! 16: ! 17: #include "0.h" ! 18: #include "yy.h" ! 19: ! 20: /* ! 21: * Very simplified version of Graham-Rhodes error recovery ! 22: * method for LALR parsers. Backward move is embodied in ! 23: * default reductions of the yacc parser until an error condition ! 24: * is reached. Forward move is over a small number of input tokens ! 25: * and cannot "condense". The basic corrections are: ! 26: * ! 27: * 1) Delete the input token. ! 28: * ! 29: * 2) Replace the current input with a legal input. ! 30: * ! 31: * 3) Insert a legal token. ! 32: * ! 33: * All corrections are weighted, considered only if they allow ! 34: * at least two shifts, and the cost of a correction increases if ! 35: * it allows shifting over only a part of the lookahead. ! 36: * ! 37: * Another error situation is that which occurs when an identifier "fails" ! 38: * a reduction because it is not the required "class". ! 39: * In this case, we also consider replacing this identifier, which has ! 40: * already been shifted over, with an identifier of the correct class. ! 41: * ! 42: * Another correction performed here is unique symbol insertion. ! 43: * If the current state admits only one input, and no other alternative ! 44: * correction presents itself, then that symbol will be inserted. ! 45: * There is a danger in this of looping, and it is handled ! 46: * by counting true shifts over input (see below). ! 47: * ! 48: * ! 49: * A final class of corrections, considered only when the error ! 50: * occurred immediately after a shift over a terminal, involves ! 51: * the three basic corrections above, but with the point of error ! 52: * considered to be before this terminal was shifted over, effectively ! 53: * "unreading" this terminal. This is a feeble attempt at elimination ! 54: * of the left-right bias and because "if" has a low weight and some ! 55: * statements are quite simple i.e. ! 56: * ! 57: * cse ch of ... ! 58: * ! 59: * we can get a small number of errors. The major deficiency of ! 60: * this is that we back up only one token, and that the forward ! 61: * move is over a small number of tokens, often not enough to really ! 62: * tell what the input should be, e.g. in ! 63: * ! 64: * a[i] > a[i - 1] ... ! 65: * ! 66: * In such cases a bad identifier (misspelled keyword) or omitted ! 67: * keyword will be change or inserted as "if" as it has the lowest cost. ! 68: * This is not terribly bad, as "if"s are most common. ! 69: * This also allows the correction of other errors. ! 70: * ! 71: * This recovery depends on the default reductions which delay ! 72: * noticing the error until the parse reaches a state where the ! 73: * relevant "alternatives" are visible. Note that it does not ! 74: * consider tokens which will cause reductions before being ! 75: * shifted over. This requires the grammar to be written in a ! 76: * certain way for the recovery to work correctly. ! 77: * In some sense, also, the recovery suffers because we have ! 78: * LALR(1) tables rather than LR(1) tables, e.g. in ! 79: * ! 80: * if rec.field < rec2,field2 then ! 81: */ ! 82: ! 83: /* ! 84: * Definitions of possible corrective actions ! 85: */ ! 86: #define CPANIC 0 ! 87: #define CDELETE 1 ! 88: #define CREPLACE 2 ! 89: #define CINSERT 3 ! 90: #define CUNIQUE 4 ! 91: #define CCHIDENT 5 ! 92: ! 93: /* ! 94: * Multiplicative cost factors for corrective actions. ! 95: * ! 96: * When an error occurs we take YCSIZ - 1 look-ahead tokens. ! 97: * If a correction being considered will shift over only part of ! 98: * that look-ahead, it is not completely discarded, but rather ! 99: * "weighted", its cost being multiplied by a weighting factor. ! 100: * For a correction to be considered its weighted cost must be less ! 101: * than CLIMIT. ! 102: * ! 103: * Non-weighted costs are considered: ! 104: * ! 105: * LOW <= 3 ! 106: * MEDIUM 4,5 ! 107: * HIGH >= 6 ! 108: * ! 109: * CURRENT WEIGHTING STRATEGY: Aug 20, 1977 ! 110: * ! 111: * For all kinds of corrections we demand shifts over two symbols. ! 112: * Corrections have high weight even after two symbol ! 113: * shifts because the costs for deleting and inserting symbols are actually ! 114: * quite low; we do not want to change weighty symbols ! 115: * on inconclusive evidence. ! 116: * ! 117: * The weights are the same after the third look ahead. ! 118: * This prevents later, unrelated errors from causing "funny" ! 119: * biases of the weights toward one type of correction. ! 120: * ! 121: * Current look ahead is 5 symbols. ! 122: */ ! 123: ! 124: /*** CLIMIT is defined in yy.h for yycosts ***/ ! 125: #define CPRLIMIT 50 ! 126: #define CCHIDCOST 3 ! 127: ! 128: char insmult[8] = {INFINITY, INFINITY, INFINITY, 15, 8, 6, 3, 1}; ! 129: char repmult[7] = {INFINITY, INFINITY, INFINITY, 8, 6, 3, 1}; ! 130: char delmult[6] = {INFINITY, INFINITY, INFINITY, 6, 3, 1}; ! 131: ! 132: #define NOCHAR -1 ! 133: ! 134: #define Eprintf if (errtrace) printf ! 135: #define Tprintf if (testtrace) printf ! 136: ! 137: /* ! 138: * Action arrays of the parser needed here ! 139: */ ! 140: int yyact[], yypact[], *yypv; ! 141: ! 142: /* ! 143: * Yytips is the tip of the stack when using ! 144: * the function loccor to check for local ! 145: * syntactic correctness. As we don't want ! 146: * to copy the whole parser stack, but want ! 147: * to simulate parser moves, we "split" ! 148: * the parser stack and keep the tip here. ! 149: */ ! 150: #define YYTIPSIZ 16 ! 151: int yytips[YYTIPSIZ], yytipct; ! 152: int yytipv[YYTIPSIZ]; ! 153: ! 154: /* ! 155: * The array YC saves the lookahead tokens for the ! 156: * forward moves. ! 157: * Yccnt is the number of tokens in the YC array. ! 158: */ ! 159: #define YCSIZ 6 ! 160: ! 161: int yCcnt; ! 162: struct yytok YC0[YCSIZ + 1]; ! 163: struct yytok *YC; ! 164: ! 165: /* ! 166: * YCps gives the top of stack at ! 167: * the point of error. ! 168: */ ! 169: ! 170: char yyunique = 1; ! 171: ! 172: STATIC unsigned yyTshifts; ! 173: ! 174: /* ! 175: * Cact is the corrective action we have decided on ! 176: * so far, ccost its cost, and cchar the associated token. ! 177: * Cflag tells if the correction is over the previous input token. ! 178: */ ! 179: int cact, ccost, cchar, cflag; ! 180: ! 181: /* ! 182: * ACtok holds the token under ! 183: * consideration when examining ! 184: * the lookaheads in a state. ! 185: */ ! 186: struct yytok ACtok; ! 187: ! 188: #define acchar ACtok.Yychar ! 189: #define aclval ACtok.Yylval ! 190: ! 191: /* ! 192: * Make a correction to the current stack which has ! 193: * top of stack pointer Ps. ! 194: */ ! 195: yyrecover(Ps0, idfail) ! 196: int *Ps0, idfail; ! 197: { ! 198: register int c, i; ! 199: int yyrwant, yyrhave; ! 200: ! 201: #ifdef PI ! 202: Recovery = 1; ! 203: #endif ! 204: ! 205: YC = &YC0[1]; ! 206: #ifdef DEBUG ! 207: if (errtrace) { ! 208: setpfx('p'); ! 209: yerror("Point of error"); ! 210: printf("States %d %d ...", Ps0[0], Ps0[-1]); ! 211: if (idfail) ! 212: printf(" [Idfail]"); ! 213: putchar('\n'); ! 214: printf("Input %s%s", tokname(&Y , 0) ! 215: , tokname(&Y , 1)); ! 216: } ! 217: ! 218: #endif ! 219: /* ! 220: * We first save the current input token ! 221: * and its associated semantic information. ! 222: */ ! 223: if (yychar < 0) ! 224: yychar = yylex(); ! 225: copy(&YC[0], &Y, sizeof Y); ! 226: ! 227: /* ! 228: * Set the default action and cost ! 229: */ ! 230: cact = CPANIC, ccost = CLIMIT, cflag = 0; ! 231: ! 232: /* ! 233: * Peek ahead ! 234: */ ! 235: for (yCcnt = 1; yCcnt < YCSIZ; yCcnt++) { ! 236: yychar = yylex(); ! 237: copy(&YC[yCcnt], &Y, sizeof YC[0]); ! 238: #ifdef DEBUG ! 239: Eprintf(" | %s%s", tokname(&YC[yCcnt] , 0 ) ! 240: , tokname(&YC[yCcnt] , 1 )); ! 241: #endif ! 242: } ! 243: #ifdef DEBUG ! 244: Eprintf("\n"); ! 245: #endif ! 246: ! 247: /* ! 248: * If we are here because a reduction failed, try ! 249: * correcting that. ! 250: */ ! 251: if (idfail) { ! 252: /* ! 253: * Save the particulars about ! 254: * the kind of identifier we want/have. ! 255: */ ! 256: yyrwant = yyidwant; ! 257: yyrhave = yyidhave; ! 258: #ifdef DEBUG ! 259: Tprintf(" Try Replace %s identifier with %s identifier cost=%d\n", ! 260: classes[yyidhave], classes[yyidwant], CCHIDCOST); ! 261: #endif ! 262: ! 263: /* ! 264: * Save the semantics of the ID on the ! 265: * stack, and null them out to free ! 266: * up the reduction in question. ! 267: */ ! 268: i = yypv[0]; ! 269: yypv[0] = nullsem(YID); ! 270: c = correct(NOCHAR, 0, CCHIDCOST, &repmult[2], Ps0, yypv); ! 271: yypv[0] = i; ! 272: #ifdef DEBUG ! 273: if (c < CPRLIMIT || fulltrace) ! 274: Eprintf("Cost %2d Replace %s identifier with %s identifier\n", c, classes[yyrhave], classes[yyrwant]); ! 275: #endif ! 276: if (c < ccost) ! 277: cact = CCHIDENT, ccost = c, cchar = YID; ! 278: } ! 279: ! 280: /* ! 281: * First try correcting the state we are in ! 282: */ ! 283: trystate(Ps0, yypv, 0, &insmult[1], &delmult[1], &repmult[1]); ! 284: ! 285: /* ! 286: * Now, if we just shifted over a terminal, try ! 287: * correcting it. ! 288: */ ! 289: if (OY.Yychar != -1 && OY.Yylval != nullsem(OY.Yychar)) { ! 290: YC--; ! 291: copy(&YC[0], &OY, sizeof YC[0]); ! 292: trystate(Ps0 - 1, yypv - 1, 1, insmult, delmult, repmult); ! 293: if (cflag == 0) ! 294: YC++; ! 295: else { ! 296: yypv--; ! 297: #ifdef PXP ! 298: yypw--; ! 299: #endif ! 300: Ps0--; ! 301: yCcnt++; ! 302: } ! 303: } ! 304: ! 305: /* ! 306: * Restoring the first look ahead into ! 307: * the scanner token allows the error message ! 308: * routine to print the error message with the text ! 309: * of the correct line. ! 310: */ ! 311: copy(&Y, &YC[0], sizeof Y); ! 312: ! 313: /* ! 314: * Unique symbol insertion. ! 315: * ! 316: * If there was no reasonable correction found, ! 317: * but only one input to the parser is acceptable ! 318: * we report that, and try it. ! 319: * ! 320: * Special precautions here to prevent looping. ! 321: * The number of true inputs shifted over at the point ! 322: * of the last unique insertion is recorded in the ! 323: * variable yyTshifts. If this is not less than ! 324: * the current number in yytshifts, we do not insert. ! 325: * Thus, after one unique insertion, no more unique ! 326: * insertions will be made until an input is shifted ! 327: * over. This guarantees termination. ! 328: */ ! 329: if (cact == CPANIC && !idfail) { ! 330: register int *ap; ! 331: ! 332: ap = &yyact[yypact[*Ps0 + 1]]; ! 333: if (*ap == -ERROR) ! 334: ap += 2; ! 335: if (ap[0] <= 0 && ap[2] > 0) { ! 336: cchar = -ap[0]; ! 337: if (cchar == YEOF) ! 338: yyexeof(); ! 339: if (cchar != ERROR && yyTshifts < yytshifts) { ! 340: cact = CUNIQUE; ! 341: #ifdef DEBUG ! 342: Eprintf("Unique symbol %s%s\n", charname(cchar)); ! 343: #endif ! 344: /* ! 345: * Note that the inserted symbol ! 346: * will not be counted as a true input ! 347: * (i.e. the "yytshifts--" below) ! 348: * so that a true shift will be needed ! 349: * to make yytshifts > yyTshifts. ! 350: */ ! 351: yyTshifts = yytshifts; ! 352: } ! 353: } ! 354: } ! 355: ! 356: /* ! 357: * Set up to perform the correction. ! 358: * Build a token appropriate for replacement ! 359: * or insertion in the yytok structure ACchar ! 360: * having the attributes of the input at the ! 361: * point of error. ! 362: */ ! 363: copy(&ACtok, &YC[0], sizeof ACtok); ! 364: acchar = cchar; ! 365: aclval = nullsem(acchar); ! 366: if (aclval != NIL) ! 367: recovered(); ! 368: switch (cact) { ! 369: /* ! 370: * Panic, just restore the ! 371: * lookahead and return. ! 372: */ ! 373: case CPANIC: ! 374: setpfx('E'); ! 375: if (idfail) { ! 376: copy(&Y, &OY, sizeof Y); ! 377: if (yyrhave == NIL) { ! 378: #ifdef PI ! 379: if (yybaduse(yypv[0], yyeline, ISUNDEF) == NIL) ! 380: #endif ! 381: yerror("Undefined identifier"); ! 382: } else { ! 383: yerror("Improper %s identifier", classes[yyrhave]); ! 384: #ifdef PI ! 385: yybaduse(yypv[0], yyeline, NIL); ! 386: #endif ! 387: } ! 388: /* ! 389: * Suppress message from panic routine ! 390: */ ! 391: yyshifts = 1; ! 392: } ! 393: i = 0; ! 394: /* Note that on one path we dont touch yyshifts ! */ ! 395: break; ! 396: /* ! 397: * Delete the input. ! 398: * Mark this as a shift over true input. ! 399: * Restore the lookahead starting at ! 400: * the second token. ! 401: */ ! 402: case CDELETE: ! 403: if (ccost != 0) ! 404: yerror("Deleted %s%s", tokname(&YC[0] , 0 ) ! 405: , tokname(&YC[0] , 1 )); ! 406: yytshifts++; ! 407: i = 1; ! 408: yyshifts = 0; ! 409: break; ! 410: /* ! 411: * Replace the input with a new token. ! 412: */ ! 413: case CREPLACE: ! 414: if (acchar == YEOF) ! 415: yyexeof(); ! 416: if (acchar == YEND) ! 417: aclval = NIL; ! 418: yerror("Replaced %s%s with a %s%s", ! 419: tokname(&YC[0] , 0 ), ! 420: tokname(&YC[0] , 1 ), ! 421: tokname(&ACtok , 0 ), ! 422: tokname(&ACtok , 1 )); ! 423: copy(&YC[0], &ACtok, sizeof YC[0]); ! 424: i = 0; ! 425: yyshifts = 0; ! 426: break; ! 427: /* ! 428: * Insert a token. ! 429: * Don't count this token as a true input shift. ! 430: * For inserted "end"s pas.y is responsible ! 431: * for the error message later so suppress it. ! 432: * Restore all the lookahead. ! 433: */ ! 434: case CINSERT: ! 435: if (acchar == YEOF) ! 436: yyexeof(); ! 437: if (acchar != YEND) ! 438: yerror("Inserted %s%s", ! 439: tokname(&ACtok , 0 ), ! 440: tokname(&ACtok , 1 )); ! 441: yytshifts--; ! 442: i = 0; ! 443: yyshifts = 0; ! 444: break; ! 445: /* ! 446: * Make a unique symbol correction. ! 447: * Like an insertion but a different message. ! 448: */ ! 449: case CUNIQUE: ! 450: setpfx('E'); ! 451: yerror("Expected %s%s", ! 452: tokname(&ACtok , 0 ), ! 453: tokname(&ACtok , 1 )); ! 454: yytshifts--; ! 455: i = 0; ! 456: if (ccost == 0 || yyunique) ! 457: yyshifts = 0; ! 458: else ! 459: yyshifts = -1; ! 460: break; ! 461: /* ! 462: * Change an identifier's type ! 463: * to make it work. ! 464: */ ! 465: case CCHIDENT: ! 466: copy(&Y, &OY, sizeof Y); ! 467: #ifdef PI ! 468: i = 1 << yyrwant; ! 469: #endif ! 470: if (yyrhave == NIL) { ! 471: yerror("Undefined %s", classes[yyrwant]); ! 472: #ifdef PI ! 473: i |= ISUNDEF; ! 474: #endif ! 475: } else ! 476: yerror("Replaced %s id with a %s id", classes[yyrhave], classes[yyrwant]); ! 477: #ifdef PI ! 478: yybaduse(yypv[0], yyeline, i); ! 479: #endif ! 480: yypv[0] = nullsem(YID); ! 481: i = 0; ! 482: yyshifts = 0; ! 483: break; ! 484: } ! 485: ! 486: /* ! 487: * Restore the desired portion of the lookahead, ! 488: * and possibly the inserted or unique inserted token. ! 489: */ ! 490: for (yCcnt--; yCcnt >= i; yCcnt--) ! 491: unyylex(&YC[yCcnt]); ! 492: if (cact == CINSERT || cact == CUNIQUE) ! 493: unyylex(&ACtok); ! 494: ! 495: /* ! 496: * Put the scanner back in sync. ! 497: */ ! 498: yychar = yylex(); ! 499: ! 500: /* ! 501: * We succeeded if we didn't "panic". ! 502: */ ! 503: Recovery = 0; ! 504: Ps = Ps0; ! 505: return (cact != CPANIC); ! 506: } ! 507: ! 508: yyexeof() ! 509: { ! 510: ! 511: yerror("End-of-file expected - QUIT"); ! 512: pexit(ERRS); ! 513: } ! 514: ! 515: yyunexeof() ! 516: { ! 517: ! 518: yerror("Unexpected end-of-file - QUIT"); ! 519: pexit(ERRS); ! 520: } ! 521: ! 522: /* ! 523: * Try corrections with the state at Ps0. ! 524: * Flag is 0 if this is the top of stack state, ! 525: * 1 if it is the state below. ! 526: */ ! 527: trystate(Ps0, Pv0, flag, insmult, delmult, repmult) ! 528: int *Ps0, *Pv0, flag; ! 529: char *insmult, *delmult, *repmult; ! 530: { ! 531: /* ! 532: * C is a working cost, ap a pointer into the action ! 533: * table for looking at feasible alternatives. ! 534: */ ! 535: register int c, *ap; ! 536: int i, *actions; ! 537: ! 538: #ifdef DEBUG ! 539: Eprintf("Trying state %d\n", *Ps0); ! 540: #endif ! 541: /* ! 542: * Try deletion. ! 543: * Correct returns a cost. ! 544: */ ! 545: #ifdef DEBUG ! 546: Tprintf(" Try Delete %s%s cost=%d\n", ! 547: tokname(&YC[0] , 0 ), ! 548: tokname(&YC[0] , 1 ), ! 549: delcost(YC[0].Yychar)); ! 550: #endif ! 551: c = delcost(YC[0].Yychar); ! 552: #ifndef DEBUG ! 553: if (c < ccost) { ! 554: #endif ! 555: c = correct(NOCHAR, 1, c, delmult, Ps0, Pv0); ! 556: #ifdef DEBUG ! 557: if (c < CPRLIMIT || fulltrace) ! 558: Eprintf("Cost %2d Delete %s%s\n", c, ! 559: tokname(&YC[0] , 0 ), ! 560: tokname(&YC[0] , 1 )); ! 561: #endif ! 562: if (c < ccost) ! 563: cact = CDELETE, ccost = c, cflag = flag; ! 564: #ifndef DEBUG ! 565: } ! 566: #endif ! 567: ! 568: /* ! 569: * Look at the inputs to this state ! 570: * which will cause parse action shift. ! 571: */ ! 572: aclval = NIL; ! 573: ap = &yyact[yypact[*Ps0 + 1]]; ! 574: ! 575: /* ! 576: * Skip action on error to ! 577: * detect true unique inputs. ! 578: * Error action is always first. ! 579: */ ! 580: if (*ap == -ERROR) ! 581: ap+= 2; ! 582: ! 583: /* ! 584: * Loop through the test actions ! 585: * for this state. ! 586: */ ! 587: for (actions = ap; *ap <= 0; ap += 2) { ! 588: /* ! 589: * Extract the token of this action ! 590: */ ! 591: acchar = -*ap; ! 592: ! 593: /* ! 594: * Try insertion ! 595: */ ! 596: #ifdef DEBUG ! 597: Tprintf(" Try Insert %s%s cost=%d\n", charname(acchar), inscost(acchar)); ! 598: #endif ! 599: c = inscost(acchar, YC[0].Yychar); ! 600: #ifndef DEBUG ! 601: if (c < ccost) { ! 602: #endif ! 603: if (c == 0) { ! 604: c = correct(acchar, 0, 1, insmult + 1, Ps0, Pv0); ! 605: #ifdef DEBUG ! 606: Eprintf("Cost %2d Freebie %s%s\n", c, charname(acchar)); ! 607: #endif ! 608: if (c < ccost) ! 609: cact = CUNIQUE, ccost = 0, cchar = acchar, cflag = flag; ! 610: } else { ! 611: c = correct(acchar, 0, c, insmult, Ps0, Pv0); ! 612: #ifdef DEBUG ! 613: if (c < CPRLIMIT || fulltrace) ! 614: Eprintf("Cost %2d Insert %s%s\n", c, charname(acchar)); ! 615: #endif ! 616: if (c < ccost) ! 617: cact = CINSERT, ccost = c, cchar = acchar, cflag = flag; ! 618: } ! 619: #ifndef DEBUG ! 620: } ! 621: #endif ! 622: ! 623: /* ! 624: * Try replacement ! 625: */ ! 626: #ifdef DEBUG ! 627: Tprintf`* Try Replace %s%s with %s%s cost=%d\n", ! 628: tokname(&YC[0] , 0 ), ! 629: tokname(&YC[0] , 1 ), ! 630: charname(acchar , 0 ), ! 631: charname(acchar , 1 ), ! 632: repcost(YC[0].Yychar, acchar)); ! 633: #endif ! 634: c = repcost(YC[0].Yychar, acchar); ! 635: #ifndef DEBUG ! 636: if (c < ccost) { ! 637: #endif ! 638: c = correct(acchar, 1, repcost(YC[0].Yychar, acchar), repmult, Ps0, Pv0); ! 639: #ifdef DEBUG ! 640: if (c < CPRLIMIT || fulltrace) ! 641: Eprintf("Cost %2d Replace %s%s with %s%s\n", ! 642: c, ! 643: tokname(&YC[0] , 0 ), ! 644: tokname(&YC[0] , 1 ), ! 645: tokname(&ACtok , 0 ), ! 646: tokname(&ACtok , 1 )); ! 647: #endif ! 648: if (c < ccost) ! 649: cact = CREPLACE, ccost = c, cchar = acchar, cflag = flag; ! 650: #ifndef DEBUG ! 651: } ! 652: #endif ! 653: } ! 654: } ! 655: ! 656: int *yCpv; ! 657: char yyredfail; ! 658: ! 659: /* ! 660: * The ntok structure is used to build a ! 661: * scanner structure for tokens inserted ! 662: * from the argument "fchar" to "correct" below. ! 663: */ ! 664: static struct yytok ntok; ! 665: ! 666: /* ! 667: * Compute the cost of a correction ! 668: * C is the base cost for it. ! 669: * Fchar is the first input character from ! 670: * the current state, NOCHAR if none. ! 671: * The rest of the inputs come from the array ! 672: * YC, starting at origin and continuing to the ! 673: * last character there, YC[yCcnt - 1].Yychar. ! 674: * ! 675: * The cost returned is INFINITE if this correction ! 676: * allows no shifts, otherwise is weighted based ! 677: * on the number of shifts this allows against the ! 678: * maximum number possible with the available lookahead. ! 679: */ ! 680: correct(fchar, origin, c, multvec, Ps0, Pv0) ! 681: register int fchar, c; ! 682: int origin; ! 683: char *multvec; ! 684: int *Ps0, *Pv0; ! 685: { ! 686: register char *mv; ! 687: ! 688: /* ! 689: * Ps is the top of the parse stack after the most ! 690: * recent local correctness check. Loccor returns ! 691: * NIL when we cannot shift. ! 692: */ ! 693: register int *ps; ! 694: ! 695: yyredfail = 0; ! 696: /* ! 697: * Initialize the tip parse and semantic stacks. ! 698: */ ! 699: ps = Ps0; ! 700: yytips[0] = *ps; ! 701: ps--; ! 702: yytipv[0] = Pv0[0]; ! 703: yCpv = Pv0 - 1; ! 704: yytipct = 1; ! 705: ! 706: /* ! 707: * Shift while possible. ! 708: * Adjust cost as necessary. ! 709: */ ! 710: mv = multvec; ! 711: do { ! 712: if (fchar != NOCHAR) { ! 713: copy(&ntok, &YC[0], sizeof ntok); ! 714: ntok.Yychar = fchar, ntok.Yylval = nullsem(fchar); ! 715: fchar = NOCHAR; ! 716: ps = loccor(ps, &ntok); ! 717: } else ! 718: ps = loccor(ps, &YC[origin++]); ! 719: if (ps == NIL) { ! 720: if (yyredfail && mv > multvec) ! 721: mv--; ! 722: c *= *mv; ! 723: break; ! 724: } ! 725: mv++; ! 726: } while (*mv != 1); ! 727: return (c); ! 728: } ! 729: ! 730: extern int yygo[], yypgo[], yyr1[], yyr2[]; ! 731: /* ! 732: * Local syntactic correctness check. ! 733: * The arguments to this routine are a ! 734: * top of stack pointer, ps, and an input ! 735: * token tok. Also, implicitly, the contents ! 736: * of the yytips array which contains the tip ! 737: * of the stack, and into which the new top ! 738: * state on the stack will be placed if we shift. ! 739: * ! 740: * If we succeed, we return a new top of stack ! 741: * pointer, else we return NIL. ! 742: */ ! 743: loccor(ps, ntok) ! 744: int *ps; ! 745: struct yytok *ntok; ! 746: { ! 747: register int *p, n; ! 748: register int nchar; ! 749: int i; ! 750: ! 751: if (ps == NIL) ! 752: return (NIL); ! 753: nchar = ntok->Yychar; ! 754: yyeline = ntok->Yyeline; ! 755: #ifdef DEBUG ! 756: Tprintf(" Stack "); ! 757: for (i = yytipct - 1; i >= 0; i--) ! 758: Tprintf("%d ", yytips[i]); ! 759: Tprintf("| %d, Input %s%s\n", *ps, charname(nchar)); ! 760: #endif ! 761: /* ! 762: * As in the yacc parser yyparse, ! 763: * p traces through the action list ! 764: * and "n" is the information associated ! 765: * with the action. ! 766: */ ! 767: newstate: ! 768: p = &yyact[ yypact[yytips[yytipct - 1]+1] ]; ! 769: ! 770: actn: ! 771: /* ! 772: * Search the parse actions table ! 773: * for something useful to do. ! 774: * While n is non-positive, it is the ! 775: * arithmetic inverse of the token to be tested. ! 776: * This allows a fast check. ! 777: */ ! 778: while ((n = *p++) <= 0) ! 779: if ((n += nchar) != 0) ! 780: p++; ! 781: switch (n >> 12) { ! 782: /* ! 783: * SHIFT ! 784: */ ! 785: case 2: ! 786: n &= 07777; ! 787: yyredfail = 0; ! 788: if (nchar == YID) ! 789: yyredfail++; ! 790: if (yytipct == YYTIPSIZ) { ! 791: tipover: ! 792: #ifdef DEBUG ! 793: Tprintf("\tTIP OVFLO\n"); ! 794: #endif ! 795: return (NIL); ! 796: } ! 797: yytips[yytipct] = n; ! 798: yytipv[yytipct] = ntok->Yylval; ! 799: yytipct++; ! 800: #ifdef DEBUG ! 801: Tprintf("\tShift to state %d\n", n); ! 802: #endif ! 803: return (ps); ! 804: /* ! 805: * REDUCE ! 806: */ ! 807: case 3: ! 808: n &= 07777; ! 809: if (yyEactr(n, yytipv[yytipct - 1]) == 0) { ! 810: #ifdef DEBUG ! 811: Tprintf("\tYyEactr objects: have %s id, want %s id\n", classes[yyidhave], classes[yyidwant]); ! 812: #endif ! 813: return (NIL); ! 814: } ! 815: yyredfail = 0; ! 816: i = yyr2[n]; ! 817: #ifdef DEBUG ! 818: Tprintf("\tReduce, length %d,", i); ! 819: #endif ! 820: if (i > yytipct) { ! 821: i -= yytipct; ! 822: yytipct = 0; ! 823: ps -= i; ! 824: yCpv -= i; ! 825: } else ! 826: yytipct -= i; ! 827: if (yytipct >= YYTIPSIZ) ! 828: goto tipover; ! 829: /* ! 830: * Use goto table to find next state ! 831: */ ! 832: p = &yygo[yypgo[yyr1[n]]]; ! 833: i = yytipct ? yytips[yytipct - 1] : *ps; ! 834: while (*p != i && *p >= 0) ! 835: p += 2; ! 836: #ifdef DEBUG ! 837: Tprintf(" new state %d\n", p[1]); ! 838: #endif ! 839: yytips[yytipct] = p[1]; ! 840: yytipct++; ! 841: goto newstate; ! 842: /* ! 843: * ACCEPT ! 844: */ ! 845: case 4: ! 846: #ifdef DEBUG ! 847: Tprintf("\tAccept\n"); ! 848: #endif ! 849: return (ps); ! 850: /* ! 851: * ERROR ! 852: */ ! 853: case 1: ! 854: #ifdef DEBUG ! 855: Tprintf("\tError\n"); ! 856: #endif ! 857: return (0); ! 858: } ! 859: panic("loccor"); ! 860: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.