UNIX 6th Ed. - /usr/source/s1/cc.c

   1: #define SBSIZE  2000
   2: char    sbf[SBSIZE];
   3: /* C command */
   4: 
   5: char *tmp0;
   6: char *tmp1;
   7: char *tmp2;
   8: char *tmp3;
   9: char *tmp4;
  10: char *tmp5;
  11: char ts[1000];
  12: char *tsp ts;
  13: char *av[50];
  14: char *clist[50];
  15: char *llist[50];
  16: int instring;
  17: int pflag;
  18: int sflag;
  19: int cflag;
  20: int oflag;
  21: int proflag;
  22: int depth;
  23: int *ibuf;
  24: int *ibuf1;
  25: int *ibuf2;
  26: int *obuf;
  27: char *lp;
  28: char *line;
  29: int lineno;
  30: int exfail;
  31: struct symtab {
  32:     char name[8];
  33:     char *value;
  34: } *symtab;
  35: int symsiz 200;
  36: struct symtab *defloc;
  37: struct symtab *incloc;
  38: struct symtab *eifloc;
  39: struct symtab *ifdloc;
  40: struct symtab *ifnloc;
  41: struct symtab *unxloc;
  42: int trulvl;
  43: int flslvl;
  44: char *stringbuf;
  45: char *pass0 "/lib/c0";
  46: char *pass1 "/lib/c1";
  47: char *pass2 "/lib/c2";
  48: char *pref "/lib/crt0.o";
  49: 
  50: main(argc, argv)
  51: char *argv[]; {
  52:     char *t;
  53:     int nc, nl, i, j, c, f20, nxo;
  54:     int dexit();
  55: 
  56:     i = nc = nl = f20 = nxo = 0;
  57:     while(++i < argc) {
  58:         if(*argv[i] == '-')
  59:             switch (argv[i][1]) {
  60:                 default:
  61:                     goto passa;
  62:                 case 'S':
  63:                     sflag++;
  64:                     cflag++;
  65:                     break;
  66:                 case 'O':
  67:                     oflag++;
  68:                     break;
  69:                 case 'p':
  70:                     proflag++;
  71:                     pref = "/lib/mcrt0.o";
  72:                     break;
  73:                 case 'P':
  74:                     pflag++;
  75:                 case 'c':
  76:                     cflag++;
  77:                     break;
  78: 
  79:                 case 'f':
  80:                     pref = "/lib/fcrt0.o";
  81:                     pass0 = "/lib/fc0";
  82:                     pass1 = "/lib/fc1";
  83:                     break;
  84: 
  85:                 case '2':
  86:                     if(argv[i][2] == '\0')
  87:                         pref = "/lib/crt2.o";
  88:                     else {
  89:                         pref = "/lib/crt20.o";
  90:                         f20 = 1;
  91:                     }
  92:                     break;
  93:                 case 't':
  94:                     if (argv[i][2]=='0')
  95:                         pass0 = "/usr/c/c0";
  96:                     if (argv[i][2]=='1')
  97:                         pass1 = "/usr/c/c1";
  98:                     if (argv[i][2]=='2')
  99:                         pass2 = "/usr/c/c2";
 100:                     break;
 101:             }
 102:         else {
 103:         passa:
 104:             t = argv[i];
 105:             if(getsuf(t)=='c') {
 106:                 clist[nc++] = t;
 107:                 t = setsuf(t, 'o');
 108:             }
 109:             if (nodup(llist, t)) {
 110:                 llist[nl++] = t;
 111:                 if (getsuf(t)=='o')
 112:                     nxo++;
 113:             }
 114:         }
 115:     }
 116:     if(nc==0)
 117:         goto nocom;
 118:     if (pflag==0) {
 119:         tmp0 = copy("/tmp/ctm0a");
 120:         while((c=open(tmp0, 0))>=0) {
 121:             close(c);
 122:             tmp0[9]++;
 123:         }
 124:         while((creat(tmp0, 0400))<0)
 125:             tmp0[9]++;
 126:     }
 127:     if ((signal(2, 1) & 01) == 0)
 128:         signal(2, &dexit);
 129:     (tmp1 = copy(tmp0))[8] = '1';
 130:     (tmp2 = copy(tmp0))[8] = '2';
 131:     (tmp3 = copy(tmp0))[8] = '3';
 132:     if (oflag)
 133:         (tmp5 = copy(tmp0))[8] = '5';
 134:     if (pflag==0)
 135:         (tmp4 = copy(tmp0))[8] = '4';
 136:     for (i=0; i<nc; i++) {
 137:         if (nc>1)
 138:             printf("%s:\n", clist[i]);
 139:         av[0] = "c0";
 140:         if (pflag)
 141:             tmp4 = setsuf(clist[i], 'i');
 142:         av[1] = expand(clist[i]);
 143:         if (pflag || exfail)
 144:             continue;
 145:         if (av[1] == 0) {
 146:             cflag++;
 147:             continue;
 148:         }
 149:         av[2] = tmp1;
 150:         av[3] = tmp2;
 151:         if (proflag) {
 152:             av[4] = "-P";
 153:             av[5] = 0;
 154:         } else
 155:             av[4] = 0;
 156:         if (callsys(pass0, av)) {
 157:             cflag++;
 158:             continue;
 159:         }
 160:         av[0] = "c1";
 161:         av[1] = tmp1;
 162:         av[2] = tmp2;
 163:         if (sflag)
 164:             tmp3 = setsuf(clist[i], 's');
 165:         av[3] = tmp3;
 166:         if (oflag)
 167:             av[3] = tmp5;
 168:         av[4] = 0;
 169:         if(callsys(pass1, av)) {
 170:             cflag++;
 171:             continue;
 172:         }
 173:         if (oflag) {
 174:             av[0] = "c2";
 175:             av[1] = tmp5;
 176:             av[2] = tmp3;
 177:             av[3] = 0;
 178:             callsys(pass2, av);
 179:             unlink(tmp5);
 180:         }
 181:         if (sflag)
 182:             continue;
 183:         av[0] = "as";
 184:         av[1] = "-";
 185:         av[2] = tmp3;
 186:         av[3] = 0;
 187:         cunlink(tmp1);
 188:         cunlink(tmp2);
 189:         cunlink(tmp4);
 190:         callsys("/bin/as", av);
 191:         t = setsuf(clist[i], 'o');
 192:         cunlink(t);
 193:         if(link("a.out", t) || cunlink("a.out")) {
 194:             printf("move failed: %s\n", t);
 195:             cflag++;
 196:         }
 197:     }
 198: nocom:
 199:     if (cflag==0 && nl!=0) {
 200:         i = 0;
 201:         av[0] = "ld";
 202:         av[1] = "-X";
 203:         av[2] = pref;
 204:         j = 3;
 205:         while(i<nl)
 206:             av[j++] = llist[i++];
 207:         if(f20)
 208:             av[j++] = "-l2";
 209:         else {
 210:             av[j++] = "-lc";
 211:             av[j++] = "-l";
 212:         }
 213:         av[j++] = 0;
 214:         callsys("/bin/ld", av);
 215:         if (nc==1 && nxo==1)
 216:             cunlink(setsuf(clist[0], 'o'));
 217:     }
 218:     dexit();
 219: }
 220: 
 221: dexit()
 222: {
 223:     if (!pflag) {
 224:         cunlink(tmp1);
 225:         cunlink(tmp2);
 226:         if (sflag==0)
 227:             cunlink(tmp3);
 228:         cunlink(tmp4);
 229:         cunlink(tmp5);
 230:         cunlink(tmp0);
 231:     }
 232:     exit();
 233: }
 234: 
 235: expand(file)
 236: char *file;
 237: {
 238:     int ib1[259], ib2[259], ob[259];
 239:     struct symtab stab[200];
 240:     char ln[196];
 241:     register int c;
 242:     register char *rlp;
 243: 
 244:     exfail = 0;
 245:     ibuf = ibuf1 = ib1;
 246:     ibuf2 = ib2;
 247:     if (fopen(file, ibuf1)<0)
 248:         return(file);
 249:     if (getc(ibuf1) != '#') {
 250:         close(ibuf1[0]);
 251:         return(file);
 252:     }
 253:     ibuf1[1]++;
 254:     ibuf1[2]--;
 255:     obuf = ob;
 256:     symtab = stab;
 257:     for (c=0; c<200; c++) {
 258:         stab[c].name[0] = '\0';
 259:         stab[c].value = 0;
 260:     }
 261:     insym(&defloc, "define");
 262:     insym(&incloc, "include");
 263:     insym(&eifloc, "endif");
 264:     insym(&ifdloc, "ifdef");
 265:     insym(&ifnloc, "ifndef");
 266:     insym(&unxloc, "unix");
 267:     stringbuf = sbf;
 268:     trulvl = 0;
 269:     flslvl = 0;
 270:     line  = ln;
 271:     lineno = 0;
 272:     if (fcreat(tmp4, obuf) < 0) {
 273:         printf("Can't creat %s\n", tmp4);
 274:         dexit();
 275:     }
 276:     while(getline()) {
 277:         if (ibuf==ibuf2 && pflag==0)
 278:             putc(001, obuf);    /*SOH: insert */
 279:         if (ln[0] != '#' && flslvl==0)
 280:             for (rlp = line; c = *rlp++;)
 281:                 putc(c, obuf);
 282:         putc('\n', obuf);
 283:     }
 284:     for(rlp=line; c = *rlp++;)
 285:             putc(c,obuf);
 286:     fflush(obuf);
 287:     close(obuf[0]);
 288:     close(ibuf1[0]);
 289:     return(tmp4);
 290: }
 291: 
 292: getline()
 293: {
 294:     register int c, sc, state;
 295:     struct symtab *np;
 296:     char *namep, *filname;
 297: 
 298:     if (ibuf==ibuf1)
 299:         lineno++;
 300:     lp = line;
 301:     *lp = '\0';
 302:     state = 0;
 303:     if ((c=getch()) == '#')
 304:         state = 1;
 305:     while (c!='\n' && c!='\0') {
 306:         if ('a'<=c && c<='z' || 'A'<=c && c<='Z' || c=='_') {
 307:             namep = lp;
 308:             sch(c);
 309:             while ('a'<=(c=getch()) && c<='z'
 310:                   ||'A'<=c && c<='Z'
 311:                   ||'0'<=c && c<='9'
 312:                   ||c=='_')
 313:                 sch(c);
 314:             sch('\0');
 315:             lp--;
 316:             if (state>3) {
 317:                 if (flslvl==0 &&(state+!lookup(namep,-1)->name[0])==5)
 318:                     trulvl++;
 319:                 else
 320:                     flslvl++;
 321:         out:
 322:                 while (c!='\n' && c!= '\0')
 323:                     c = getch();
 324:                 return(c);
 325:             }
 326:             if (state!=2 || flslvl==0)
 327:                 {
 328:                 ungetc(c);
 329:                 np = lookup(namep, state);
 330:                 c = getch();
 331:                 }
 332:             if (state==1) {
 333:                 if (np==defloc)
 334:                     state = 2;
 335:                 else if (np==incloc)
 336:                     state = 3;
 337:                 else if (np==ifnloc)
 338:                     state = 4;
 339:                 else if (np==ifdloc)
 340:                     state = 5;
 341:                 else if (np==eifloc) {
 342:                     if (flslvl)
 343:                         --flslvl;
 344:                     else if (trulvl)
 345:                         --trulvl;
 346:                     else error("If-less endif");
 347:                     goto out;
 348:                 }
 349:                 else {
 350:                     error("Undefined control");
 351:                     while (c!='\n' && c!='\0')
 352:                         c = getch();
 353:                     return(c);
 354:                 }
 355:             } else if (state==2) {
 356:                 if (flslvl)
 357:                     goto out;
 358:                 np->value = stringbuf;
 359:                 savch(c);
 360:                 while ((c=getch())!='\n' && c!='\0')
 361:                     savch(c);
 362:                 savch('\0');
 363:                 return(1);
 364:             }
 365:             continue;
 366:         } else if ((sc=c)=='\'' || sc=='"') {
 367:             sch(sc);
 368:             filname = lp;
 369:             instring++;
 370:             while ((c=getch())!=sc && c!='\n' && c!='\0') {
 371:                 sch(c);
 372:                 if (c=='\\')
 373:                     sch(getch());
 374:             }
 375:             instring = 0;
 376:             if (flslvl)
 377:                 goto out;
 378:             if (state==3) {
 379:                 if (flslvl)
 380:                     goto out;
 381:                 *lp = '\0';
 382:                 while ((c=getch())!='\n' && c!='\0');
 383:                 if (ibuf==ibuf2)
 384:                     error("Nested 'include'");
 385:                 if (fopen(filname, ibuf2)<0)
 386:                     error("Missing file %s", filname);
 387:                 else
 388:                     ibuf = ibuf2;
 389:                 return(c);
 390:             }
 391:         }
 392:         sch(c);
 393:         c = getch();
 394:     }
 395:     sch('\0');
 396:     if (state>1)
 397:         error("Control syntax");
 398:     return(c);
 399: }
 400: 
 401: insym(sp, namep)
 402: struct symtab **sp;
 403: char *namep;
 404: {
 405:     register struct symtab *np;
 406: 
 407:     *sp = np = lookup(namep, 1);
 408:     np->value = np->name;
 409: }
 410: 
 411: error(s, x)
 412: {
 413:     printf("%d: ", lineno);
 414:     printf(s, x);
 415:     putchar('\n');
 416:     exfail++;
 417:     cflag++;
 418: }
 419: 
 420: sch(c)
 421: {
 422:     register char *rlp;
 423: 
 424:     rlp = lp;
 425:     if (rlp==line+194)
 426:         error("Line overflow");
 427:     *rlp++ = c;
 428:     if (rlp>line+195)
 429:         rlp = line+195;
 430:     lp = rlp;
 431: }
 432: 
 433: savch(c)
 434: {
 435:     *stringbuf++ = c;
 436:     if (stringbuf-sbf < SBSIZE)
 437:         return;
 438:     error("Too much defining");
 439:     dexit();
 440: }
 441: 
 442: getch()
 443: {
 444:     register int c;
 445: 
 446: loop:
 447:     if ((c=getc1())=='/' && !instring) {
 448:         if ((c=getc1())!='*')
 449:             {
 450:             ungetc(c);
 451:             return('/');
 452:             }
 453:         for(;;) {
 454:             c = getc1();
 455:         cloop:
 456:             switch (c) {
 457: 
 458:             case '\0':
 459:                 return('\0');
 460: 
 461:             case '*':
 462:                 if ((c=getc1())=='/')
 463:                     goto loop;
 464:                 goto cloop;
 465: 
 466:             case '\n':
 467:                 if (ibuf==ibuf1) {
 468:                     putc('\n', obuf);
 469:                     lineno++;
 470:                 }
 471:                 continue;
 472:             }
 473:         }
 474:     }
 475:     return(c);
 476: }
 477: char pushbuff[300];
 478: char *pushp pushbuff;
 479: ungetc(c)
 480:     {
 481:     *++pushp = c;
 482:     }
 483: 
 484: getc1()
 485: {
 486:     register c;
 487: 
 488:     if (*pushp !=0)
 489:         return(*pushp--);
 490:     depth=0;
 491:     if ((c = getc(ibuf)) < 0 && ibuf==ibuf2) {
 492:         close(ibuf2[0]);
 493:         ibuf = ibuf1;
 494:         putc('\n', obuf);
 495:         lineno++;
 496:         c = getc1();
 497:     }
 498:     if (c<0)
 499:         return(0);
 500:     return(c);
 501: }
 502: 
 503: lookup(namep, enterf)
 504: char *namep;
 505: {
 506:     register char *np, *snp;
 507:     register struct symtab *sp;
 508:     int i, c, around;
 509:     np = namep;
 510:     around = i = 0;
 511:     while (c = *np++)
 512:         i =+ c;
 513:     i =% symsiz;
 514:     sp = &symtab[i];
 515:     while (sp->name[0]) {
 516:         snp = sp;
 517:         np = namep;
 518:         while (*snp++ == *np)
 519:             if (*np++ == '\0' || np==namep+8) {
 520:                 if (!enterf)
 521:                     subst(namep, sp);
 522:                 return(sp);
 523:             }
 524:         if (++sp >= &symtab[symsiz])
 525:             if (around++)
 526:                 {
 527:                 error("too many defines");
 528:                 dexit();
 529:                 }
 530:             else
 531:             sp = symtab;
 532:     }
 533:     if (enterf>0) {
 534:         snp = namep;
 535:         for (np = &sp->name[0]; np < &sp->name[8];)
 536:             if (*np++ = *snp)
 537:                 snp++;
 538:     }
 539:     return(sp);
 540: }
 541: char revbuff[200];
 542: char    *bp;
 543: backsch(c)
 544:     {
 545:     if (bp-revbuff > 200)
 546:         error("Excessive define looping", bp--);
 547:     *bp++ = c;
 548:     }
 549: 
 550: subst(np, sp)
 551: char *np;
 552: struct symtab *sp;
 553: {
 554:     register char *vp;
 555: 
 556:     lp = np;
 557:     bp = revbuff;
 558:     if (depth++>100)
 559:         {
 560:         error("define recursion loop\n");
 561:         return;
 562:         }
 563:     if ((vp = sp->value) == 0)
 564:         return;
 565:     /* arrange that define unix unix still
 566: 	has no effect, avoiding rescanning */
 567:     if (streq(sp->name,sp->value))
 568:         {
 569:         while (*vp)
 570:             sch(*vp++);
 571:         return;
 572:         }
 573:     backsch(' ');
 574:     if (*vp == '(')
 575:         expdef(vp);
 576:     else
 577:     while (*vp)
 578:         backsch(*vp++);
 579:     backsch(' ');
 580:     while (bp>revbuff)
 581:         ungetc(*--bp);
 582: }
 583: 
 584: getsuf(as)
 585: char as[];
 586: {
 587:     register int c;
 588:     register char *s;
 589:     register int t;
 590: 
 591:     s = as;
 592:     c = 0;
 593:     while(t = *s++)
 594:         if (t=='/')
 595:             c = 0;
 596:         else
 597:             c++;
 598:     s =- 3;
 599:     if (c<=14 && c>2 && *s++=='.')
 600:         return(*s);
 601:     return(0);
 602: }
 603: 
 604: setsuf(as, ch)
 605: char as[];
 606: {
 607:     register char *s, *s1;
 608: 
 609:     s = s1 = copy(as);
 610:     while(*s)
 611:         if (*s++ == '/')
 612:             s1 = s;
 613:     s[-1] = ch;
 614:     return(s1);
 615: }
 616: 
 617: callsys(f, v)
 618: char f[], *v[]; {
 619:     int t, status;
 620: 
 621:     if ((t=fork())==0) {
 622:         execv(f, v);
 623:         printf("Can't find %s\n", f);
 624:         exit(1);
 625:     } else
 626:         if (t == -1) {
 627:             printf("Try again\n");
 628:             return(1);
 629:         }
 630:     while(t!=wait(&status));
 631:     if ((t=(status&0377)) != 0 && t!=14) {
 632:         if (t!=2)       /* interrupt */
 633:             printf("Fatal error in %s\n", f);
 634:         dexit();
 635:     }
 636:     return((status>>8) & 0377);
 637: }
 638: 
 639: copy(as)
 640: char as[];
 641: {
 642:     register char *otsp, *s;
 643: 
 644:     otsp = tsp;
 645:     s = as;
 646:     while(*tsp++ = *s++);
 647:     return(otsp);
 648: }
 649: 
 650: nodup(l, os)
 651: char **l, *os;
 652: {
 653:     register char *t, *s;
 654:     register int c;
 655: 
 656:     s = os;
 657:     if (getsuf(s) != 'o')
 658:         return(1);
 659:     while(t = *l++) {
 660:         while(c = *s++)
 661:             if (c != *t++)
 662:                 break;
 663:         if (*t=='\0' && c=='\0')
 664:             return(0);
 665:         s = os;
 666:     }
 667:     return(1);
 668: }
 669: 
 670: cunlink(f)
 671: char *f;
 672: {
 673:     if (f==0)
 674:         return(0);
 675:     return(unlink(f));
 676: }
 677: expdef(proto)
 678:   char *proto;
 679: {
 680: char buffer[100], *parg[20], *pval[20], name[20], *cspace, *wp;
 681: char protcop[100], *pr;
 682: int narg, k, i, c;
 683: pr = protcop;
 684: while (*pr++ = *proto++);
 685: proto= protcop;
 686: for (narg=0; (parg[narg] = token(&proto)) != 0; narg++)
 687:     ;
 688: /* now scan input */
 689: cspace = buffer;
 690: while ((c=getch()) == ' ');
 691: if (c != '(')
 692:     {
 693:     error("defined function requires arguments");
 694:     return;
 695:     }
 696: ungetc(c);
 697: for(k=0; pval[k] = coptok(&cspace); k++);
 698: if (k!=narg)
 699:  {
 700:   error("define argument mismatch");
 701:   return;
 702:  }
 703: while (c= *proto++)
 704:    {
 705:    if (!letter(c))
 706:       backsch(c);
 707:    else
 708:       {
 709:       wp = name;
 710:       *wp++ = c;
 711:       while (letnum(*proto))
 712:         *wp++ = *proto++;
 713:       *wp = 0;
 714:       for (k=0; k<narg; k++)
 715:       if(streq(name,parg[k]))
 716:         break;
 717:       wp = k <narg ? pval[k] : name;
 718:       while (*wp) backsch(*wp++);
 719:       }
 720:    }
 721: }
 722: token(cpp) char **cpp;
 723: {
 724: char *val;
 725: int stc;
 726: stc = **cpp;
 727: *(*cpp)++ = '\0';
 728: if (stc==')') return(0);
 729: while (**cpp == ' ') (*cpp)++;
 730: for (val = *cpp; (stc= **cpp) != ',' && stc!= ')'; (*cpp)++)
 731:   {
 732:   if (!letnum(stc) || (val == *cpp && !letter(stc)))
 733:     {
 734:     error("define prototype argument error");
 735:     break;
 736:     }
 737:   }
 738: return(val);
 739: }
 740: coptok (cpp) char **cpp; {
 741: char *val;
 742: int stc, stop,paren;
 743: paren = 0;
 744: val = *cpp;
 745: if (getch() == ')')
 746:   return(0);
 747: while (((stc = getch()) != ',' && stc != ')') || paren > 0)
 748:   {
 749:   if (stc == '"' || stc == '\'')
 750:     {
 751:     stop = stc;
 752:     if (stop == '\'')
 753:       *(*cpp)++ = '\'';
 754:     while ( (stc = getch()) != stop)
 755:       {
 756:       if (stc == '\n')
 757:         {
 758:         error ("non-terminated string");
 759:         break;
 760:         }
 761:       if (stc == '\\')
 762:         if ((stc= getch()) != stop && stc != '\\')
 763:           *(*cpp)++ = '\\';
 764:       *(*cpp)++ = stc;
 765:       }
 766:     if (stop == '\'')
 767:       *(*cpp)++ = '\'';
 768:     }
 769:   else if (stc == '\\')
 770:       {
 771:       stc = getch();
 772:       if (stc != '"' && stc != '\\')
 773:         *(*cpp)++ = '\\';
 774:       *(*cpp)++ = stc;
 775:       }
 776:   else
 777:     {
 778:     *(*cpp)++ = stc;
 779:     if (stc == '(')
 780:         paren++;
 781:     if (stc == ')')
 782:         paren--;
 783:     }
 784:   }
 785: *(*cpp)++ = 0;
 786: ungetc(stc);
 787: return(val);
 788: }
 789: letter(c)
 790: {
 791: if ((c >= 'a' && c <= 'z') ||
 792:     (c >= 'A' && c <= 'Z') ||
 793:     (c == '_'))
 794:     return (1);
 795: else
 796:     return(0);
 797: }
 798: letnum(c)
 799: {
 800: if (letter(c) || (c >= '0' && c <= '9'))
 801:   return(1);
 802: else
 803:   return(0);
 804: }
 805: streq(s,t) char *s, *t;
 806: {
 807: int c;
 808: while ( (c= *s++) == *t++)
 809:    if (c==0) return(1);
 810: return(0);
 811: }

Defined functions

Defined variables

Defined struct's

Defined macros