Return to 3cc.c CVS log

Up to [Research Unix] / researchv9 / jerq / sgs

Annotation of researchv9/jerq/sgs/3cc.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * cc - front end for C compiler
        !             3:  */
        !             4: #include <sys/types.h>
        !             5: #include <stdio.h>
        !             6: #include <ctype.h>
        !             7: #include <signal.h>
        !             8: #include <dir.h>
        !             9: 
        !            10: char   *cpp = "/lib/cpp";
        !            11: char   *ccom = "/usr/jerq/lib/m32/comp";
        !            12: char   *as = "/usr/jerq/bin/3as";
        !            13: char   *c2 = "/usr/jerq/lib/m32/optim";
        !            14: char   *ld = "/usr/jerq/bin/3ld";
        !            15: char   *ifile = "/usr/jerq/lib/muxmap";
        !            16: 
        !            17: char   tmp0[30];               /* big enough for /tmp/ctm%05.5d */
        !            18: char   *tmp1, *tmp2, *tmp3, *tmp4, *tmp5;
        !            19: char   *outfile;
        !            20: char   *savestr(), *strspl(), *setsuf();
        !            21: int    idexit();
        !            22: char   **av, **clist, **llist, **plist;
        !            23: int    cflag, eflag, gflag, pflag, sflag, Rflag, exflag, proflag, oflag;
        !            24: int    dont, jflag, mflag=1;   /* default is to compile for mux(9) */
        !            25: int    exfail;
        !            26: char   *chpass;
        !            27: char   *npassname;
        !            28: extern int     optind;
        !            29: extern int     opterr;
        !            30: extern char    *optarg;
        !            31: extern int     optopt;
        !            32: 
        !            33: int    nc, nl, np, nxo, na;
        !            34: 
        !            35: #define        cunlink(x)      if (x) unlink(x)
        !            36: 
        !            37: main(argc, argv)
        !            38:        char **argv;
        !            39: {
        !            40:        char *t;
        !            41:        char *assource;
        !            42:        int i, j, c;
        !            43: 
        !            44:        /* ld currently adds upto 5 args; 10 is room to spare */
        !            45:        /* I upped it anyway -- rob */
        !            46:        av = (char **)calloc(argc+20, sizeof (char **));
        !            47:        clist = (char **)calloc(argc+20, sizeof (char **));
        !            48:        llist = (char **)calloc(argc+20, sizeof (char **));
        !            49:        plist = (char **)calloc(argc+20, sizeof (char **));
        !            50:        opterr = 0;
        !            51:        while (optind<argc) switch (c = getopt(argc, argv, "dJmSo:ROPgEPcD:I:U:C:t:B:l:")) {
        !            52:        case 'd':
        !            53:                dont++;
        !            54:                continue;
        !            55:        case 'S':
        !            56:                sflag++;
        !            57:                cflag++;
        !            58:                continue;
        !            59:        case 'J':
        !            60:                jflag++;
        !            61:        case 'm':
        !            62:                mflag=0;
        !            63:                ifile = "/usr/jerq/lib/jxmap";
        !            64:                continue;
        !            65:        case 'l':
        !            66:                llist[nl++] = strspl("-l", optarg);
        !            67:                continue;
        !            68:        case 'o':
        !            69:                outfile = optarg;
        !            70:                switch (getsuf(outfile)) {
        !            71: 
        !            72:                case 'c':
        !            73:                case 'o':
        !            74:                        error("-o would overwrite %s", outfile);
        !            75:                        exit(8);
        !            76:                }
        !            77:                continue;
        !            78:        case 'R':
        !            79:                Rflag++;
        !            80:                continue;
        !            81:        case 'O':
        !            82:                oflag++;
        !            83:                continue;
        !            84:        case 'p':
        !            85:                proflag++;
        !            86:                continue;
        !            87:        case 'g':
        !            88:                gflag++;
        !            89:                continue;
        !            90:        case 'E':
        !            91:                exflag++;
        !            92:                cflag++;
        !            93:                continue;
        !            94:        case 'P':
        !            95:                pflag++;
        !            96:        case 'c':
        !            97:                cflag++;
        !            98:                continue;
        !            99:        case 'D':
        !           100:        case 'I':
        !           101:        case 'U':
        !           102:        case 'C':
        !           103:                plist[np] = strspl("-X", optarg);
        !           104:                plist[np++][1] = c;
        !           105:                continue;
        !           106:        case 't':
        !           107:                if (chpass)
        !           108:                        error("-t overwrites earlier option", 0);
        !           109:                chpass = optarg;
        !           110:                if (chpass[0]==0)
        !           111:                        chpass = "012p";
        !           112:                continue;
        !           113:        case 'B':
        !           114:                if (npassname)
        !           115:                        error("-B overwrites earlier option", 0);
        !           116:                npassname = optarg;
        !           117:                if (npassname[0]==0)
        !           118:                        npassname = "/usr/scj/mcc";
        !           119:                continue;
        !           120:        case '?':
        !           121:                t = strspl("-", "x");
        !           122:                t[1] = optopt;
        !           123:                llist[nl++] = t;
        !           124:                continue;
        !           125: 
        !           126:        case EOF:
        !           127:                t = argv[optind];
        !           128:                optind++;
        !           129:                c = getsuf(t);
        !           130:                if (c=='c' || c=='s' || c=='i' || exflag) {
        !           131:                        clist[nc++] = t;
        !           132:                        t = setsuf(t, 'o');
        !           133:                }
        !           134:                if (nodup(llist, t)) {
        !           135:                        llist[nl++] = t;
        !           136:                        if (getsuf(t)=='o')
        !           137:                                nxo++;
        !           138:                }
        !           139:        }
        !           140:        if (npassname && chpass ==0)
        !           141:                chpass = "012p";
        !           142:        if (chpass && npassname==0)
        !           143:                npassname = "/usr/new";
        !           144:        if (chpass)
        !           145:        for (t=chpass; *t; t++) {
        !           146:                switch (*t) {
        !           147: 
        !           148:                case '0':
        !           149:                        ccom = strspl(npassname, "comp");
        !           150:                        continue;
        !           151:                case '2':
        !           152:                        c2 = strspl(npassname, "optim");
        !           153:                        continue;
        !           154:                case 'p':
        !           155:                        cpp = strspl(npassname, "cpp");
        !           156:                        continue;
        !           157:                }
        !           158:        }
        !           159:        if (proflag)
        !           160:                printf("3cc: no profiling option\n");
        !           161:        if (nc==0)
        !           162:                goto nocom;
        !           163:        if (signal(SIGINT, SIG_IGN) != SIG_IGN)
        !           164:                signal(SIGINT, idexit);
        !           165:        if (signal(SIGTERM, SIG_IGN) != SIG_IGN)
        !           166:                signal(SIGTERM, idexit);
        !           167:        if (pflag==0)
        !           168:                sprintf(tmp0, "/tmp/ctm%05.5d", getpid());
        !           169:        tmp1 = strspl(tmp0, "1");
        !           170:        tmp2 = strspl(tmp0, "2");
        !           171:        tmp3 = strspl(tmp0, "3");
        !           172:        if (pflag==0)
        !           173:                tmp4 = strspl(tmp0, "4");
        !           174:        if (oflag)
        !           175:                tmp5 = strspl(tmp0, "5");
        !           176:        for (i=0; i<nc; i++) {
        !           177:                int suffix = getsuf(clist[i]);
        !           178:                if (nc > 1) {
        !           179:                        printf("%s:\n", clist[i]);
        !           180:                        fflush(stdout);
        !           181:                }
        !           182:                if (suffix == 's') {
        !           183:                        assource = clist[i];
        !           184:                        goto assemble;
        !           185:                } else
        !           186:                        assource = tmp3;
        !           187:                if (suffix == 'i')
        !           188:                        goto compile;
        !           189:                if (pflag)
        !           190:                        tmp4 = setsuf(clist[i], 'i');
        !           191:                na=0;
        !           192:                av[na++] = "cpp";
        !           193:                av[na++] = "-Uvax";
        !           194:                av[na++] = "-Usun";
        !           195:                av[na++] = "-Usun2";
        !           196:                av[na++] = "-Usun3";
        !           197:                av[na++] = "-Umc68000";
        !           198:                av[na++] = "-Umc68010";
        !           199:                av[na++] = "-Umc68020";
        !           200:                av[na++] = "-Dm32";
        !           201:                if(mflag)
        !           202:                        av[na++] = "-DMUX";
        !           203:                for (j = 0; j < np; j++)
        !           204:                        av[na++] = plist[j];
        !           205:                av[na++] = "-I/usr/jerq/include";
        !           206:                av[na++] = clist[i];
        !           207:                av[na++] = exflag ? "-" : tmp4;
        !           208:                av[na++] = 0;
        !           209:                switch(callsys(cpp, av)){
        !           210:                case 0:
        !           211:                        break;
        !           212: #define        CLASS 27
        !           213:                case CLASS:
        !           214:                        if(callsys("/lib/cpre", av)==0)
        !           215:                                break;
        !           216:                        /* fall through */
        !           217:                default:
        !           218:                        exfail++;
        !           219:                        eflag++;
        !           220:                }
        !           221:                if (pflag || exfail) {
        !           222:                        cflag++;
        !           223:                        continue;
        !           224:                }
        !           225: compile:
        !           226:                if (sflag)
        !           227:                        assource = tmp3 = setsuf(clist[i], 's');
        !           228:                av[0] = "3comp";
        !           229:                av[1] = "-i";
        !           230:                av[2] = suffix=='i'? clist[i]: tmp4;
        !           231:                av[3] = "-o";
        !           232:                av[4] = oflag? tmp5 : tmp3;
        !           233:                av[5] = "-f";
        !           234:                av[6] = clist[i];
        !           235:                if(gflag)
        !           236:                        na = 7;
        !           237:                else{
        !           238:                        av[7] = "-ds";
        !           239:                        av[8] = "-dl";
        !           240:                        na = 9;
        !           241:                }
        !           242:                av[na] = 0;
        !           243:                if (callsys(ccom, av)) {
        !           244:                        cflag++;
        !           245:                        eflag++;
        !           246:                        continue;
        !           247:                }
        !           248:                if (oflag) {
        !           249:                        av[0] = "3optim";
        !           250:                        av[1] = "-I";
        !           251:                        av[2] = tmp5;
        !           252:                        av[3] = "-O";
        !           253:                        av[4] = tmp3;
        !           254:                        av[5] = 0;
        !           255:                        if (callsys(c2, av)) {
        !           256:                                unlink(tmp3);
        !           257:                                tmp3 = assource = tmp5;
        !           258:                        } else
        !           259:                                unlink(tmp5);
        !           260:                }
        !           261:                if (sflag)
        !           262:                        continue;
        !           263:        assemble:
        !           264:                cunlink(tmp1); cunlink(tmp2); cunlink(tmp4);
        !           265:                av[0] = "3as";
        !           266:                na = 1;
        !           267:                if(!gflag)
        !           268:                        av[na++] = "-dl";
        !           269:                av[na++] = "-o"; av[na++] = setsuf(clist[i], 'o');
        !           270:                if (Rflag)
        !           271:                        av[na++] = "-R";
        !           272:                av[na++] = assource;
        !           273:                av[na] = 0;
        !           274:                if (callsys(as, av) > 1) {
        !           275:                        cflag++;
        !           276:                        eflag++;
        !           277:                        continue;
        !           278:                }
        !           279:        }
        !           280: nocom:
        !           281:        if (cflag==0 && nl!=0) {
        !           282:                i = 0;
        !           283:                av[0] = "3ld"; na=1;
        !           284:                av[na++] = "-o";
        !           285:                av[na++] = outfile? outfile : "a.out";
        !           286:                av[na++] = "-L/usr/jerq/lib";
        !           287:                if (jflag)
        !           288:                        av[na++] = "/usr/jerq/lib/rom.o";
        !           289:                av[na++] = ifile;
        !           290:                while (i < nl)
        !           291:                        av[na++] = llist[i++];
        !           292:                if(mflag){
        !           293:                        av[na++] = "-r";
        !           294:                        av[na++] = "-a";
        !           295:                }
        !           296:                if(mflag)
        !           297:                        av[na++] = "-lmj";
        !           298:                if(jflag){
        !           299:                        av[na++] = "-lj";
        !           300:                        av[na++] = "-lsys";
        !           301:                }
        !           302:                av[na++] = "-lj";
        !           303:                av[na++] = "-lc";
        !           304:                av[na++] = 0;
        !           305:                eflag |= callsys(ld, av);
        !           306:                if (nc==1 && nxo==1 && eflag==0)
        !           307:                        unlink(setsuf(clist[0], 'o'));
        !           308:                if(!eflag && mflag){
        !           309:                        int f=open(outfile? outfile : "a.out", 1);
        !           310:                        short m=0x5620;
        !           311:                        if(f==-1 || lseek(f, 22, 0)==-1 || write(f, &m, 2)!=2)
        !           312:                                error("can't write magic number in %s",
        !           313:                                        outfile? outfile : "a.out");
        !           314:                        else
        !           315:                                close(f);
        !           316:                }
        !           317:        }
        !           318:        dexit();
        !           319: }
        !           320: 
        !           321: idexit()
        !           322: {
        !           323: 
        !           324:        eflag = 100;
        !           325:        dexit();
        !           326: }
        !           327: 
        !           328: dexit()
        !           329: {
        !           330: 
        !           331:        if (!pflag) {
        !           332:                cunlink(tmp1);
        !           333:                cunlink(tmp2);
        !           334:                if (sflag==0)
        !           335:                        cunlink(tmp3);
        !           336:                cunlink(tmp4);
        !           337:                cunlink(tmp5);
        !           338:        }
        !           339:        exit(eflag);
        !           340: }
        !           341: 
        !           342: error(s, x)
        !           343:        char *s, *x;
        !           344: {
        !           345:        FILE *diag = exflag ? stderr : stdout;
        !           346: 
        !           347:        fprintf(diag, "3cc: ");
        !           348:        fprintf(diag, s, x);
        !           349:        putc('\n', diag);
        !           350:        exfail++;
        !           351:        cflag++;
        !           352:        eflag++;
        !           353: }
        !           354: 
        !           355: getsuf(as)
        !           356: char as[];
        !           357: {
        !           358:        register int c;
        !           359:        register char *s;
        !           360:        register int t;
        !           361: 
        !           362:        s = as;
        !           363:        c = 0;
        !           364:        while (t = *s++)
        !           365:                if (t=='/')
        !           366:                        c = 0;
        !           367:                else
        !           368:                        c++;
        !           369:        s -= 3;
        !           370:        if (c <= DIRSIZ && c > 2 && *s++ == '.')
        !           371:                return (*s);
        !           372:        return (0);
        !           373: }
        !           374: 
        !           375: char *
        !           376: setsuf(as, ch)
        !           377:        char *as;
        !           378: {
        !           379:        register char *s, *s1;
        !           380: 
        !           381:        s = s1 = savestr(as);
        !           382:        while (*s)
        !           383:                if (*s++ == '/')
        !           384:                        s1 = s;
        !           385:        s[-1] = ch;
        !           386:        return (s1);
        !           387: }
        !           388: 
        !           389: callsys(f, v)
        !           390:        char *f, **v;
        !           391: {
        !           392:        int t, status;
        !           393: 
        !           394:        if(dont){
        !           395:                printf("3cc: (%s)", f);
        !           396:                while(*v)
        !           397:                        printf(" %s", *v++);
        !           398:                printf("\n");
        !           399:                return 0;
        !           400:        }
        !           401:        t = fork();
        !           402:        if (t == -1) {
        !           403:                printf("No more processes\n");
        !           404:                return (100);
        !           405:        }
        !           406:        if (t == 0) {
        !           407:                execv(f, v);
        !           408:                printf("Can't find %s\n", f);
        !           409:                fflush(stdout);
        !           410:                _exit(100);
        !           411:        }
        !           412:        while (t != wait(&status))
        !           413:                ;
        !           414:        if ((t=(status&0377)) != 0 && t!=14) {
        !           415:                if (t!=2) {
        !           416:                        printf("Fatal error in %s\n", f);
        !           417:                        eflag = 8;
        !           418:                }
        !           419:                dexit();
        !           420:        }
        !           421:        return ((status>>8) & 0377);
        !           422: }
        !           423: 
        !           424: nodup(l, os)
        !           425:        char **l, *os;
        !           426: {
        !           427:        register char *t, *s;
        !           428:        register int c;
        !           429: 
        !           430:        s = os;
        !           431:        if (getsuf(s) != 'o')
        !           432:                return (1);
        !           433:        while (t = *l++) {
        !           434:                while (c = *s++)
        !           435:                        if (c != *t++)
        !           436:                                break;
        !           437:                if (*t==0 && c==0)
        !           438:                        return (0);
        !           439:                s = os;
        !           440:        }
        !           441:        return (1);
        !           442: }
        !           443: 
        !           444: #define        NSAVETAB        1024
        !           445: char   *savetab;
        !           446: int    saveleft;
        !           447: 
        !           448: char *
        !           449: savestr(cp)
        !           450:        register char *cp;
        !           451: {
        !           452:        register int len;
        !           453: 
        !           454:        len = strlen(cp) + 1;
        !           455:        if (len > saveleft) {
        !           456:                saveleft = NSAVETAB;
        !           457:                if (len > saveleft)
        !           458:                        saveleft = len;
        !           459:                savetab = (char *)malloc(saveleft);
        !           460:                if (savetab == 0) {
        !           461:                        fprintf(stderr, "ran out of memory (savestr)\n");
        !           462:                        exit(1);
        !           463:                }
        !           464:        }
        !           465:        strncpy(savetab, cp, len);
        !           466:        cp = savetab;
        !           467:        savetab += len;
        !           468:        saveleft -= len;
        !           469:        return (cp);
        !           470: }
        !           471: 
        !           472: char *
        !           473: strspl(left, right)
        !           474:        char *left, *right;
        !           475: {
        !           476:        char buf[BUFSIZ];
        !           477: 
        !           478:        strcpy(buf, left);
        !           479:        strcat(buf, right);
        !           480:        return (savestr(buf));
        !           481: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.