![[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 [CSRG BSD Unix] / 3BSD / cmd / pi|
Return to yyrecover.c CVS log | Up to [CSRG BSD Unix] / 3BSD / cmd / pi |
1.1 ! root 1: /* Copyright (c) 1979 Regents of the University of California */ ! 2: # ! 3: /* ! 4: * pi - Pascal interpreter code translator ! 5: * ! 6: * Charles Haley, Bill Joy UCB ! 7: * Version 1.1 February 1978 ! 8: * ! 9: * ! 10: * pxp - Pascal execution profiler ! 11: * ! 12: * Bill Joy UCB ! 13: * Version 1.1 February 1978 ! 14: */ ! 15: ! 16: #include "whoami" ! 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: bool 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: pchr('\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" ! 343: , charname(cchar , 0 ) ! 344: , charname(cchar , 1 )); ! 345: #endif ! 346: /* ! 347: * Note that the inserted symbol ! 348: * will not be counted as a true input ! 349: * (i.e. the "yytshifts--" below) ! 350: * so that a true shift will be needed ! 351: * to make yytshifts > yyTshifts. ! 352: */ ! 353: yyTshifts = yytshifts; ! 354: } ! 355: } ! 356: } ! 357: ! 358: /* ! 359: * Set up to perform the correction. ! 360: * Build a token appropriate for replacement ! 361: * or insertion in the yytok structure ACchar ! 362: * having the attributes of the input at the ! 363: * point of error. ! 364: */ ! 365: copy(&ACtok, &YC[0], sizeof ACtok); ! 366: acchar = cchar; ! 367: aclval = nullsem(acchar); ! 368: if (aclval != NIL) ! 369: recovered(); ! 370: switch (cact) { ! 371: /* ! 372: * Panic, just restore the ! 373: * lookahead and return. ! 374: */ ! 375: case CPANIC: ! 376: setpfx('E'); ! 377: if (idfail) { ! 378: copy(&Y, &OY, sizeof Y); ! 379: if (yyrhave == NIL) { ! 380: #ifdef PI ! 381: if (yybaduse(yypv[0], yyeline, ISUNDEF) == NIL) ! 382: #endif ! 383: yerror("Undefined identifier"); ! 384: } else { ! 385: yerror("Improper %s identifier", classes[yyrhave]); ! 386: #ifdef PI ! 387: yybaduse(yypv[0], yyeline, NIL); ! 388: #endif ! 389: } ! 390: /* ! 391: * Suppress message from panic routine ! 392: */ ! 393: yyshifts = 1; ! 394: } ! 395: i = 0; ! 396: /* Note that on one path we dont touch yyshifts ! */ ! 397: break; ! 398: /* ! 399: * Delete the input. ! 400: * Mark this as a shift over true input. ! 401: * Restore the lookahead starting at ! 402: * the second token. ! 403: */ ! 404: case CDELETE: ! 405: if (ccost != 0) ! 406: yerror("Deleted %s%s", tokname(&YC[0] , 0 ) ! 407: , tokname(&YC[0] , 1 )); ! 408: yytshifts++; ! 409: i = 1; ! 410: yyshifts = 0; ! 411: break; ! 412: /* ! 413: * Replace the input with a new token. ! 414: */ ! 415: case CREPLACE: ! 416: if (acchar == YEOF) ! 417: yyexeof(); ! 418: if (acchar == YEND) ! 419: aclval = NIL; ! 420: yerror("Replaced %s%s with a %s%s", ! 421: tokname(&YC[0] , 0 ), ! 422: tokname(&YC[0] , 1 ), ! 423: tokname(&ACtok , 0 ), ! 424: tokname(&ACtok , 1 )); ! 425: copy(&YC[0], &ACtok, sizeof YC[0]); ! 426: i = 0; ! 427: yyshifts = 0; ! 428: break; ! 429: /* ! 430: * Insert a token. ! 431: * Don't count this token as a true input shift. ! 432: * For inserted "end"s pas.y is responsible ! 433: * for the error message later so suppress it. ! 434: * Restore all the lookahead. ! 435: */ ! 436: case CINSERT: ! 437: if (acchar == YEOF) ! 438: yyexeof(); ! 439: if (acchar != YEND) ! 440: yerror("Inserted %s%s", ! 441: tokname(&ACtok , 0 ), ! 442: tokname(&ACtok , 1 )); ! 443: yytshifts--; ! 444: i = 0; ! 445: yyshifts = 0; ! 446: break; ! 447: /* ! 448: * Make a unique symbol correction. ! 449: * Like an insertion but a different message. ! 450: */ ! 451: case CUNIQUE: ! 452: setpfx('E'); ! 453: yerror("Expected %s%s", ! 454: tokname(&ACtok , 0 ), ! 455: tokname(&ACtok , 1 )); ! 456: yytshifts--; ! 457: i = 0; ! 458: if (ccost == 0 || yyunique) ! 459: yyshifts = 0; ! 460: else ! 461: yyshifts = -1; ! 462: break; ! 463: /* ! 464: * Change an identifier's type ! 465: * to make it work. ! 466: */ ! 467: case CCHIDENT: ! 468: copy(&Y, &OY, sizeof Y); ! 469: #ifdef PI ! 470: i = 1 << yyrwant; ! 471: #endif ! 472: if (yyrhave == NIL) { ! 473: yerror("Undefined %s", classes[yyrwant]); ! 474: #ifdef PI ! 475: i =| ISUNDEF; ! 476: #endif ! 477: } else ! 478: yerror("Replaced %s id with a %s id", classes[yyrhave], classes[yyrwant]); ! 479: #ifdef PI ! 480: yybaduse(yypv[0], yyeline, i); ! 481: #endif ! 482: yypv[0] = nullsem(YID); ! 483: i = 0; ! 484: yyshifts = 0; ! 485: break; ! 486: } ! 487: ! 488: /* ! 489: * Restore the desired portion of the lookahead, ! 490: * and possibly the inserted or unique inserted token. ! 491: */ ! 492: for (yCcnt--; yCcnt >= i; yCcnt--) ! 493: unyylex(&YC[yCcnt]); ! 494: if (cact == CINSERT || cact == CUNIQUE) ! 495: unyylex(&ACtok); ! 496: ! 497: /* ! 498: * Put the scanner back in sync. ! 499: */ ! 500: yychar = yylex(); ! 501: ! 502: /* ! 503: * We succeeded if we didn't "panic". ! 504: */ ! 505: Recovery = 0; ! 506: Ps = Ps0; ! 507: return (cact != CPANIC); ! 508: } ! 509: ! 510: yyexeof() ! 511: { ! 512: ! 513: yerror("End-of-file expected - QUIT"); ! 514: pexit(ERRS); ! 515: } ! 516: ! 517: yyunexeof() ! 518: { ! 519: ! 520: yerror("Unexpected end-of-file - QUIT"); ! 521: pexit(ERRS); ! 522: } ! 523: ! 524: /* ! 525: * Try corrections with the state at Ps0. ! 526: * Flag is 0 if this is the top of stack state, ! 527: * 1 if it is the state below. ! 528: */ ! 529: trystate(Ps0, Pv0, flag, insmult, delmult, repmult) ! 530: int *Ps0, *Pv0, flag; ! 531: char *insmult, *delmult, *repmult; ! 532: { ! 533: /* ! 534: * C is a working cost, ap a pointer into the action ! 535: * table for looking at feasible alternatives. ! 536: */ ! 537: register int c, *ap; ! 538: int i, *actions; ! 539: ! 540: #ifdef DEBUG ! 541: Eprintf("Trying state %d\n", *Ps0); ! 542: #endif ! 543: /* ! 544: * Try deletion. ! 545: * Correct returns a cost. ! 546: */ ! 547: #ifdef DEBUG ! 548: Tprintf(" Try Delete %s%s cost=%d\n", ! 549: tokname(&YC[0] , 0 ), ! 550: tokname(&YC[0] , 1 ), ! 551: delcost(YC[0].Yychar)); ! 552: #endif ! 553: c = delcost(YC[0].Yychar); ! 554: #ifndef DEBUG ! 555: if (c < ccost) { ! 556: #endif ! 557: c = correct(NOCHAR, 1, c, delmult, Ps0, Pv0); ! 558: #ifdef DEBUG ! 559: if (c < CPRLIMIT || fulltrace) ! 560: Eprintf("Cost %2d Delete %s%s\n", c, ! 561: tokname(&YC[0] , 0 ), ! 562: tokname(&YC[0] , 1 )); ! 563: #endif ! 564: if (c < ccost) ! 565: cact = CDELETE, ccost = c, cflag = flag; ! 566: #ifndef DEBUG ! 567: } ! 568: #endif ! 569: ! 570: /* ! 571: * Look at the inputs to this state ! 572: * which will cause parse action shift. ! 573: */ ! 574: aclval = NIL; ! 575: ap = &yyact[yypact[*Ps0 + 1]]; ! 576: ! 577: /* ! 578: * Skip action on error to ! 579: * detect true unique inputs. ! 580: * Error action is always first. ! 581: */ ! 582: if (*ap == -ERROR) ! 583: ap=+ 2; ! 584: ! 585: /* ! 586: * Loop through the test actions ! 587: * for this state. ! 588: */ ! 589: for (actions = ap; *ap <= 0; ap =+ 2) { ! 590: /* ! 591: * Extract the token of this action ! 592: */ ! 593: acchar = -*ap; ! 594: ! 595: /* ! 596: * Try insertion ! 597: */ ! 598: #ifdef DEBUG ! 599: Tprintf(" Try Insert %s%s cost=%d\n" ! 600: , charname(acchar , 0 ) ! 601: , charname(acchar , 1 ) ! 602: , inscost(acchar)); ! 603: #endif ! 604: c = inscost(acchar, YC[0].Yychar); ! 605: #ifndef DEBUG ! 606: if (c < ccost) { ! 607: #endif ! 608: if (c == 0) { ! 609: c = correct(acchar, 0, 1, insmult + 1, Ps0, Pv0); ! 610: #ifdef DEBUG ! 611: Eprintf("Cost %2d Freebie %s%s\n", c ! 612: , charname(acchar , 0 ) ! 613: , charname(acchar , 1 )); ! 614: #endif ! 615: if (c < ccost) ! 616: cact = CUNIQUE, ccost = 0, cchar = acchar, cflag = flag; ! 617: } else { ! 618: c = correct(acchar, 0, c, insmult, Ps0, Pv0); ! 619: #ifdef DEBUG ! 620: if (c < CPRLIMIT || fulltrace) ! 621: Eprintf("Cost %2d Insert %s%s\n", c ! 622: , charname(acchar , 0 ) ! 623: , charname(acchar , 1 )); ! 624: #endif ! 625: if (c < ccost) ! 626: cact = CINSERT, ccost = c, cchar = acchar, cflag = flag; ! 627: } ! 628: #ifndef DEBUG ! 629: } ! 630: #endif ! 631: ! 632: /* ! 633: * Try replacement ! 634: */ ! 635: #ifdef DEBUG ! 636: Tprintf(" Try Replace %s%s with %s%s cost=%d\n", ! 637: tokname(&YC[0] , 0 ), ! 638: tokname(&YC[0] , 1 ), ! 639: charname(acchar , 0 ), ! 640: charname(acchar , 1 ), ! 641: repcost(YC[0].Yychar, acchar)); ! 642: #endif ! 643: c = repcost(YC[0].Yychar, acchar); ! 644: #ifndef DEBUG ! 645: if (c < ccost) { ! 646: #endif ! 647: c = correct(acchar, 1, repcost(YC[0].Yychar, acchar), repmult, Ps0, Pv0); ! 648: #ifdef DEBUG ! 649: if (c < CPRLIMIT || fulltrace) ! 650: Eprintf("Cost %2d Replace %s%s with %s%s\n", ! 651: c, ! 652: tokname(&YC[0] , 0 ), ! 653: tokname(&YC[0] , 1 ), ! 654: tokname(&ACtok , 0 ), ! 655: tokname(&ACtok , 1 )); ! 656: #endif ! 657: if (c < ccost) ! 658: cact = CREPLACE, ccost = c, cchar = acchar, cflag = flag; ! 659: #ifndef DEBUG ! 660: } ! 661: #endif ! 662: } ! 663: } ! 664: ! 665: int *yCpv; ! 666: char yyredfail; ! 667: ! 668: /* ! 669: * The ntok structure is used to build a ! 670: * scanner structure for tokens inserted ! 671: * from the argument "fchar" to "correct" below. ! 672: */ ! 673: static struct yytok ntok; ! 674: ! 675: /* ! 676: * Compute the cost of a correction ! 677: * C is the base cost for it. ! 678: * Fchar is the first input character from ! 679: * the current state, NOCHAR if none. ! 680: * The rest of the inputs come from the array ! 681: * YC, starting at origin and continuing to the ! 682: * last character there, YC[yCcnt - 1].Yychar. ! 683: * ! 684: * The cost returned is INFINITE if this correction ! 685: * allows no shifts, otherwise is weighted based ! 686: * on the number of shifts this allows against the ! 687: * maximum number possible with the available lookahead. ! 688: */ ! 689: correct(fchar, origin, c, multvec, Ps0, Pv0) ! 690: register int fchar, c; ! 691: int origin; ! 692: char *multvec; ! 693: int *Ps0, *Pv0; ! 694: { ! 695: register char *mv; ! 696: ! 697: /* ! 698: * Ps is the top of the parse stack after the most ! 699: * recent local correctness check. Loccor returns ! 700: * NIL when we cannot shift. ! 701: */ ! 702: register int *ps; ! 703: ! 704: yyredfail = 0; ! 705: /* ! 706: * Initialize the tip parse and semantic stacks. ! 707: */ ! 708: ps = Ps0; ! 709: yytips[0] = *ps; ! 710: ps--; ! 711: yytipv[0] = Pv0[0]; ! 712: yCpv = Pv0 - 1; ! 713: yytipct = 1; ! 714: ! 715: /* ! 716: * Shift while possible. ! 717: * Adjust cost as necessary. ! 718: */ ! 719: mv = multvec; ! 720: do { ! 721: if (fchar != NOCHAR) { ! 722: copy(&ntok, &YC[0], sizeof ntok); ! 723: ntok.Yychar = fchar, ntok.Yylval = nullsem(fchar); ! 724: fchar = NOCHAR; ! 725: ps = loccor(ps, &ntok); ! 726: } else ! 727: ps = loccor(ps, &YC[origin++]); ! 728: if (ps == NIL) { ! 729: if (yyredfail && mv > multvec) ! 730: mv--; ! 731: c =* *mv; ! 732: break; ! 733: } ! 734: mv++; ! 735: } while (*mv != 1); ! 736: return (c); ! 737: } ! 738: ! 739: extern int yygo[], yypgo[], yyr1[], yyr2[]; ! 740: /* ! 741: * Local syntactic correctness check. ! 742: * The arguments to this routine are a ! 743: * top of stack pointer, ps, and an input ! 744: * token tok. Also, implicitly, the contents ! 745: * of the yytips array which contains the tip ! 746: * of the stack, and into which the new top ! 747: * state on the stack will be placed if we shift. ! 748: * ! 749: * If we succeed, we return a new top of stack ! 750: * pointer, else we return NIL. ! 751: */ ! 752: loccor(ps, ntok) ! 753: int *ps; ! 754: struct yytok *ntok; ! 755: { ! 756: register int *p, n; ! 757: register int nchar; ! 758: int i; ! 759: ! 760: if (ps == NIL) ! 761: return (NIL); ! 762: nchar = ntok->Yychar; ! 763: yyeline = ntok->Yyeline; ! 764: #ifdef DEBUG ! 765: Tprintf(" Stack "); ! 766: for (i = yytipct - 1; i >= 0; i--) ! 767: Tprintf("%d ", yytips[i]); ! 768: Tprintf("| %d, Input %s%s\n", *ps ! 769: , charname(nchar , 0 ) ! 770: , charname(nchar , 1 )); ! 771: #endif ! 772: /* ! 773: * As in the yacc parser yyparse, ! 774: * p traces through the action list ! 775: * and "n" is the information associated ! 776: * with the action. ! 777: */ ! 778: newstate: ! 779: p = &yyact[ yypact[yytips[yytipct - 1]+1] ]; ! 780: ! 781: actn: ! 782: /* ! 783: * Search the parse actions table ! 784: * for something useful to do. ! 785: * While n is non-positive, it is the ! 786: * arithmetic inverse of the token to be tested. ! 787: * This allows a fast check. ! 788: */ ! 789: while ((n = *p++) <= 0) ! 790: if ((n =+ nchar) != 0) ! 791: p++; ! 792: switch (n >> 12) { ! 793: /* ! 794: * SHIFT ! 795: */ ! 796: case 2: ! 797: n =& 07777; ! 798: yyredfail = 0; ! 799: if (nchar == YID) ! 800: yyredfail++; ! 801: if (yytipct == YYTIPSIZ) { ! 802: tipover: ! 803: #ifdef DEBUG ! 804: Tprintf("\tTIP OVFLO\n"); ! 805: #endif ! 806: return (NIL); ! 807: } ! 808: yytips[yytipct] = n; ! 809: yytipv[yytipct] = ntok->Yylval; ! 810: yytipct++; ! 811: #ifdef DEBUG ! 812: Tprintf("\tShift to state %d\n", n); ! 813: #endif ! 814: return (ps); ! 815: /* ! 816: * REDUCE ! 817: */ ! 818: case 3: ! 819: n =& 07777; ! 820: if (yyEactr(n, yytipv[yytipct - 1]) == 0) { ! 821: #ifdef DEBUG ! 822: Tprintf("\tYyEactr objects: have %s id, want %s id\n", classes[yyidhave], classes[yyidwant]); ! 823: #endif ! 824: return (NIL); ! 825: } ! 826: yyredfail = 0; ! 827: i = yyr2[n]; ! 828: #ifdef DEBUG ! 829: Tprintf("\tReduce, length %d,", i); ! 830: #endif ! 831: if (i > yytipct) { ! 832: i =- yytipct; ! 833: yytipct = 0; ! 834: ps =- i; ! 835: yCpv =- i; ! 836: } else ! 837: yytipct =- i; ! 838: if (yytipct >= YYTIPSIZ) ! 839: goto tipover; ! 840: /* ! 841: * Use goto table to find next state ! 842: */ ! 843: p = &yygo[yypgo[yyr1[n]]]; ! 844: i = yytipct ? yytips[yytipct - 1] : *ps; ! 845: while (*p != i && *p >= 0) ! 846: p =+ 2; ! 847: #ifdef DEBUG ! 848: Tprintf(" new state %d\n", p[1]); ! 849: #endif ! 850: yytips[yytipct] = p[1]; ! 851: yytipct++; ! 852: goto newstate; ! 853: /* ! 854: * ACCEPT ! 855: */ ! 856: case 4: ! 857: #ifdef DEBUG ! 858: Tprintf("\tAccept\n"); ! 859: #endif ! 860: return (ps); ! 861: /* ! 862: * ERROR ! 863: */ ! 864: case 1: ! 865: #ifdef DEBUG ! 866: Tprintf("\tError\n"); ! 867: #endif ! 868: return (0); ! 869: } ! 870: panic("loccor"); ! 871: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.