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