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

   1: #ifndef lint
   2: static char sccsid[] = "@(#)sub1.c	4.2 (Berkeley) 2/21/85";
   3: #endif
   4: 
   5: # include "ldefs.c"
   6: char *
   7: getl(p) /* return next line of input, throw away trailing '\n' */
   8:     /* returns 0 if eof is had immediately */
   9:   char *p;
  10:     {
  11:     register int c;
  12:     register char *s, *t;
  13:     t = s = p;
  14:     while(((c = gch()) != 0) && c != '\n')
  15:         *t++ = c;
  16:     *t = 0;
  17:     if(c == 0 && s == t) return(0);
  18:     prev = '\n';
  19:     pres = '\n';
  20:     return(s);
  21:     }
  22: space(ch)
  23:     {
  24:     switch(ch)
  25:         {
  26:         case ' ':
  27:         case '\t':
  28:         case '\n':
  29:             return(1);
  30:         }
  31:     return(0);
  32:     }
  33: 
  34: digit(c)
  35: {
  36:     return(c>='0' && c <= '9');
  37: }
  38: error(s,p,d)
  39:     {
  40:     fprintf(errorf,"\"%s\", line %d: (Error) ",
  41:         fptr > 0 ? sargv[fptr] : "<stdin>", yyline);
  42:     fprintf(errorf,s,p,d);
  43:     putc('\n',errorf);
  44: # ifdef DEBUG
  45:     if(debug && sect != ENDSECTION) {
  46:         sect1dump();
  47:         sect2dump();
  48:     }
  49: # endif
  50:     if(
  51: # ifdef DEBUG
  52:         debug ||
  53: # endif
  54:         report == 1) statistics();
  55:     exit(1);    /* error return code */
  56:     }
  57: 
  58: warning(s,p,d)
  59:     {
  60:     fprintf(errorf,"\"%s\", line %d: (Warning) ",
  61:         fptr > 0 ? sargv[fptr] : "<stdin>", yyline);
  62:     fprintf(errorf,s,p,d);
  63:     putc('\n',errorf);
  64:     fflush(errorf);
  65:     fflush(fout);
  66:     fflush(stdout);
  67:     }
  68: index(a,s)
  69:     char *s;
  70: {
  71:     register int k;
  72:     for(k=0; s[k]; k++)
  73:         if (s[k]== a)
  74:             return(k);
  75:     return(-1);
  76:     }
  77: 
  78: alpha(c)
  79:   int c; {
  80: # ifdef ASCII
  81: return('a' <= c && c <= 'z' || 'A' <= c && c <= 'Z');
  82: # endif
  83: # ifdef EBCDIC
  84: return(index(c,"abcdefghijklmnopqrstuvxyzABCDEFGHIJKLMNOPQRSTUVWXYZ") >= 0);
  85: # endif
  86: }
  87: printable(c)
  88: {
  89: # ifdef ASCII
  90: return( c>040 && c < 0177);
  91: # endif
  92: # ifdef EBCDIC
  93: return(index(c, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.,;:><+*)('&%!-=\"")>=0);
  94: # endif
  95: }
  96: lgate()
  97: {
  98:     char fname[20];
  99:     if (lgatflg) return;
 100:     lgatflg=1;
 101:     if(fout == NULL){
 102:         sprintf(fname, "lex.yy.%c", ratfor ? 'r' : 'c' );
 103:         fout = fopen(fname, "w");
 104:         }
 105:     if(fout == NULL) error("Can't open %s",fname);
 106:     if(ratfor) fprintf( fout, "#\n");
 107:     phead1();
 108:     }
 109: /* scopy(ptr to str, ptr to str) - copy first arg str to second */
 110: /* returns ptr to second arg */
 111: scopy(s,t)
 112:   char *s, *t; {
 113:     register char *i;
 114:     i = t;
 115:     while(*i++ = *s++);
 116:     return;
 117:     }
 118: siconv(t)   /* convert string t, return integer value */
 119:   char *t; {
 120:     register int i,sw;
 121:     register char *s;
 122:     s = t;
 123:     while(!(('0' <= *s && *s <= '9') || *s == '-') && *s) s++;
 124:     sw = 0;
 125:     if(*s == '-'){  /* neg */
 126:         sw = 1;
 127:         s++;
 128:         }
 129:     i = 0;
 130:     while('0' <= *s && *s <= '9')
 131:         i = i * 10 + (*(s++)-'0');
 132:     return(sw ? -i : i);
 133:     }
 134: /* slength(ptr to str) - return integer length of string arg */
 135: /* excludes '\0' terminator */
 136: slength(s)
 137:   char *s; {
 138:     register int n;
 139:     register char *t;
 140:     t = s;
 141:     for (n = 0; *t++; n++);
 142:     return(n);
 143:     }
 144: /* scomp(x,y) - return -1 if x < y,
 145: 		0 if x == y,
 146: 		return 1 if x > y, all lexicographically */
 147: scomp(x,y)
 148:   char *x,*y; {
 149:     register char *a,*d;
 150:     a = x;
 151:     d = y;
 152:     while(*a || *d){
 153:         if(*a > *d)
 154:             return(1);  /* greater */
 155:         if(*a < *d)
 156:             return(-1); /* less */
 157:         a++;
 158:         d++;
 159:         }
 160:     return(0);  /* equal */
 161:     }
 162: ctrans(ss)
 163:     char **ss;
 164: {
 165:     register int c, k;
 166:     if ((c = **ss) != '\\')
 167:         return(c);
 168:     switch(c= *++*ss)
 169:     {
 170:     case 'n': c = '\n'; break;
 171:     case 't': c = '\t'; break;
 172:     case 'r': c = '\r'; break;
 173:     case 'b': c = '\b'; break;
 174:     case 'f': c = 014; break;       /* form feed for ascii */
 175:     case '\\': c = '\\'; break;
 176:     case '0': case '1': case '2': case '3':
 177:     case '4': case '5': case '6': case '7':
 178:         c -= '0';
 179:         while ((k = *(*ss+1)) >= '0' && k <= '7')
 180:             {
 181:             c = c*8 + k - '0';
 182:             (*ss)++;
 183:             }
 184:         break;
 185:     }
 186:     return(c);
 187: }
 188: cclinter(sw)
 189:   int sw; {
 190:         /* sw = 1 ==> ccl */
 191:     register int i, j, k;
 192:     int m;
 193:     if(!sw){        /* is NCCL */
 194:         for(i=1;i<NCH;i++)
 195:             symbol[i] ^= 1;         /* reverse value */
 196:         }
 197:     for(i=1;i<NCH;i++)
 198:         if(symbol[i]) break;
 199:     if(i >= NCH) return;
 200:     i = cindex[i];
 201:     /* see if ccl is already in our table */
 202:     j = 0;
 203:     if(i){
 204:         for(j=1;j<NCH;j++){
 205:             if((symbol[j] && cindex[j] != i) ||
 206:                (!symbol[j] && cindex[j] == i)) break;
 207:             }
 208:         }
 209:     if(j >= NCH) return;        /* already in */
 210:     m = 0;
 211:     k = 0;
 212:     for(i=1;i<NCH;i++)
 213:         if(symbol[i]){
 214:             if(!cindex[i]){
 215:                 cindex[i] = ccount;
 216:                 symbol[i] = 0;
 217:                 m = 1;
 218:                 }
 219:             else k = 1;
 220:             }
 221:             /* m == 1 implies last value of ccount has been used */
 222:     if(m)ccount++;
 223:     if(k == 0) return;  /* is now in as ccount wholly */
 224:     /* intersection must be computed */
 225:     for(i=1;i<NCH;i++){
 226:         if(symbol[i]){
 227:             m = 0;
 228:             j = cindex[i];  /* will be non-zero */
 229:             for(k=1;k<NCH;k++){
 230:                 if(cindex[k] == j){
 231:                     if(symbol[k]) symbol[k] = 0;
 232:                     else {
 233:                         cindex[k] = ccount;
 234:                         m = 1;
 235:                         }
 236:                     }
 237:                 }
 238:             if(m)ccount++;
 239:             }
 240:         }
 241:     return;
 242:     }
 243: usescape(c)
 244:   int c; {
 245:     register char d;
 246:     switch(c){
 247:     case 'n': c = '\n'; break;
 248:     case 'r': c = '\r'; break;
 249:     case 't': c = '\t'; break;
 250:     case 'b': c = '\b'; break;
 251:     case 'f': c = 014; break;       /* form feed for ascii */
 252:     case '0': case '1': case '2': case '3':
 253:     case '4': case '5': case '6': case '7':
 254:         c -= '0';
 255:         while('0' <= (d=gch()) && d <= '7'){
 256:             c = c * 8 + (d-'0');
 257:             if(!('0' <= peek && peek <= '7')) break;
 258:             }
 259:         break;
 260:     }
 261:     return(c);
 262:     }
 263: lookup(s,t)
 264:   char *s;
 265:   char **t; {
 266:     register int i;
 267:     i = 0;
 268:     while(*t){
 269:         if(scomp(s,*t) == 0)
 270:             return(i);
 271:         i++;
 272:         t++;
 273:         }
 274:     return(-1);
 275:     }
 276: cpyact(){ /* copy C action to the next ; or closing } */
 277:     register int brac, c, mth;
 278:     int savline, sw;
 279: 
 280:     brac = 0;
 281:     sw = TRUE;
 282: 
 283: while(!eof){
 284:     c = gch();
 285: swt:
 286:     switch( c ){
 287: 
 288: case '|':   if(brac == 0 && sw == TRUE){
 289:             if(peek == '|')gch();       /* eat up an extra '|' */
 290:             return(0);
 291:             }
 292:         break;
 293: 
 294: case ';':
 295:         if( brac == 0 ){
 296:             putc(c,fout);
 297:             putc('\n',fout);
 298:             return(1);
 299:             }
 300:         break;
 301: 
 302: case '{':
 303:         brac++;
 304:         savline=yyline;
 305:         break;
 306: 
 307: case '}':
 308:         brac--;
 309:         if( brac == 0 ){
 310:             putc(c,fout);
 311:             putc('\n',fout);
 312:             return(1);
 313:             }
 314:         break;
 315: 
 316: case '/':   /* look for comments */
 317:         putc(c,fout);
 318:         c = gch();
 319:         if( c != '*' ) goto swt;
 320: 
 321:         /* it really is a comment */
 322: 
 323:         putc(c,fout);
 324:         savline=yyline;
 325:         while( c=gch() ){
 326:             if( c=='*' ){
 327:                 putc(c,fout);
 328:                 if( (c=gch()) == '/' ) goto loop;
 329:                 }
 330:             putc(c,fout);
 331:             }
 332:         yyline=savline;
 333:         error( "EOF inside comment" );
 334: 
 335: case '\'':  /* character constant */
 336:         mth = '\'';
 337:         goto string;
 338: 
 339: case '"':   /* character string */
 340:         mth = '"';
 341: 
 342:     string:
 343: 
 344:         putc(c,fout);
 345:         while( c=gch() ){
 346:             if( c=='\\' ){
 347:                 putc(c,fout);
 348:                 c=gch();
 349:                 }
 350:             else if( c==mth ) goto loop;
 351:             putc(c,fout);
 352:             if (c == '\n')
 353:                 {
 354:                 yyline--;
 355:                 error( "Non-terminated string or character constant");
 356:                 }
 357:             }
 358:         error( "EOF in string or character constant" );
 359: 
 360: case '\0':
 361:         yyline = savline;
 362:         error("Action does not terminate");
 363: default:
 364:         break;      /* usual character */
 365:         }
 366: loop:
 367:     if(c != ' ' && c != '\t' && c != '\n') sw = FALSE;
 368:     putc(c,fout);
 369:     }
 370: error("Premature EOF");
 371: }
 372: gch(){
 373:     register int c;
 374:     static int hadeof;
 375: 
 376:     if (hadeof) {
 377:         hadeof = 0;
 378:         yyline = 0;
 379:     }
 380:     prev = pres;
 381:     c = pres = peek;
 382:     peek = pushptr > pushc ? *--pushptr : getc(fin);
 383:     if(peek == EOF && sargc > 1){
 384:         hadeof = 1;
 385:         fclose(fin);
 386:         fin = fopen(sargv[++fptr],"r");
 387:         if(fin == NULL) {
 388:             yyline = 0;
 389:             error("Cannot open file %s",sargv[fptr]);
 390:         }
 391:         peek = getc(fin);
 392:         sargc--;
 393:         }
 394:     if(c == EOF) {
 395:         eof = TRUE;
 396:         fclose(fin);
 397:         return(0);
 398:         }
 399:     if(c == '\n')yyline++;
 400:     return(c);
 401:     }
 402: mn2(a,d,c)
 403:   int a,d,c;
 404:     {
 405:     name[tptr] = a;
 406:     left[tptr] = d;
 407:     right[tptr] = c;
 408:     parent[tptr] = 0;
 409:     nullstr[tptr] = 0;
 410:     switch(a){
 411:     case RSTR:
 412:         parent[d] = tptr;
 413:         break;
 414:     case BAR:
 415:     case RNEWE:
 416:         if(nullstr[d] || nullstr[c]) nullstr[tptr] = TRUE;
 417:         parent[d] = parent[c] = tptr;
 418:         break;
 419:     case RCAT:
 420:     case DIV:
 421:         if(nullstr[d] && nullstr[c])nullstr[tptr] = TRUE;
 422:         parent[d] = parent[c] = tptr;
 423:         break;
 424:     case RSCON:
 425:         parent[d] = tptr;
 426:         nullstr[tptr] = nullstr[d];
 427:         break;
 428: # ifdef DEBUG
 429:     default:
 430:         warning("bad switch mn2 %d %d",a,d);
 431:         break;
 432: # endif
 433:         }
 434:     if(tptr > treesize)
 435:         error("Parse tree too big %s",(treesize == TREESIZE?"\nTry using %e num":""));
 436:     return(tptr++);
 437:     }
 438: mn1(a,d)
 439:   int a,d;
 440:     {
 441:     name[tptr] = a;
 442:     left[tptr] = d;
 443:     parent[tptr] = 0;
 444:     nullstr[tptr] = 0;
 445:     switch(a){
 446:     case RCCL:
 447:     case RNCCL:
 448:         if(slength(d) == 0) nullstr[tptr] = TRUE;
 449:         break;
 450:     case STAR:
 451:     case QUEST:
 452:         nullstr[tptr] = TRUE;
 453:         parent[d] = tptr;
 454:         break;
 455:     case PLUS:
 456:     case CARAT:
 457:         nullstr[tptr] = nullstr[d];
 458:         parent[d] = tptr;
 459:         break;
 460:     case S2FINAL:
 461:         nullstr[tptr] = TRUE;
 462:         break;
 463: # ifdef DEBUG
 464:     case FINAL:
 465:     case S1FINAL:
 466:         break;
 467:     default:
 468:         warning("bad switch mn1 %d %d",a,d);
 469:         break;
 470: # endif
 471:         }
 472:     if(tptr > treesize)
 473:         error("Parse tree too big %s",(treesize == TREESIZE?"\nTry using %e num":""));
 474:     return(tptr++);
 475:     }
 476: mn0(a)
 477:   int a;
 478:     {
 479:     name[tptr] = a;
 480:     parent[tptr] = 0;
 481:     nullstr[tptr] = 0;
 482:     if(a >= NCH) switch(a){
 483:     case RNULLS: nullstr[tptr] = TRUE; break;
 484: # ifdef DEBUG
 485:     default:
 486:         warning("bad switch mn0 %d",a);
 487:         break;
 488: # endif
 489:     }
 490:     if(tptr > treesize)
 491:         error("Parse tree too big %s",(treesize == TREESIZE?"\nTry using %e num":""));
 492:     return(tptr++);
 493:     }
 494: munput(t,p) /* implementation dependent */
 495:   char *p;
 496:   int t; {
 497:     register int i,j;
 498:     if(t == 'c'){
 499:         *pushptr++ = peek;      /* watch out for this */
 500:         peek = p;
 501:         }
 502:     else if(t == 's'){
 503:         *pushptr++ = peek;
 504:         peek = p[0];
 505:         i = slength(p);
 506:         for(j = i-1; j>=1; j--)
 507:             *pushptr++ = p[j];
 508:         }
 509: # ifdef DEBUG
 510:     else error("Unrecognized munput option %c",t);
 511: # endif
 512:     if(pushptr >= pushc+TOKENSIZE)
 513:         error("Too many characters pushed");
 514:     return;
 515:     }
 516: 
 517: dupl(n)
 518:   int n; {
 519:     /* duplicate the subtree whose root is n, return ptr to it */
 520:     register int i;
 521:     i = name[n];
 522:     if(i < NCH) return(mn0(i));
 523:     switch(i){
 524:     case RNULLS:
 525:         return(mn0(i));
 526:     case RCCL: case RNCCL: case FINAL: case S1FINAL: case S2FINAL:
 527:         return(mn1(i,left[n]));
 528:     case STAR: case QUEST: case PLUS: case CARAT:
 529:         return(mn1(i,dupl(left[n])));
 530:     case RSTR: case RSCON:
 531:         return(mn2(i,dupl(left[n]),right[n]));
 532:     case BAR: case RNEWE: case RCAT: case DIV:
 533:         return(mn2(i,dupl(left[n]),dupl(right[n])));
 534: # ifdef DEBUG
 535:     default:
 536:         warning("bad switch dupl %d",n);
 537: # endif
 538:     }
 539:     return(0);
 540:     }
 541: # ifdef DEBUG
 542: allprint(c)
 543:   char c; {
 544:     switch(c){
 545:         case 014:
 546:             printf("\\f");
 547:             charc++;
 548:             break;
 549:         case '\n':
 550:             printf("\\n");
 551:             charc++;
 552:             break;
 553:         case '\t':
 554:             printf("\\t");
 555:             charc++;
 556:             break;
 557:         case '\b':
 558:             printf("\\b");
 559:             charc++;
 560:             break;
 561:         case ' ':
 562:             printf("\\\bb");
 563:             break;
 564:         default:
 565:             if(!printable(c)){
 566:                 printf("\\%-3o",c);
 567:                 charc += 3;
 568:                 }
 569:             else
 570:                 putchar(c);
 571:             break;
 572:         }
 573:     charc++;
 574:     return;
 575:     }
 576: strpt(s)
 577:   char *s; {
 578:     charc = 0;
 579:     while(*s){
 580:         allprint(*s++);
 581:         if(charc > LINESIZE){
 582:             charc = 0;
 583:             printf("\n\t");
 584:             }
 585:         }
 586:     return;
 587:     }
 588: sect1dump(){
 589:     register int i;
 590:     printf("Sect 1:\n");
 591:     if(def[0]){
 592:         printf("str	trans\n");
 593:         i = -1;
 594:         while(def[++i])
 595:             printf("%s\t%s\n",def[i],subs[i]);
 596:         }
 597:     if(sname[0]){
 598:         printf("start names\n");
 599:         i = -1;
 600:         while(sname[++i])
 601:             printf("%s\n",sname[i]);
 602:         }
 603:     if(chset == TRUE){
 604:         printf("char set changed\n");
 605:         for(i=1;i<NCH;i++){
 606:             if(i != ctable[i]){
 607:                 allprint(i);
 608:                 putchar(' ');
 609:                 printable(ctable[i]) ? putchar(ctable[i]) : printf("%d",ctable[i]);
 610:                 putchar('\n');
 611:                 }
 612:             }
 613:         }
 614:     }
 615: sect2dump(){
 616:     printf("Sect 2:\n");
 617:     treedump();
 618:     }
 619: treedump()
 620:     {
 621:     register int t;
 622:     register char *p;
 623:     printf("treedump %d nodes:\n",tptr);
 624:     for(t=0;t<tptr;t++){
 625:         printf("%4d ",t);
 626:         parent[t] ? printf("p=%4d",parent[t]) : printf("      ");
 627:         printf("  ");
 628:         if(name[t] < NCH) {
 629:                 allprint(name[t]);
 630:                 }
 631:         else switch(name[t]){
 632:             case RSTR:
 633:                 printf("%d ",left[t]);
 634:                 allprint(right[t]);
 635:                 break;
 636:             case RCCL:
 637:                 printf("ccl ");
 638:                 strpt(left[t]);
 639:                 break;
 640:             case RNCCL:
 641:                 printf("nccl ");
 642:                 strpt(left[t]);
 643:                 break;
 644:             case DIV:
 645:                 printf("/ %d %d",left[t],right[t]);
 646:                 break;
 647:             case BAR:
 648:                 printf("| %d %d",left[t],right[t]);
 649:                 break;
 650:             case RCAT:
 651:                 printf("cat %d %d",left[t],right[t]);
 652:                 break;
 653:             case PLUS:
 654:                 printf("+ %d",left[t]);
 655:                 break;
 656:             case STAR:
 657:                 printf("* %d",left[t]);
 658:                 break;
 659:             case CARAT:
 660:                 printf("^ %d",left[t]);
 661:                 break;
 662:             case QUEST:
 663:                 printf("? %d",left[t]);
 664:                 break;
 665:             case RNULLS:
 666:                 printf("nullstring");
 667:                 break;
 668:             case FINAL:
 669:                 printf("final %d",left[t]);
 670:                 break;
 671:             case S1FINAL:
 672:                 printf("s1final %d",left[t]);
 673:                 break;
 674:             case S2FINAL:
 675:                 printf("s2final %d",left[t]);
 676:                 break;
 677:             case RNEWE:
 678:                 printf("new %d %d",left[t],right[t]);
 679:                 break;
 680:             case RSCON:
 681:                 p = right[t];
 682:                 printf("start %s",sname[*p++-1]);
 683:                 while(*p)
 684:                     printf(", %s",sname[*p++-1]);
 685:                 printf(" %d",left[t]);
 686:                 break;
 687:             default:
 688:                 printf("unknown %d %d %d",name[t],left[t],right[t]);
 689:                 break;
 690:             }
 691:         if(nullstr[t])printf("\t(null poss.)");
 692:         putchar('\n');
 693:         }
 694:     }
 695: # endif

Defined functions

Defined variables