2.9BSD - /usr/src/cmd/yacc/y1.c

   1: # include "dextern"
   2: 
   3:     /* variables used locally */
   4: 
   5:     /* lookahead computations */
   6: 
   7: int tbitset;  /* size of lookahead sets */
   8: struct looksets lkst [ LSETSIZE ];
   9: int nlset = 0; /* next lookahead set index */
  10: int nolook = 0; /* flag to suppress lookahead computations */
  11: struct looksets clset;  /* temporary storage for lookahead computations */
  12: 
  13:     /* working set computations */
  14: 
  15: struct wset wsets[ WSETSIZE ];
  16: struct wset *cwp;
  17: 
  18:     /* state information */
  19: 
  20: int nstate = 0;     /* number of states */
  21: struct item *pstate[NSTATES+2]; /* pointers to the descriptions of the states */
  22: int tystate[NSTATES];   /* contains type information about the states */
  23: int indgo[NSTATES];     /* index to the stored goto table */
  24: int tstates[ NTERMS ]; /* states generated by terminal gotos */
  25: int ntstates[ NNONTERM ]; /* states generated by nonterminal gotos */
  26: int mstates[ NSTATES ]; /* chain of overflows of term/nonterm generation lists  */
  27: 
  28:     /* storage for the actions in the parser */
  29: 
  30: int amem[ACTSIZE];  /* action table storage */
  31: int *memp = amem;   /* next free action table position */
  32: 
  33:     /* other storage areas */
  34: 
  35: int temp1[TEMPSIZE]; /* temporary storage, indexed by terms + ntokens or states */
  36: int lineno= 1; /* current input line number */
  37: int fatfl = 1;      /* if on, error is fatal */
  38: int nerrors = 0;    /* number of errors */
  39: 
  40:     /* storage for information about the nonterminals */
  41: 
  42: int **pres[NNONTERM+2];  /* vector of pointers to productions yielding each nonterminal */
  43: struct looksets *pfirst[NNONTERM+2];  /* vector of pointers to first sets for each nonterminal */
  44: int pempty[NNONTERM+1];  /* vector of nonterminals nontrivially deriving e */
  45: 
  46: main(argc,argv) int argc; char *argv[]; {
  47: 
  48:     setup(argc,argv); /* initialize and read productions */
  49:     tbitset = NWORDS(ntokens);
  50:     cpres(); /* make table of which productions yield a given nonterminal */
  51:     cempty(); /* make a table of which nonterminals can match the empty string */
  52:     cpfir(); /* make a table of firsts of nonterminals */
  53:     stagen(); /* generate the states */
  54:     output();  /* write the states and the tables */
  55:     go2out();
  56:     hideprod();
  57:     summary();
  58:     callopt();
  59:     others();
  60:     exit(0);
  61:     }
  62: 
  63: others(){ /* put out other arrays, copy the parsers */
  64:     register c, i, j;
  65: 
  66:     finput = fopen( PARSER, "r" );
  67:     if( finput == NULL ) error( "cannot find parser %s", PARSER );
  68: 
  69:     warray( "yyr1", levprd, nprod );
  70: 
  71:     aryfil( temp1, nprod, 0 );
  72:     PLOOP(1,i)temp1[i] = prdptr[i+1]-prdptr[i]-2;
  73:     warray( "yyr2", temp1, nprod );
  74: 
  75:     aryfil( temp1, nstate, -1000 );
  76:     TLOOP(i){
  77:         for( j=tstates[i]; j!=0; j=mstates[j] ){
  78:             temp1[j] = tokset[i].value;
  79:             }
  80:         }
  81:     NTLOOP(i){
  82:         for( j=ntstates[i]; j!=0; j=mstates[j] ){
  83:             temp1[j] = -i;
  84:             }
  85:         }
  86:     warray( "yychk", temp1, nstate );
  87: 
  88:     warray( "yydef", defact, nstate );
  89: 
  90:     /* copy parser text */
  91: 
  92:     while( (c=getc(finput) ) != EOF ){
  93:         if( c == '$' ){
  94:             if( (c=getc(finput)) != 'A' ) putc( '$', ftable );
  95:             else { /* copy actions */
  96:                 faction = fopen( ACTNAME, "r" );
  97:                 if( faction == NULL ) error( "cannot reopen action tempfile" );
  98:                 while( (c=getc(faction) ) != EOF ) putc( c, ftable );
  99:                 fclose(faction);
 100:                 ZAPFILE(ACTNAME);
 101:                 c = getc(finput);
 102:                 }
 103:             }
 104:         putc( c, ftable );
 105:         }
 106: 
 107:     fclose( ftable );
 108:     }
 109: 
 110: char *chcopy( p, q )  char *p, *q; {
 111:     /* copies string q into p, returning next free char ptr */
 112:     while( *p = *q++ ) ++p;
 113:     return( p );
 114:     }
 115: 
 116: # define ISIZE 400
 117: char *writem(pp) int *pp; { /* creates output string for item pointed to by pp */
 118:     int i,*p;
 119:     static char sarr[ISIZE];
 120:     char *q;
 121: 
 122:     for( p=pp; *p>0 ; ++p ) ;
 123:     p = prdptr[-*p];
 124:     q = chcopy( sarr, nontrst[*p-NTBASE].name );
 125:     q = chcopy( q, " : " );
 126: 
 127:     for(;;){
 128:         *q++ = ++p==pp ? '_' : ' ';
 129:         *q = '\0';
 130:         if((i = *p) <= 0) break;
 131:         q = chcopy( q, symnam(i) );
 132:         if( q> &sarr[ISIZE-30] ) error( "item too big" );
 133:         }
 134: 
 135:     if( (i = *pp) < 0 ){ /* an item calling for a reduction */
 136:         q = chcopy( q, "    (" );
 137:         sprintf( q, "%d)", -i );
 138:         }
 139: 
 140:     return( sarr );
 141:     }
 142: 
 143: char *symnam(i){ /* return a pointer to the name of symbol i */
 144:     char *cp;
 145: 
 146:     cp = (i>=NTBASE) ? nontrst[i-NTBASE].name : tokset[i].name ;
 147:     if( *cp == ' ' ) ++cp;
 148:     return( cp );
 149:     }
 150: 
 151: struct wset *zzcwp = wsets;
 152: int zzgoent = 0;
 153: int zzgobest = 0;
 154: int zzacent = 0;
 155: int zzexcp = 0;
 156: int zzclose = 0;
 157: int zzsrconf = 0;
 158: int * zzmemsz = mem0;
 159: int zzrrconf = 0;
 160: 
 161: summary(){ /* output the summary on the tty */
 162: 
 163:     if( foutput!=NULL ){
 164:         fprintf( foutput, "\n%d/%d terminals, %d/%d nonterminals\n", ntokens, NTERMS,
 165:                 nnonter, NNONTERM );
 166:         fprintf( foutput, "%d/%d grammar rules, %d/%d states\n", nprod, NPROD, nstate, NSTATES );
 167:         fprintf( foutput, "%d shift/reduce, %d reduce/reduce conflicts reported\n", zzsrconf, zzrrconf );
 168:         fprintf( foutput, "%d/%d working sets used\n", zzcwp-wsets,  WSETSIZE );
 169:         fprintf( foutput, "memory: states,etc. %d/%d, parser %d/%d\n", zzmemsz-mem0, MEMSIZE,
 170:                 memp-amem, ACTSIZE );
 171:         fprintf( foutput, "%d/%d distinct lookahead sets\n", nlset, LSETSIZE );
 172:         fprintf( foutput, "%d extra closures\n", zzclose - 2*nstate );
 173:         fprintf( foutput, "%d shift entries, %d exceptions\n", zzacent, zzexcp );
 174:         fprintf( foutput, "%d goto entries\n", zzgoent );
 175:         fprintf( foutput, "%d entries saved by goto default\n", zzgobest );
 176:         }
 177:     if( zzsrconf!=0 || zzrrconf!=0 ){
 178:           fprintf( stdout,"\nconflicts: ");
 179:           if( zzsrconf )fprintf( stdout, "%d shift/reduce" , zzsrconf );
 180:           if( zzsrconf && zzrrconf )fprintf( stdout, ", " );
 181:           if( zzrrconf )fprintf( stdout, "%d reduce/reduce" , zzrrconf );
 182:           fprintf( stdout, "\n" );
 183:           }
 184: 
 185:     fclose( ftemp );
 186:     if( fdefine != NULL ) fclose( fdefine );
 187:     }
 188: 
 189: /* VARARGS1 */
 190: error(s,a1) char *s; { /* write out error comment */
 191: 
 192:     ++nerrors;
 193:     fprintf( stderr, "\n fatal error: ");
 194:     fprintf( stderr, s,a1);
 195:     fprintf( stderr, ", line %d\n", lineno );
 196:     if( !fatfl ) return;
 197:     summary();
 198:     exit(1);
 199:     }
 200: 
 201: aryfil( v, n, c ) int *v,n,c; { /* set elements 0 through n-1 to c */
 202:     int i;
 203:     for( i=0; i<n; ++i ) v[i] = c;
 204:     }
 205: 
 206: setunion( a, b ) register *a, *b; {
 207:     /* set a to the union of a and b */
 208:     /* return 1 if b is not a subset of a, 0 otherwise */
 209:     register i, x, sub;
 210: 
 211:     sub = 0;
 212:     SETLOOP(i){
 213:         *a = (x = *a)|*b++;
 214:         if( *a++ != x ) sub = 1;
 215:         }
 216:     return( sub );
 217:     }
 218: 
 219: prlook( p ) struct looksets *p;{
 220:     register j, *pp;
 221:     pp = p->lset;
 222:     if( pp == 0 ) fprintf( foutput, "\tNULL");
 223:     else {
 224:         fprintf( foutput, " { " );
 225:         TLOOP(j) {
 226:             if( BIT(pp,j) ) fprintf( foutput,  "%s ", symnam(j) );
 227:             }
 228:         fprintf( foutput,  "}" );
 229:         }
 230:     }
 231: 
 232: cpres(){ /* compute an array with the beginnings of  productions yielding given nonterminals
 233: 	The array pres points to these lists */
 234:     /* the array pyield has the lists: the total size is only NPROD+1 */
 235:     register **pmem;
 236:     register c, j, i;
 237:     static int * pyield[NPROD];
 238: 
 239:     pmem = pyield;
 240: 
 241:     NTLOOP(i){
 242:         c = i+NTBASE;
 243:         pres[i] = pmem;
 244:         fatfl = 0;  /* make undefined  symbols  nonfatal */
 245:         PLOOP(0,j){
 246:             if (*prdptr[j] == c) *pmem++ =  prdptr[j]+1;
 247:             }
 248:         if(pres[i] == pmem){
 249:             error("nonterminal %s not defined!", nontrst[i].name);
 250:             }
 251:         }
 252:     pres[i] = pmem;
 253:     fatfl = 1;
 254:     if( nerrors ){
 255:         summary();
 256:         exit(1);
 257:         }
 258:     if( pmem != &pyield[nprod] ) error( "internal Yacc error: pyield %d", pmem-&pyield[nprod] );
 259:     }
 260: 
 261: int indebug = 0;
 262: cpfir() {
 263:     /* compute an array with the first of nonterminals */
 264:     register *p, **s, i, **t, ch, changes;
 265: 
 266:     zzcwp = &wsets[nnonter];
 267:     NTLOOP(i){
 268:         aryfil( wsets[i].ws.lset, tbitset, 0 );
 269:         t = pres[i+1];
 270:         for( s=pres[i]; s<t; ++s ){ /* initially fill the sets */
 271:             for( p = *s; (ch = *p) > 0 ; ++p ) {
 272:                 if( ch < NTBASE ) {
 273:                     SETBIT( wsets[i].ws.lset, ch );
 274:                     break;
 275:                     }
 276:                 else if( !pempty[ch-NTBASE] ) break;
 277:                 }
 278:             }
 279:         }
 280: 
 281:     /* now, reflect transitivity */
 282: 
 283:     changes = 1;
 284:     while( changes ){
 285:         changes = 0;
 286:         NTLOOP(i){
 287:             t = pres[i+1];
 288:             for( s=pres[i]; s<t; ++s ){
 289:                 for( p = *s; ( ch = (*p-NTBASE) ) >= 0; ++p ) {
 290:                     changes |= setunion( wsets[i].ws.lset, wsets[ch].ws.lset );
 291:                     if( !pempty[ch] ) break;
 292:                     }
 293:                 }
 294:             }
 295:         }
 296: 
 297:     NTLOOP(i) pfirst[i] = flset( &wsets[i].ws );
 298:     if( !indebug ) return;
 299:     if( (foutput!=NULL) ){
 300:         NTLOOP(i) {
 301:             fprintf( foutput,  "\n%s: ", nontrst[i].name );
 302:             prlook( pfirst[i] );
 303:             fprintf( foutput,  " %d\n", pempty[i] );
 304:             }
 305:         }
 306:     }
 307: 
 308: state(c){ /* sorts last state,and sees if it equals earlier ones. returns state number */
 309:     int size1,size2;
 310:     register i;
 311:     struct item *p1, *p2, *k, *l, *q1, *q2;
 312:     p1 = pstate[nstate];
 313:     p2 = pstate[nstate+1];
 314:     if(p1==p2) return(0); /* null state */
 315:     /* sort the items */
 316:     for(k=p2-1;k>p1;k--) {  /* make k the biggest */
 317:         for(l=k-1;l>=p1;--l)if( l->pitem > k->pitem ){
 318:             int *s;
 319:             struct looksets *ss;
 320:             s = k->pitem;
 321:             k->pitem = l->pitem;
 322:             l->pitem = s;
 323:             ss = k->look;
 324:             k->look = l->look;
 325:             l->look = ss;
 326:             }
 327:         }
 328:     size1 = p2 - p1; /* size of state */
 329: 
 330:     for( i= (c>=NTBASE)?ntstates[c-NTBASE]:tstates[c]; i != 0; i = mstates[i] ) {
 331:         /* get ith state */
 332:         q1 = pstate[i];
 333:         q2 = pstate[i+1];
 334:         size2 = q2 - q1;
 335:         if (size1 != size2) continue;
 336:         k=p1;
 337:         for(l=q1;l<q2;l++) {
 338:             if( l->pitem != k->pitem ) break;
 339:             ++k;
 340:             }
 341:         if (l != q2) continue;
 342:         /* found it */
 343:         pstate[nstate+1] = pstate[nstate]; /* delete last state */
 344:         /* fix up lookaheads */
 345:         if( nolook ) return(i);
 346:         for( l=q1,k=p1; l<q2; ++l,++k ){
 347:             int s;
 348:             SETLOOP(s) clset.lset[s] = l->look->lset[s];
 349:             if( setunion( clset.lset, k->look->lset ) ) {
 350:                 tystate[i] = MUSTDO;
 351:                 /* register the new set */
 352:                 l->look = flset( &clset );
 353:                 }
 354:             }
 355:         return (i);
 356:         }
 357:     /* state is new */
 358:     if( nolook ) error( "yacc state/nolook error" );
 359:     pstate[nstate+2] = p2;
 360:     if(nstate+1 >= NSTATES) error("too many states" );
 361:     if( c >= NTBASE ){
 362:         mstates[ nstate ] = ntstates[ c-NTBASE ];
 363:         ntstates[ c-NTBASE ] = nstate;
 364:         }
 365:     else {
 366:         mstates[ nstate ] = tstates[ c ];
 367:         tstates[ c ] = nstate;
 368:         }
 369:     tystate[nstate]=MUSTDO;
 370:     return(nstate++);
 371:     }
 372: 
 373: int pidebug = 0; /* debugging flag for putitem */
 374: putitem( ptr, lptr )  int *ptr;  struct looksets *lptr; {
 375:     register struct item *j;
 376: 
 377:     if( pidebug && (foutput!=NULL) ) {
 378:         fprintf( foutput, "putitem(%s), state %d\n", writem(ptr), nstate );
 379:         }
 380:     j = pstate[nstate+1];
 381:     j->pitem = ptr;
 382:     if( !nolook ) j->look = flset( lptr );
 383:     pstate[nstate+1] = ++j;
 384:     if( (int *)j > zzmemsz ){
 385:         zzmemsz = (int *)j;
 386:         if( zzmemsz >=  &mem0[MEMSIZE] ) error( "out of state space" );
 387:         }
 388:     }
 389: 
 390: cempty(){ /* mark nonterminals which derive the empty string */
 391:     /* also, look for nonterminals which don't derive any token strings */
 392: 
 393: # define EMPTY 1
 394: # define WHOKNOWS 0
 395: # define OK 1
 396: 
 397:     register i, *p;
 398: 
 399:     /* first, use the array pempty to detect productions that can never be reduced */
 400:     /* set pempty to WHONOWS */
 401:     aryfil( pempty, nnonter+1, WHOKNOWS );
 402: 
 403:     /* now, look at productions, marking nonterminals which derive something */
 404: 
 405:     more:
 406:     PLOOP(0,i){
 407:         if( pempty[ *prdptr[i] - NTBASE ] ) continue;
 408:         for( p=prdptr[i]+1; *p>=0; ++p ){
 409:             if( *p>=NTBASE && pempty[ *p-NTBASE ] == WHOKNOWS ) break;
 410:             }
 411:         if( *p < 0 ){ /* production can be derived */
 412:             pempty[ *prdptr[i]-NTBASE ] = OK;
 413:             goto more;
 414:             }
 415:         }
 416: 
 417:     /* now, look at the nonterminals, to see if they are all OK */
 418: 
 419:     NTLOOP(i){
 420:         /* the added production rises or falls as the start symbol ... */
 421:         if( i == 0 ) continue;
 422:         if( pempty[ i ] != OK ) {
 423:             fatfl = 0;
 424:             error( "nonterminal %s never derives any token string", nontrst[i].name );
 425:             }
 426:         }
 427: 
 428:     if( nerrors ){
 429:         summary();
 430:         exit(1);
 431:         }
 432: 
 433:     /* now, compute the pempty array, to see which nonterminals derive the empty string */
 434: 
 435:     /* set pempty to WHOKNOWS */
 436: 
 437:     aryfil( pempty, nnonter+1, WHOKNOWS );
 438: 
 439:     /* loop as long as we keep finding empty nonterminals */
 440: 
 441: again:
 442:     PLOOP(1,i){
 443:         if( pempty[ *prdptr[i]-NTBASE ]==WHOKNOWS ){ /* not known to be empty */
 444:             for( p=prdptr[i]+1; *p>=NTBASE && pempty[*p-NTBASE]==EMPTY ; ++p ) ;
 445:             if( *p < 0 ){ /* we have a nontrivially empty nonterminal */
 446:                 pempty[*prdptr[i]-NTBASE] = EMPTY;
 447:                 goto again; /* got one ... try for another */
 448:                 }
 449:             }
 450:         }
 451: 
 452:     }
 453: 
 454: int gsdebug = 0;
 455: stagen(){ /* generate the states */
 456: 
 457:     int i, j;
 458:     register c;
 459:     register struct wset *p, *q;
 460: 
 461:     /* initialize */
 462: 
 463:     nstate = 0;
 464:     /* THIS IS FUNNY from the standpoint of portability */
 465:     /* it represents the magic moment when the mem0 array, which has
 466: 	/* been holding the productions, starts to hold item pointers, of a
 467: 	/* different type... */
 468:     /* someday, alloc should be used to allocate all this stuff... for now, we
 469: 	/* accept that if pointers don't fit in integers, there is a problem... */
 470: 
 471:     pstate[0] = pstate[1] = (struct item *)mem;
 472:     aryfil( clset.lset, tbitset, 0 );
 473:     putitem( prdptr[0]+1, &clset );
 474:     tystate[0] = MUSTDO;
 475:     nstate = 1;
 476:     pstate[2] = pstate[1];
 477: 
 478:     aryfil( amem, ACTSIZE, 0 );
 479: 
 480:     /* now, the main state generation loop */
 481: 
 482:     more:
 483:     SLOOP(i){
 484:         if( tystate[i] != MUSTDO ) continue;
 485:         tystate[i] = DONE;
 486:         aryfil( temp1, nnonter+1, 0 );
 487:         /* take state i, close it, and do gotos */
 488:         closure(i);
 489:         WSLOOP(wsets,p){ /* generate goto's */
 490:             if( p->flag ) continue;
 491:             p->flag = 1;
 492:             c = *(p->pitem);
 493:             if( c <= 1 ) {
 494:                 if( pstate[i+1]-pstate[i] <= p-wsets ) tystate[i] = MUSTLOOKAHEAD;
 495:                 continue;
 496:                 }
 497:             /* do a goto on c */
 498:             WSLOOP(p,q){
 499:                 if( c == *(q->pitem) ){ /* this item contributes to the goto */
 500:                     putitem( q->pitem + 1, &q->ws );
 501:                     q->flag = 1;
 502:                     }
 503:                 }
 504:             if( c < NTBASE ) {
 505:                 state(c);  /* register new state */
 506:                 }
 507:             else {
 508:                 temp1[c-NTBASE] = state(c);
 509:                 }
 510:             }
 511:         if( gsdebug && (foutput!=NULL) ){
 512:             fprintf( foutput,  "%d: ", i );
 513:             NTLOOP(j) {
 514:                 if( temp1[j] ) fprintf( foutput,  "%s %d, ", nontrst[j].name, temp1[j] );
 515:                 }
 516:             fprintf( foutput, "\n");
 517:             }
 518:         indgo[i] = apack( &temp1[1], nnonter-1 ) - 1;
 519:         goto more; /* we have done one goto; do some more */
 520:         }
 521:     /* no more to do... stop */
 522:     }
 523: 
 524: int cldebug = 0; /* debugging flag for closure */
 525: closure(i){ /* generate the closure of state i */
 526: 
 527:     int c, ch, work, k;
 528:     register struct wset *u, *v;
 529:     int *pi;
 530:     int **s, **t;
 531:     struct item *q;
 532:     register struct item *p;
 533: 
 534:     ++zzclose;
 535: 
 536:     /* first, copy kernel of state i to wsets */
 537: 
 538:     cwp = wsets;
 539:     ITMLOOP(i,p,q){
 540:         cwp->pitem = p->pitem;
 541:         cwp->flag = 1;    /* this item must get closed */
 542:         SETLOOP(k) cwp->ws.lset[k] = p->look->lset[k];
 543:         WSBUMP(cwp);
 544:         }
 545: 
 546:     /* now, go through the loop, closing each item */
 547: 
 548:     work = 1;
 549:     while( work ){
 550:         work = 0;
 551:         WSLOOP(wsets,u){
 552: 
 553:             if( u->flag == 0 ) continue;
 554:             c = *(u->pitem);  /* dot is before c */
 555: 
 556:             if( c < NTBASE ){
 557:                 u->flag = 0;
 558:                 continue;  /* only interesting case is where . is before nonterminal */
 559:                 }
 560: 
 561:             /* compute the lookahead */
 562:             aryfil( clset.lset, tbitset, 0 );
 563: 
 564:             /* find items involving c */
 565: 
 566:             WSLOOP(u,v){
 567:                 if( v->flag == 1 && *(pi=v->pitem) == c ){
 568:                     v->flag = 0;
 569:                     if( nolook ) continue;
 570:                     while( (ch= *++pi)>0 ){
 571:                         if( ch < NTBASE ){ /* terminal symbol */
 572:                             SETBIT( clset.lset, ch );
 573:                             break;
 574:                             }
 575:                         /* nonterminal symbol */
 576:                         setunion( clset.lset, pfirst[ch-NTBASE]->lset );
 577:                         if( !pempty[ch-NTBASE] ) break;
 578:                         }
 579:                     if( ch<=0 ) setunion( clset.lset, v->ws.lset );
 580:                     }
 581:                 }
 582: 
 583:             /*  now loop over productions derived from c */
 584: 
 585:             c -= NTBASE; /* c is now nonterminal number */
 586: 
 587:             t = pres[c+1];
 588:             for( s=pres[c]; s<t; ++s ){
 589:                 /* put these items into the closure */
 590:                 WSLOOP(wsets,v){ /* is the item there */
 591:                     if( v->pitem == *s ){ /* yes, it is there */
 592:                         if( nolook ) goto nexts;
 593:                         if( setunion( v->ws.lset, clset.lset ) ) v->flag = work = 1;
 594:                         goto nexts;
 595:                         }
 596:                     }
 597: 
 598:                 /*  not there; make a new entry */
 599:                 if( cwp-wsets+1 >= WSETSIZE ) error( "working set overflow" );
 600:                 cwp->pitem = *s;
 601:                 cwp->flag = 1;
 602:                 if( !nolook ){
 603:                     work = 1;
 604:                     SETLOOP(k) cwp->ws.lset[k] = clset.lset[k];
 605:                     }
 606:                 WSBUMP(cwp);
 607: 
 608:             nexts: ;
 609:                 }
 610: 
 611:             }
 612:         }
 613: 
 614:     /* have computed closure; flags are reset; return */
 615: 
 616:     if( cwp > zzcwp ) zzcwp = cwp;
 617:     if( cldebug && (foutput!=NULL) ){
 618:         fprintf( foutput, "\nState %d, nolook = %d\n", i, nolook );
 619:         WSLOOP(wsets,u){
 620:             if( u->flag ) fprintf( foutput, "flag set!\n");
 621:             u->flag = 0;
 622:             fprintf( foutput, "\t%s", writem(u->pitem));
 623:             prlook( &u->ws );
 624:             fprintf( foutput,  "\n" );
 625:             }
 626:         }
 627:     }
 628: 
 629: struct looksets *flset( p )   struct looksets *p; {
 630:     /* decide if the lookahead set pointed to by p is known */
 631:     /* return pointer to a perminent location for the set */
 632: 
 633:     register struct looksets *q;
 634:     int j, *w;
 635:     register *u, *v;
 636: 
 637:     for( q = &lkst[nlset]; q-- > lkst; ){
 638:         u = p->lset;
 639:         v = q->lset;
 640:         w = & v[tbitset];
 641:         while( v<w) if( *u++ != *v++ ) goto more;
 642:         /* we have matched */
 643:         return( q );
 644:         more: ;
 645:         }
 646:     /* add a new one */
 647:     q = &lkst[nlset++];
 648:     if( nlset >= LSETSIZE )error("too many lookahead sets" );
 649:     SETLOOP(j){
 650:         q->lset[j] = p->lset[j];
 651:         }
 652:     return( q );
 653:     }

Defined functions

Defined variables

Defined macros