# 2.11BSD#431 - /usr/src/usr.bin/lex/sub2.c

##### Functions

    acompute          X
    add               X
    bprint            X
    cfoll             X
    cgoto             X
    first             X
    follow            X
    layout            X
    member            X
    mkmatch           X
    nextstate         X
    notin             X
    packtrans         X
    padd              X
    pccl              X
    pfoll             X
    pstate            X
    rprint            X
    shiftr            X
    stprt             X
    upone             X

       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

#### Defined functions

acompute defined in line 592; used 1 times

- in line 235

add defined in line 96; used 4 times

- in line 23, 217, 291, 952

bprint defined in line 913; used 2 times

- in line 793-794(2)

cfoll defined in line 6; used 6 times

- in line 25, 56-63(4)
- in /usr/src/usr.bin/lex/lmain.c line 82

cgoto defined in line 198; used 1 times

- in /usr/src/usr.bin/lex/lmain.c line 86

first defined in line 153; used 10 times

- in line 129, 139, 167-172(3), 179-189(4), 216

follow defined in line 113; used 6 times

- in line 18, 130-144(5)

layout defined in line 701; used 1 times

- in /usr/src/usr.bin/lex/lmain.c line 97

member defined in line 547; used 1 times

- in line 329

mkmatch defined in line 688; used 1 times

- in /usr/src/usr.bin/lex/lmain.c line 77

nextstate defined in line 315; used 1 times

- in line 285

notin defined in line 349; used 1 times

- in line 286

packtrans defined in line 368; used 1 times

- in line 307

padd defined in line 932; used 1 times

- in line 20

pccl defined in line 658; used 1 times

- in /usr/src/usr.bin/lex/lmain.c line 79

pfoll defined in line 77; used 1 times

- in /usr/src/usr.bin/lex/lmain.c line 84

pstate defined in line 531; used 2 times

- in line 222, 293

rprint defined in line 883; used 5 times

- in line 787-796(5)

shiftr defined in line 899; used 3 times

- in line 789-795(3)

stprt defined in line 560; used 1 times

- in /usr/src/usr.bin/lex/lmain.c line 90

upone defined in line 906; used 1 times

- in line 791

#### Defined variables

sccsid defined in line 2; never used

Last modified: 1987-02-17 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 2840 |