![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sub2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / usr.bin / lex|
Return to sub2.c CVS log | Up to [CSRG BSD Unix] / 43BSD / usr.bin / lex |
1.1 ! root 1: #ifndef lint ! 2: static char sccsid[] = "@(#)sub2.c 4.1 (Berkeley) 8/11/83"; ! 3: #endif ! 4: ! 5: # include "ldefs.c" ! 6: cfoll(v) ! 7: int v; ! 8: { ! 9: register int i,j,k; ! 10: char *p; ! 11: i = name[v]; ! 12: if(i < NCH) i = 1; /* character */ ! 13: switch(i){ ! 14: case 1: case RSTR: case RCCL: case RNCCL: case RNULLS: ! 15: for(j=0;j<tptr;j++) ! 16: tmpstat[j] = FALSE; ! 17: count = 0; ! 18: follow(v); ! 19: # ifdef PP ! 20: padd(foll,v); /* packing version */ ! 21: # endif ! 22: # ifndef PP ! 23: add(foll,v); /* no packing version */ ! 24: # endif ! 25: if(i == RSTR) cfoll(left[v]); ! 26: else if(i == RCCL || i == RNCCL){ /* compress ccl list */ ! 27: for(j=1; j<NCH;j++) ! 28: symbol[j] = (i==RNCCL); ! 29: p = left[v]; ! 30: while(*p) ! 31: symbol[*p++] = (i == RCCL); ! 32: p = pcptr; ! 33: for(j=1;j<NCH;j++) ! 34: if(symbol[j]){ ! 35: for(k=0;p+k < pcptr; k++) ! 36: if(cindex[j] == *(p+k)) ! 37: break; ! 38: if(p+k >= pcptr)*pcptr++ = cindex[j]; ! 39: } ! 40: *pcptr++ = 0; ! 41: if(pcptr > pchar + pchlen) ! 42: error("Too many packed character classes"); ! 43: left[v] = p; ! 44: name[v] = RCCL; /* RNCCL eliminated */ ! 45: # ifdef DEBUG ! 46: if(debug && *p){ ! 47: printf("ccl %d: %d",v,*p++); ! 48: while(*p) ! 49: printf(", %d",*p++); ! 50: putchar('\n'); ! 51: } ! 52: # endif ! 53: } ! 54: break; ! 55: case CARAT: ! 56: cfoll(left[v]); ! 57: break; ! 58: case STAR: case PLUS: case QUEST: case RSCON: ! 59: cfoll(left[v]); ! 60: break; ! 61: case BAR: case RCAT: case DIV: case RNEWE: ! 62: cfoll(left[v]); ! 63: cfoll(right[v]); ! 64: break; ! 65: # ifdef DEBUG ! 66: case FINAL: ! 67: case S1FINAL: ! 68: case S2FINAL: ! 69: break; ! 70: default: ! 71: warning("bad switch cfoll %d",v); ! 72: # endif ! 73: } ! 74: return; ! 75: } ! 76: # ifdef DEBUG ! 77: pfoll() ! 78: { ! 79: register int i,k,*p; ! 80: int j; ! 81: /* print sets of chars which may follow positions */ ! 82: printf("pos\tchars\n"); ! 83: for(i=0;i<tptr;i++) ! 84: if(p=foll[i]){ ! 85: j = *p++; ! 86: if(j >= 1){ ! 87: printf("%d:\t%d",i,*p++); ! 88: for(k=2;k<=j;k++) ! 89: printf(", %d",*p++); ! 90: putchar('\n'); ! 91: } ! 92: } ! 93: return; ! 94: } ! 95: # endif ! 96: add(array,n) ! 97: int **array; ! 98: int n; { ! 99: register int i, *temp; ! 100: register char *ctemp; ! 101: temp = nxtpos; ! 102: ctemp = tmpstat; ! 103: array[n] = nxtpos; /* note no packing is done in positions */ ! 104: *temp++ = count; ! 105: for(i=0;i<tptr;i++) ! 106: if(ctemp[i] == TRUE) ! 107: *temp++ = i; ! 108: nxtpos = temp; ! 109: if(nxtpos >= positions+maxpos) ! 110: error("Too many positions %s",(maxpos== MAXPOS?"\nTry using %p num":"")); ! 111: return; ! 112: } ! 113: follow(v) ! 114: int v; ! 115: { ! 116: register int p; ! 117: if(v >= tptr-1)return; ! 118: p = parent[v]; ! 119: if(p == 0) return; ! 120: switch(name[p]){ ! 121: /* will not be CHAR RNULLS FINAL S1FINAL S2FINAL RCCL RNCCL */ ! 122: case RSTR: ! 123: if(tmpstat[p] == FALSE){ ! 124: count++; ! 125: tmpstat[p] = TRUE; ! 126: } ! 127: break; ! 128: case STAR: case PLUS: ! 129: first(v); ! 130: follow(p); ! 131: break; ! 132: case BAR: case QUEST: case RNEWE: ! 133: follow(p); ! 134: break; ! 135: case RCAT: case DIV: ! 136: if(v == left[p]){ ! 137: if(nullstr[right[p]]) ! 138: follow(p); ! 139: first(right[p]); ! 140: } ! 141: else follow(p); ! 142: break; ! 143: case RSCON: case CARAT: ! 144: follow(p); ! 145: break; ! 146: # ifdef DEBUG ! 147: default: ! 148: warning("bad switch follow %d",p); ! 149: # endif ! 150: } ! 151: return; ! 152: } ! 153: first(v) /* calculate set of positions with v as root which can be active initially */ ! 154: int v; { ! 155: register int i; ! 156: register char *p; ! 157: i = name[v]; ! 158: if(i < NCH)i = 1; ! 159: switch(i){ ! 160: case 1: case RCCL: case RNCCL: case RNULLS: case FINAL: case S1FINAL: case S2FINAL: ! 161: if(tmpstat[v] == FALSE){ ! 162: count++; ! 163: tmpstat[v] = TRUE; ! 164: } ! 165: break; ! 166: case BAR: case RNEWE: ! 167: first(left[v]); ! 168: first(right[v]); ! 169: break; ! 170: case CARAT: ! 171: if(stnum % 2 == 1) ! 172: first(left[v]); ! 173: break; ! 174: case RSCON: ! 175: i = stnum/2 +1; ! 176: p = right[v]; ! 177: while(*p) ! 178: if(*p++ == i){ ! 179: first(left[v]); ! 180: break; ! 181: } ! 182: break; ! 183: case STAR: case QUEST: case PLUS: case RSTR: ! 184: first(left[v]); ! 185: break; ! 186: case RCAT: case DIV: ! 187: first(left[v]); ! 188: if(nullstr[left[v]]) ! 189: first(right[v]); ! 190: break; ! 191: # ifdef DEBUG ! 192: default: ! 193: warning("bad switch first %d",v); ! 194: # endif ! 195: } ! 196: return; ! 197: } ! 198: cgoto(){ ! 199: register int i, j, s; ! 200: int npos, curpos, n; ! 201: int tryit; ! 202: char tch[NCH]; ! 203: int tst[NCH]; ! 204: char *q; ! 205: /* generate initial state, for each start condition */ ! 206: if(ratfor){ ! 207: fprintf(fout,"blockdata\n"); ! 208: fprintf(fout,"common /Lvstop/ vstop\n"); ! 209: fprintf(fout,"define Svstop %d\n",nstates+1); ! 210: fprintf(fout,"integer vstop(Svstop)\n"); ! 211: } ! 212: else fprintf(fout,"int yyvstop[] ={\n0,\n"); ! 213: while(stnum < 2 || stnum/2 < sptr){ ! 214: for(i = 0; i<tptr; i++) tmpstat[i] = 0; ! 215: count = 0; ! 216: if(tptr > 0)first(tptr-1); ! 217: add(state,stnum); ! 218: # ifdef DEBUG ! 219: if(debug){ ! 220: if(stnum > 1) ! 221: printf("%s:\n",sname[stnum/2]); ! 222: pstate(stnum); ! 223: } ! 224: # endif ! 225: stnum++; ! 226: } ! 227: stnum--; ! 228: /* even stnum = might not be at line begin */ ! 229: /* odd stnum = must be at line begin */ ! 230: /* even states can occur anywhere, odd states only at line begin */ ! 231: for(s = 0; s <= stnum; s++){ ! 232: tryit = FALSE; ! 233: cpackflg[s] = FALSE; ! 234: sfall[s] = -1; ! 235: acompute(s); ! 236: for(i=0;i<NCH;i++) symbol[i] = 0; ! 237: npos = *state[s]; ! 238: for(i = 1; i<=npos; i++){ ! 239: curpos = *(state[s]+i); ! 240: if(name[curpos] < NCH) symbol[name[curpos]] = TRUE; ! 241: else switch(name[curpos]){ ! 242: case RCCL: ! 243: tryit = TRUE; ! 244: q = left[curpos]; ! 245: while(*q){ ! 246: for(j=1;j<NCH;j++) ! 247: if(cindex[j] == *q) ! 248: symbol[j] = TRUE; ! 249: q++; ! 250: } ! 251: break; ! 252: case RSTR: ! 253: symbol[right[curpos]] = TRUE; ! 254: break; ! 255: # ifdef DEBUG ! 256: case RNULLS: ! 257: case FINAL: ! 258: case S1FINAL: ! 259: case S2FINAL: ! 260: break; ! 261: default: ! 262: warning("bad switch cgoto %d state %d",curpos,s); ! 263: break; ! 264: # endif ! 265: } ! 266: } ! 267: # ifdef DEBUG ! 268: if(debug){ ! 269: printf("State %d transitions on:\n\t",s); ! 270: charc = 0; ! 271: for(i = 1; i<NCH; i++){ ! 272: if(symbol[i]) allprint(i); ! 273: if(charc > LINESIZE){ ! 274: charc = 0; ! 275: printf("\n\t"); ! 276: } ! 277: } ! 278: putchar('\n'); ! 279: } ! 280: # endif ! 281: /* for each char, calculate next state */ ! 282: n = 0; ! 283: for(i = 1; i<NCH; i++){ ! 284: if(symbol[i]){ ! 285: nextstate(s,i); /* executed for each state, transition pair */ ! 286: xstate = notin(stnum); ! 287: if(xstate == -2) warning("bad state %d %o",s,i); ! 288: else if(xstate == -1){ ! 289: if(stnum >= nstates) ! 290: error("Too many states %s",(nstates == NSTATES ? "\nTry using %n num":"")); ! 291: add(state,++stnum); ! 292: # ifdef DEBUG ! 293: if(debug)pstate(stnum); ! 294: # endif ! 295: tch[n] = i; ! 296: tst[n++] = stnum; ! 297: } ! 298: else { /* xstate >= 0 ==> state exists */ ! 299: tch[n] = i; ! 300: tst[n++] = xstate; ! 301: } ! 302: } ! 303: } ! 304: tch[n] = 0; ! 305: tst[n] = -1; ! 306: /* pack transitions into permanent array */ ! 307: if(n > 0) packtrans(s,tch,tst,n,tryit); ! 308: else gotof[s] = -1; ! 309: } ! 310: ratfor ? fprintf(fout,"end\n") : fprintf(fout,"0};\n"); ! 311: return; ! 312: } ! 313: /* Beware -- 70% of total CPU time is spent in this subroutine - ! 314: if you don't believe me - try it yourself ! */ ! 315: nextstate(s,c) ! 316: int s,c; { ! 317: register int j, *newpos; ! 318: register char *temp, *tz; ! 319: int *pos, i, *f, num, curpos, number; ! 320: /* state to goto from state s on char c */ ! 321: num = *state[s]; ! 322: temp = tmpstat; ! 323: pos = state[s] + 1; ! 324: for(i = 0; i<num; i++){ ! 325: curpos = *pos++; ! 326: j = name[curpos]; ! 327: if(j < NCH && j == c ! 328: || j == RSTR && c == right[curpos] ! 329: || j == RCCL && member(c,left[curpos])){ ! 330: f = foll[curpos]; ! 331: number = *f; ! 332: newpos = f+1; ! 333: for(j=0;j<number;j++) ! 334: temp[*newpos++] = 2; ! 335: } ! 336: } ! 337: j = 0; ! 338: tz = temp + tptr; ! 339: while(temp < tz){ ! 340: if(*temp == 2){ ! 341: j++; ! 342: *temp++ = 1; ! 343: } ! 344: else *temp++ = 0; ! 345: } ! 346: count = j; ! 347: return; ! 348: } ! 349: notin(n) ! 350: int n; { /* see if tmpstat occurs previously */ ! 351: register int *j,k; ! 352: register char *temp; ! 353: int i; ! 354: if(count == 0) ! 355: return(-2); ! 356: temp = tmpstat; ! 357: for(i=n;i>=0;i--){ /* for each state */ ! 358: j = state[i]; ! 359: if(count == *j++){ ! 360: for(k=0;k<count;k++) ! 361: if(!temp[*j++])break; ! 362: if(k >= count) ! 363: return(i); ! 364: } ! 365: } ! 366: return(-1); ! 367: } ! 368: packtrans(st,tch,tst,cnt,tryit) ! 369: int st, *tst, cnt,tryit; ! 370: char *tch; { ! 371: /* pack transitions into nchar, nexts */ ! 372: /* nchar is terminated by '\0', nexts uses cnt, followed by elements */ ! 373: /* gotof[st] = index into nchr, nexts for state st */ ! 374: ! 375: /* sfall[st] = t implies t is fall back state for st */ ! 376: /* == -1 implies no fall back */ ! 377: ! 378: int cmin, cval, tcnt, diff, p, *ast; ! 379: register int i,j,k; ! 380: char *ach; ! 381: int go[NCH], temp[NCH], c; ! 382: int swork[NCH]; ! 383: char cwork[NCH]; ! 384: int upper; ! 385: ! 386: rcount += cnt; ! 387: cmin = -1; ! 388: cval = NCH; ! 389: ast = tst; ! 390: ach = tch; ! 391: /* try to pack transitions using ccl's */ ! 392: if(!optim)goto nopack; /* skip all compaction */ ! 393: if(tryit){ /* ccl's used */ ! 394: for(i=1;i<NCH;i++){ ! 395: go[i] = temp[i] = -1; ! 396: symbol[i] = 1; ! 397: } ! 398: for(i=0;i<cnt;i++){ ! 399: go[tch[i]] = tst[i]; ! 400: symbol[tch[i]] = 0; ! 401: } ! 402: for(i=0; i<cnt;i++){ ! 403: c = match[tch[i]]; ! 404: if(go[c] != tst[i] || c == tch[i]) ! 405: temp[tch[i]] = tst[i]; ! 406: } ! 407: /* fill in error entries */ ! 408: for(i=1;i<NCH;i++) ! 409: if(symbol[i]) temp[i] = -2; /* error trans */ ! 410: /* count them */ ! 411: k = 0; ! 412: for(i=1;i<NCH;i++) ! 413: if(temp[i] != -1)k++; ! 414: if(k <cnt){ /* compress by char */ ! 415: # ifdef DEBUG ! 416: if(debug) printf("use compression %d, %d vs %d\n",st,k,cnt); ! 417: # endif ! 418: k = 0; ! 419: for(i=1;i<NCH;i++) ! 420: if(temp[i] != -1){ ! 421: cwork[k] = i; ! 422: swork[k++] = (temp[i] == -2 ? -1 : temp[i]); ! 423: } ! 424: cwork[k] = 0; ! 425: # ifdef PC ! 426: ach = cwork; ! 427: ast = swork; ! 428: cnt = k; ! 429: cpackflg[st] = TRUE; ! 430: # endif ! 431: } ! 432: } ! 433: for(i=0; i<st; i++){ /* get most similar state */ ! 434: /* reject state with more transitions, state already represented by a third state, ! 435: and state which is compressed by char if ours is not to be */ ! 436: if(sfall[i] != -1) continue; ! 437: if(cpackflg[st] == 1) if(!(cpackflg[i] == 1)) continue; ! 438: p = gotof[i]; ! 439: if(p == -1) /* no transitions */ continue; ! 440: tcnt = nexts[p]; ! 441: if(tcnt > cnt) continue; ! 442: diff = 0; ! 443: k = 0; ! 444: j = 0; ! 445: upper = p + tcnt; ! 446: while(ach[j] && p < upper){ ! 447: while(ach[j] < nchar[p] && ach[j]){diff++; j++; } ! 448: if(ach[j] == 0)break; ! 449: if(ach[j] > nchar[p]){diff=NCH;break;} ! 450: /* ach[j] == nchar[p] */ ! 451: if(ast[j] != nexts[++p] || ast[j] == -1 || (cpackflg[st] && ach[j] != match[ach[j]]))diff++; ! 452: j++; ! 453: } ! 454: while(ach[j]){ ! 455: diff++; ! 456: j++; ! 457: } ! 458: if(p < upper)diff = NCH; ! 459: if(diff < cval && diff < tcnt){ ! 460: cval = diff; ! 461: cmin = i; ! 462: if(cval == 0)break; ! 463: } ! 464: } ! 465: /* cmin = state "most like" state st */ ! 466: # ifdef DEBUG ! 467: if(debug)printf("select st %d for st %d diff %d\n",cmin,st,cval); ! 468: # endif ! 469: # ifdef PS ! 470: if(cmin != -1){ /* if we can use st cmin */ ! 471: gotof[st] = nptr; ! 472: k = 0; ! 473: sfall[st] = cmin; ! 474: p = gotof[cmin]+1; ! 475: j = 0; ! 476: while(ach[j]){ ! 477: /* if cmin has a transition on c, then so will st */ ! 478: /* st may be "larger" than cmin, however */ ! 479: while(ach[j] < nchar[p-1] && ach[j]){ ! 480: k++; ! 481: nchar[nptr] = ach[j]; ! 482: nexts[++nptr] = ast[j]; ! 483: j++; ! 484: } ! 485: if(nchar[p-1] == 0)break; ! 486: if(ach[j] > nchar[p-1]){ ! 487: warning("bad transition %d %d",st,cmin); ! 488: goto nopack; ! 489: } ! 490: /* ach[j] == nchar[p-1] */ ! 491: if(ast[j] != nexts[p] || ast[j] == -1 || (cpackflg[st] && ach[j] != match[ach[j]])){ ! 492: k++; ! 493: nchar[nptr] = ach[j]; ! 494: nexts[++nptr] = ast[j]; ! 495: } ! 496: p++; ! 497: j++; ! 498: } ! 499: while(ach[j]){ ! 500: nchar[nptr] = ach[j]; ! 501: nexts[++nptr] = ast[j++]; ! 502: k++; ! 503: } ! 504: nexts[gotof[st]] = cnt = k; ! 505: nchar[nptr++] = 0; ! 506: } ! 507: else { ! 508: # endif ! 509: nopack: ! 510: /* stick it in */ ! 511: gotof[st] = nptr; ! 512: nexts[nptr] = cnt; ! 513: for(i=0;i<cnt;i++){ ! 514: nchar[nptr] = ach[i]; ! 515: nexts[++nptr] = ast[i]; ! 516: } ! 517: nchar[nptr++] = 0; ! 518: # ifdef PS ! 519: } ! 520: # endif ! 521: if(cnt < 1){ ! 522: gotof[st] = -1; ! 523: nptr--; ! 524: } ! 525: else ! 526: if(nptr > ntrans) ! 527: error("Too many transitions %s",(ntrans==NTRANS?"\nTry using %a num":"")); ! 528: return; ! 529: } ! 530: # ifdef DEBUG ! 531: pstate(s) ! 532: int s; { ! 533: register int *p,i,j; ! 534: printf("State %d:\n",s); ! 535: p = state[s]; ! 536: i = *p++; ! 537: if(i == 0) return; ! 538: printf("%4d",*p++); ! 539: for(j = 1; j<i; j++){ ! 540: printf(", %4d",*p++); ! 541: if(j%30 == 0)putchar('\n'); ! 542: } ! 543: putchar('\n'); ! 544: return; ! 545: } ! 546: # endif ! 547: member(d,t) ! 548: int d; ! 549: char *t; { ! 550: register int c; ! 551: register char *s; ! 552: c = d; ! 553: s = t; ! 554: c = cindex[c]; ! 555: while(*s) ! 556: if(*s++ == c) return(1); ! 557: return(0); ! 558: } ! 559: # ifdef DEBUG ! 560: stprt(i) ! 561: int i; { ! 562: register int p, t; ! 563: printf("State %d:",i); ! 564: /* print actions, if any */ ! 565: t = atable[i]; ! 566: if(t != -1)printf(" final"); ! 567: putchar('\n'); ! 568: if(cpackflg[i] == TRUE)printf("backup char in use\n"); ! 569: if(sfall[i] != -1)printf("fall back state %d\n",sfall[i]); ! 570: p = gotof[i]; ! 571: if(p == -1) return; ! 572: printf("(%d transitions)\n",nexts[p]); ! 573: while(nchar[p]){ ! 574: charc = 0; ! 575: if(nexts[p+1] >= 0) ! 576: printf("%d\t",nexts[p+1]); ! 577: else printf("err\t"); ! 578: allprint(nchar[p++]); ! 579: while(nexts[p] == nexts[p+1] && nchar[p]){ ! 580: if(charc > LINESIZE){ ! 581: charc = 0; ! 582: printf("\n\t"); ! 583: } ! 584: allprint(nchar[p++]); ! 585: } ! 586: putchar('\n'); ! 587: } ! 588: putchar('\n'); ! 589: return; ! 590: } ! 591: # endif ! 592: acompute(s) /* compute action list = set of poss. actions */ ! 593: int s; { ! 594: register int *p, i, j; ! 595: int cnt, m; ! 596: int temp[300], k, neg[300], n; ! 597: k = 0; ! 598: n = 0; ! 599: p = state[s]; ! 600: cnt = *p++; ! 601: if(cnt > 300) ! 602: error("Too many positions for one state - acompute"); ! 603: for(i=0;i<cnt;i++){ ! 604: if(name[*p] == FINAL)temp[k++] = left[*p]; ! 605: else if(name[*p] == S1FINAL){temp[k++] = left[*p]; ! 606: if (left[*p] >NACTIONS) error("Too many right contexts"); ! 607: extra[left[*p]] = 1; ! 608: } ! 609: else if(name[*p] == S2FINAL)neg[n++] = left[*p]; ! 610: p++; ! 611: } ! 612: atable[s] = -1; ! 613: if(k < 1 && n < 1) return; ! 614: # ifdef DEBUG ! 615: if(debug) printf("final %d actions:",s); ! 616: # endif ! 617: /* sort action list */ ! 618: for(i=0; i<k; i++) ! 619: for(j=i+1;j<k;j++) ! 620: if(temp[j] < temp[i]){ ! 621: m = temp[j]; ! 622: temp[j] = temp[i]; ! 623: temp[i] = m; ! 624: } ! 625: /* remove dups */ ! 626: for(i=0;i<k-1;i++) ! 627: if(temp[i] == temp[i+1]) temp[i] = 0; ! 628: /* copy to permanent quarters */ ! 629: atable[s] = aptr; ! 630: # ifdef DEBUG ! 631: if(!ratfor)fprintf(fout,"/* actions for state %d */",s); ! 632: # endif ! 633: putc('\n',fout); ! 634: for(i=0;i<k;i++) ! 635: if(temp[i] != 0){ ! 636: ratfor ? fprintf(fout,"data vstop(%d)/%d/\n",aptr,temp[i]) : fprintf(fout,"%d,\n",temp[i]); ! 637: # ifdef DEBUG ! 638: if(debug) ! 639: printf("%d ",temp[i]); ! 640: # endif ! 641: aptr++; ! 642: } ! 643: for(i=0;i<n;i++){ /* copy fall back actions - all neg */ ! 644: ratfor ? fprintf(fout,"data vstop(%d)/%d/\n",aptr,neg[i]) : fprintf(fout,"%d,\n",neg[i]); ! 645: aptr++; ! 646: # ifdef DEBUG ! 647: if(debug)printf("%d ",neg[i]); ! 648: # endif ! 649: } ! 650: # ifdef DEBUG ! 651: if(debug)putchar('\n'); ! 652: # endif ! 653: ratfor ? fprintf(fout,"data vstop (%d)/0/\n",aptr) : fprintf(fout,"0,\n"); ! 654: aptr++; ! 655: return; ! 656: } ! 657: # ifdef DEBUG ! 658: pccl() { ! 659: /* print character class sets */ ! 660: register int i, j; ! 661: printf("char class intersection\n"); ! 662: for(i=0; i< ccount; i++){ ! 663: charc = 0; ! 664: printf("class %d:\n\t",i); ! 665: for(j=1;j<NCH;j++) ! 666: if(cindex[j] == i){ ! 667: allprint(j); ! 668: if(charc > LINESIZE){ ! 669: printf("\n\t"); ! 670: charc = 0; ! 671: } ! 672: } ! 673: putchar('\n'); ! 674: } ! 675: charc = 0; ! 676: printf("match:\n"); ! 677: for(i=0;i<NCH;i++){ ! 678: allprint(match[i]); ! 679: if(charc > LINESIZE){ ! 680: putchar('\n'); ! 681: charc = 0; ! 682: } ! 683: } ! 684: putchar('\n'); ! 685: return; ! 686: } ! 687: # endif ! 688: mkmatch(){ ! 689: register int i; ! 690: char tab[NCH]; ! 691: for(i=0; i<ccount; i++) ! 692: tab[i] = 0; ! 693: for(i=1;i<NCH;i++) ! 694: if(tab[cindex[i]] == 0) ! 695: tab[cindex[i]] = i; ! 696: /* tab[i] = principal char for new ccl i */ ! 697: for(i = 1; i<NCH; i++) ! 698: match[i] = tab[cindex[i]]; ! 699: return; ! 700: } ! 701: layout(){ ! 702: /* format and output final program's tables */ ! 703: register int i, j, k; ! 704: int top, bot, startup, omin; ! 705: startup = 0; ! 706: for(i=0; i<outsize;i++) ! 707: verify[i] = advance[i] = 0; ! 708: omin = 0; ! 709: yytop = 0; ! 710: for(i=0; i<= stnum; i++){ /* for each state */ ! 711: j = gotof[i]; ! 712: if(j == -1){ ! 713: stoff[i] = 0; ! 714: continue; ! 715: } ! 716: bot = j; ! 717: while(nchar[j])j++; ! 718: top = j - 1; ! 719: # if DEBUG ! 720: if (debug) ! 721: { ! 722: printf("State %d: (layout)\n", i); ! 723: for(j=bot; j<=top;j++) ! 724: { ! 725: printf(" %o", nchar[j]); ! 726: if (j%10==0) putchar('\n'); ! 727: } ! 728: putchar('\n'); ! 729: } ! 730: # endif ! 731: while(verify[omin+ZCH]) omin++; ! 732: startup = omin; ! 733: # if DEBUG ! 734: if (debug) printf("bot,top %d, %d startup begins %d\n",bot,top,startup); ! 735: # endif ! 736: if(chset){ ! 737: do { ! 738: ++startup; ! 739: if(startup > outsize - ZCH) ! 740: error("output table overflow"); ! 741: for(j = bot; j<= top; j++){ ! 742: k=startup+ctable[nchar[j]]; ! 743: if(verify[k])break; ! 744: } ! 745: } while (j <= top); ! 746: # if DEBUG ! 747: if (debug) printf(" startup will be %d\n",startup); ! 748: # endif ! 749: /* have found place */ ! 750: for(j = bot; j<= top; j++){ ! 751: k = startup + ctable[nchar[j]]; ! 752: if (ctable[nchar[j]]<=0) ! 753: printf("j %d nchar %d ctable.nch %d\n",j,nchar[j],ctable[nchar[k]]); ! 754: verify[k] = i+1; /* state number + 1*/ ! 755: advance[k] = nexts[j+1]+1; /* state number + 1*/ ! 756: if(yytop < k) yytop = k; ! 757: } ! 758: } ! 759: else { ! 760: do { ! 761: ++startup; ! 762: if(startup > outsize - ZCH) ! 763: error("output table overflow"); ! 764: for(j = bot; j<= top; j++){ ! 765: k = startup + nchar[j]; ! 766: if(verify[k])break; ! 767: } ! 768: } while (j <= top); ! 769: /* have found place */ ! 770: # if DEBUG ! 771: if (debug) printf(" startup going to be %d\n", startup); ! 772: # endif ! 773: for(j = bot; j<= top; j++){ ! 774: k = startup + nchar[j]; ! 775: verify[k] = i+1; /* state number + 1*/ ! 776: advance[k] = nexts[j+1]+1; /* state number + 1*/ ! 777: if(yytop < k) yytop = k; ! 778: } ! 779: } ! 780: stoff[i] = startup; ! 781: } ! 782: ! 783: /* stoff[i] = offset into verify, advance for trans for state i */ ! 784: /* put out yywork */ ! 785: if(ratfor){ ! 786: fprintf(fout, "define YYTOPVAL %d\n", yytop); ! 787: rprint(verify,"verif",yytop+1); ! 788: rprint(advance,"advan",yytop+1); ! 789: shiftr(stoff, stnum); ! 790: rprint(stoff,"stoff",stnum+1); ! 791: shiftr(sfall, stnum); upone(sfall, stnum+1); ! 792: rprint(sfall,"sfall",stnum+1); ! 793: bprint(extra,"extra",casecount+1); ! 794: bprint(match,"match",NCH); ! 795: shiftr(atable, stnum); ! 796: rprint(atable,"atable",stnum+1); ! 797: return; ! 798: } ! 799: fprintf(fout,"# define YYTYPE %s\n",stnum+1 > NCH ? "int" : "char"); ! 800: fprintf(fout,"struct yywork { YYTYPE verify, advance; } yycrank[] ={\n"); ! 801: for(i=0;i<=yytop;i+=4){ ! 802: for(j=0;j<4;j++){ ! 803: k = i+j; ! 804: if(verify[k]) ! 805: fprintf(fout,"%d,%d,\t",verify[k],advance[k]); ! 806: else ! 807: fprintf(fout,"0,0,\t"); ! 808: } ! 809: putc('\n',fout); ! 810: } ! 811: fprintf(fout,"0,0};\n"); ! 812: ! 813: /* put out yysvec */ ! 814: ! 815: fprintf(fout,"struct yysvf yysvec[] ={\n"); ! 816: fprintf(fout,"0,\t0,\t0,\n"); ! 817: for(i=0;i<=stnum;i++){ /* for each state */ ! 818: if(cpackflg[i])stoff[i] = -stoff[i]; ! 819: fprintf(fout,"yycrank+%d,\t",stoff[i]); ! 820: if(sfall[i] != -1) ! 821: fprintf(fout,"yysvec+%d,\t", sfall[i]+1); /* state + 1 */ ! 822: else fprintf(fout,"0,\t\t"); ! 823: if(atable[i] != -1) ! 824: fprintf(fout,"yyvstop+%d,",atable[i]); ! 825: else fprintf(fout,"0,\t"); ! 826: # ifdef DEBUG ! 827: fprintf(fout,"\t\t/* state %d */",i); ! 828: # endif ! 829: putc('\n',fout); ! 830: } ! 831: fprintf(fout,"0,\t0,\t0};\n"); ! 832: ! 833: /* put out yymatch */ ! 834: ! 835: fprintf(fout,"struct yywork *yytop = yycrank+%d;\n",yytop); ! 836: fprintf(fout,"struct yysvf *yybgin = yysvec+1;\n"); ! 837: if(optim){ ! 838: fprintf(fout,"char yymatch[] ={\n"); ! 839: if (chset==0) /* no chset, put out in normal order */ ! 840: { ! 841: for(i=0; i<NCH; i+=8){ ! 842: for(j=0; j<8; j++){ ! 843: int fbch; ! 844: fbch = match[i+j]; ! 845: if(printable(fbch) && fbch != '\'' && fbch != '\\') ! 846: fprintf(fout,"'%c' ,",fbch); ! 847: else fprintf(fout,"0%-3o,",fbch); ! 848: } ! 849: putc('\n',fout); ! 850: } ! 851: } ! 852: else ! 853: { ! 854: int *fbarr; ! 855: fbarr = myalloc(2*NCH, sizeof(*fbarr)); ! 856: if (fbarr==0) ! 857: error("No space for char table reverse",0); ! 858: for(i=0; i<ZCH; i++) ! 859: fbarr[i]=0; ! 860: for(i=0; i<NCH; i++) ! 861: fbarr[ctable[i]] = ctable[match[i]]; ! 862: for(i=0; i<ZCH; i+=8) ! 863: { ! 864: for(j=0; j<8; j++) ! 865: fprintf(fout, "0%-3o,",fbarr[i+j]); ! 866: putc('\n',fout); ! 867: } ! 868: cfree(fbarr, 2*NCH, 1); ! 869: } ! 870: fprintf(fout,"0};\n"); ! 871: } ! 872: /* put out yyextra */ ! 873: fprintf(fout,"char yyextra[] ={\n"); ! 874: for(i=0;i<casecount;i+=8){ ! 875: for(j=0;j<8;j++) ! 876: fprintf(fout, "%d,", i+j<NACTIONS ? ! 877: extra[i+j] : 0); ! 878: putc('\n',fout); ! 879: } ! 880: fprintf(fout,"0};\n"); ! 881: return; ! 882: } ! 883: rprint(a,s,n) ! 884: char *s; ! 885: int *a, n; { ! 886: register int i; ! 887: fprintf(fout,"block data\n"); ! 888: fprintf(fout,"common /L%s/ %s\n",s,s); ! 889: fprintf(fout,"define S%s %d\n",s,n); ! 890: fprintf(fout,"integer %s (S%s)\n",s,s); ! 891: for(i=1; i<=n; i++) ! 892: { ! 893: if (i%8==1) fprintf(fout, "data "); ! 894: fprintf(fout, "%s (%d)/%d/",s,i,a[i]); ! 895: fprintf(fout, (i%8 && i<n) ? ", " : "\n"); ! 896: } ! 897: fprintf(fout,"end\n"); ! 898: } ! 899: shiftr(a, n) ! 900: int *a; ! 901: { ! 902: int i; ! 903: for(i=n; i>=0; i--) ! 904: a[i+1]=a[i]; ! 905: } ! 906: upone(a,n) ! 907: int *a; ! 908: { ! 909: int i; ! 910: for(i=0; i<=n ; i++) ! 911: a[i]++; ! 912: } ! 913: bprint(a,s,n) ! 914: char *s, *a; ! 915: int n; { ! 916: register int i, j, k; ! 917: fprintf(fout,"block data\n"); ! 918: fprintf(fout,"common /L%s/ %s\n",s,s); ! 919: fprintf(fout,"define S%s %d\n",s,n); ! 920: fprintf(fout,"integer %s (S%s)\n",s,s); ! 921: for(i=1;i<n;i+=8){ ! 922: fprintf(fout,"data %s (%d)/%d/",s,i,a[i]); ! 923: for(j=1;j<8;j++){ ! 924: k = i+j; ! 925: if(k < n)fprintf(fout,", %s (%d)/%d/",s,k,a[k]); ! 926: } ! 927: putc('\n',fout); ! 928: } ! 929: fprintf(fout,"end\n"); ! 930: } ! 931: # ifdef PP ! 932: padd(array,n) ! 933: int **array; ! 934: int n; { ! 935: register int i, *j, k; ! 936: array[n] = nxtpos; ! 937: if(count == 0){ ! 938: *nxtpos++ = 0; ! 939: return; ! 940: } ! 941: for(i=tptr-1;i>=0;i--){ ! 942: j = array[i]; ! 943: if(j && *j++ == count){ ! 944: for(k=0;k<count;k++) ! 945: if(!tmpstat[*j++])break; ! 946: if(k >= count){ ! 947: array[n] = array[i]; ! 948: return; ! 949: } ! 950: } ! 951: } ! 952: add(array,n); ! 953: return; ! 954: } ! 955: # endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.