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