Return to 11cc.c CVS log

Up to [Research Unix] / researchv10no / cmd / PDP11

Annotation of researchv10no/cmd/PDP11/11cc.c, revision 1.1

1.1     ! root        1: # include <stdio.h>
        !             2: # include <ctype.h>
        !             3: # include <signal.h>
        !             4: 
        !             5: # include "11cc.h"             /* god: has all the local pathnames */
        !             6: 
        !             7: /* 11cc command */
        !             8: 
        !             9: # define MAXINC 10
        !            10: # define MAXFIL 100
        !            11: # define MAXLIB 100
        !            12: # define MAXOPT 100
        !            13: char   *tmp0;
        !            14: char   *tmp1;
        !            15: char   *tmp2;
        !            16: char   *tmp3;
        !            17: char   *tmp4;
        !            18: char   *tmp5;
        !            19: char   *tmp6, *tmp7;   /* mjm */
        !            20: char   *outfile;
        !            21: char   *av[50];
        !            22: char   *clist[MAXFIL];
        !            23: char   *llist[MAXLIB];
        !            24: int    pflag;
        !            25: int    sflag;
        !            26: int    cflag;
        !            27: int    eflag;
        !            28: int    exflag;
        !            29: int    oflag;
        !            30: int    Fflag;  /* mjm: RH fpp */
        !            31: int    vflag;  /* mjm: verbose */
        !            32: int    proflag;
        !            33: int    noflflag;
        !            34: int    zflag;          /* request zero-extension on all chars */
        !            35: char   *chpass ;
        !            36: char   *npassname ;
        !            37: char   pass0[50] = LIBPATH(11c0);              /*god*/
        !            38: char   pass1[50] = LIBPATH(11c1);              /*god*/
        !            39: char   pass2[50] = LIBPATH(11c2);              /*god*/
        !            40: char   passp[50] = "/lib/cpp";                 /*god*/
        !            41: char   passf[50] = LIBPATH(fpp);               /*mjm*/
        !            42: char   *pref = LIBPATH(11crt0.o);              /*god*/
        !            43: char   *copy();
        !            44: char   *setsuf();
        !            45: char   *strcat();
        !            46: char   *strcpy();
        !            47: char   *stralloc();
        !            48: extern int optind;
        !            49: extern int opterr;
        !            50: extern char *optarg;
        !            51: extern int optopt;
        !            52: 
        !            53: main(argc, argv)
        !            54: char *argv[]; 
        !            55: {
        !            56:        char *rhopt;    /* mjm */
        !            57:        char *t;
        !            58:        char *assource;
        !            59:        char **pv, *ptemp[MAXOPT], **pvt;
        !            60:        int nc, nl, i, j, c, nxo, na;
        !            61:        int idexit();
        !            62: 
        !            63:        opterr = 0;
        !            64:        i = nc = nl = nxo = 0;
        !            65:        setbuf(stdout, (char *)NULL);
        !            66:        pv = ptemp;
        !            67:        while (optind<argc)
        !            68:            switch (c = getopt(argc, argv, "So:OpEPcfL:l:D:I:U:C:t:B:zvF")) {
        !            69:        case 'S':
        !            70:                sflag++;
        !            71:                cflag++;
        !            72:                continue;
        !            73: 
        !            74:        case 'o':
        !            75:                outfile = optarg;
        !            76:                if ((c=getsuf(outfile))=='c'||c=='o') {
        !            77:                        error("Would overwrite %s", outfile);
        !            78:                        exit(8);
        !            79:                }
        !            80:                continue;
        !            81: 
        !            82:        case 'O':
        !            83:                oflag++;
        !            84:                continue;
        !            85: 
        !            86:        case 'p':
        !            87:                error("profiling not supported", (char *)NULL); /*god*/
        !            88:                exit(-1); /*god*/
        !            89: /*god*/                /*proflag++;
        !            90:                continue;*/     /*god*/
        !            91: 
        !            92:        case 'E':
        !            93:                exflag++;
        !            94:                cflag++;
        !            95:                pflag++;
        !            96:                *pv++ = "-E";
        !            97:                continue;
        !            98: 
        !            99:        case 'P':
        !           100:                pflag++;
        !           101:                *pv++ = "-P";
        !           102:        case 'c':
        !           103:                cflag++;
        !           104:                continue;
        !           105: 
        !           106:        case 'f':
        !           107: /*god*/                error("floating point interpreter not supported",(char *)NULL);
        !           108:                error("use -F to invoke floating point preprocessor",
        !           109:                        (char *)NULL); /*god*/
        !           110:                exit(-1); /*god*/
        !           111: /*god*/                /*noflflag++;
        !           112:                if (npassname || chpass)
        !           113:                        error("-f overwrites earlier option", (char *)NULL);
        !           114:                npassname = "/lib/f";
        !           115:                chpass = "1";
        !           116:                continue;*/             /*god*/
        !           117: 
        !           118:        case 'L':
        !           119:                t = stralloc(strlen(optarg)+2);
        !           120:                t[0] = '-';
        !           121:                t[1] = 'L';
        !           122:                t[2] = '\0';
        !           123:                strcat(t, optarg);
        !           124:                llist[nl++] = t;
        !           125:                break;
        !           126: 
        !           127:        case 'l':
        !           128:                t = stralloc(strlen(optarg)+2);
        !           129:                t[0] = '-';
        !           130:                t[1] = 'l';
        !           131:                t[2] = '\0';
        !           132:                strcat(t, optarg);
        !           133:                llist[nl++] = t;
        !           134:                break;
        !           135: 
        !           136:        case 'D':
        !           137:        case 'I':
        !           138:        case 'U':
        !           139:        case 'C':
        !           140:                *pv = stralloc(strlen(optarg)+2);
        !           141:                if (pv >= ptemp+MAXOPT) {
        !           142:                        error("Too many DIUC options", (char *)NULL);
        !           143:                        dexit();
        !           144:                }
        !           145:                (*pv)[0] = '-';
        !           146:                (*pv)[1] = c;
        !           147:                (*pv)[2] = '\0';
        !           148:                strcat(*pv, optarg);
        !           149:                pv++;
        !           150:                break;
        !           151: 
        !           152:        case 't':
        !           153:                if (chpass)
        !           154:                        error("-t overwrites earlier option", (char *)NULL);
        !           155:                chpass = optarg;
        !           156:                if (chpass[0]==0)
        !           157:                        chpass = "012pf"; /*god: allow select fpp pass*/
        !           158:                break;
        !           159: 
        !           160:        case 'B':
        !           161:                if (npassname)
        !           162:                        error("-B overwrites earlier option", (char *)NULL);
        !           163:                npassname = optarg;
        !           164:                if (npassname[0]==0)
        !           165:                        npassname = LIBPATH(11);        /*god*/
        !           166:                break;
        !           167: 
        !           168:        case '?':
        !           169:                t = stralloc(3);
        !           170:                t[0] = '-';
        !           171:                t[1] = optopt;
        !           172:                t[2] = '\0';
        !           173:                llist[nl++] = t;
        !           174:                break;
        !           175: 
        !           176:        case 'z':
        !           177:                zflag++;
        !           178:                break;
        !           179: 
        !           180:        case 'v':               /* mjm: callsys print */
        !           181:                vflag++;
        !           182:                break;
        !           183: 
        !           184:        case 'F':               /* mjm: RH fpp */
        !           185:                Fflag++;
        !           186:                if( (optind < argc)/*god*/ && (argv[optind][1] == 'F') )
        !           187:                        rhopt = argv[optind];
        !           188:                else if(argv[optind-1][1] == 'F')
        !           189:                        rhopt = argv[optind-1];
        !           190:                for(t = rhopt+2; *t != '\0'; t++)       /* skip rest after -F */
        !           191:                        getopt(argc, argv, "qunl");
        !           192:                break;
        !           193: 
        !           194:        case EOF:
        !           195:                t = argv[optind];
        !           196:                optind++;
        !           197:                if((c=getsuf(t))=='c' || c=='s'|| exflag) {
        !           198:                        clist[nc++] = t;
        !           199:                        if (nc>=MAXFIL) {
        !           200:                                error("Too many source files", (char *)NULL);
        !           201:                                exit(1);
        !           202:                        }
        !           203:                        t = setsuf(t, 'o');
        !           204:                }
        !           205:                if (nodup(llist, t)) {
        !           206:                        llist[nl++] = t;
        !           207:                        if (nl >= MAXLIB) {
        !           208:                                error("Too many object/library files", (char *)NULL);
        !           209:                                exit(1);
        !           210:                        }
        !           211:                        if (getsuf(t)=='o')
        !           212:                                nxo++;
        !           213:                }
        !           214:        }
        !           215:        if (npassname && chpass ==0)
        !           216:                chpass = "012pf";               /*god: allow select fpp pass*/
        !           217:        if (chpass && npassname==0)
        !           218:                npassname = LIBPATH(11);        /*god*/
        !           219:        if (chpass)
        !           220:                for (t=chpass; *t; t++) {
        !           221:                        switch (*t) {
        !           222:                        case '0':
        !           223:                                strcpy (pass0, npassname);
        !           224:                                strcat (pass0, "c0");
        !           225:                                continue;
        !           226:                        case '1':
        !           227:                                strcpy (pass1, npassname);
        !           228:                                strcat (pass1, "c1");
        !           229:                                continue;
        !           230:                        case '2':
        !           231:                                strcpy (pass2, npassname);
        !           232:                                strcat (pass2, "c2");
        !           233:                                continue;
        !           234:                        case 'p':
        !           235:                                strcpy (passp, npassname);
        !           236:                                strcat (passp, "cpp");
        !           237:                                continue;
        !           238:                        case 'f':               /*god: include fpp in here */
        !           239:                                strcpy (passf, npassname);
        !           240:                                strcat (passf, "fpp");
        !           241:                        }
        !           242:                }
        !           243: /*god*/        /*if (noflflag)
        !           244:                pref = proflag ? "/lib/fmcrt0.o" : "/lib/fcrt0.o";
        !           245:        else if (proflag)
        !           246:                pref = "/lib/mcrt0.o";*/        /*god*/
        !           247:        if(nc==0)
        !           248:                goto nocom;
        !           249:        if (pflag==0 || Fflag) {        /* mjm: added Fflag */
        !           250:                tmp0 = copy("/tmp/ctm0a");
        !           251:                while (access(tmp0, 0)==0)
        !           252:                        tmp0[9]++;
        !           253:                while((creat(tmp0, 0400))<0) {
        !           254:                        if (tmp0[9]=='z') {
        !           255:                                error("11cc: cannot create temp", (char *)NULL);
        !           256:                                exit(1);
        !           257:                        }
        !           258:                        tmp0[9]++;
        !           259:                }
        !           260:        }
        !           261:        if (signal(SIGINT, SIG_IGN) != SIG_IGN)
        !           262:                signal(SIGINT, idexit);
        !           263:        if (signal(SIGTERM, SIG_IGN) != SIG_IGN)
        !           264:                signal(SIGTERM, idexit);
        !           265:        (tmp1 = copy(tmp0))[8] = '1';
        !           266:        (tmp2 = copy(tmp0))[8] = '2';
        !           267:        (tmp3 = copy(tmp0))[8] = '3';
        !           268:        if (oflag)
        !           269:                (tmp5 = copy(tmp0))[8] = '5';
        !           270:        if (pflag==0)
        !           271:                (tmp4 = copy(tmp0))[8] = '4';
        !           272:        if (Fflag) {            /* mjm */
        !           273:                (tmp6 = copy(tmp0))[8] = '6';   /* mjm */
        !           274:                (tmp7 = copy(tmp0))[8] = '7';   /* mjm */
        !           275:        }
        !           276:        pvt = pv;
        !           277:        for (i=0; i<nc; i++) {
        !           278:                if (nc>1)
        !           279:                        printf("%s:\n", clist[i]);
        !           280:                if (getsuf(clist[i])=='s') {
        !           281:                        assource = clist[i];
        !           282:                        goto assemble;
        !           283:                } 
        !           284:                else
        !           285:                        assource = tmp3;
        !           286:                if (pflag)
        !           287:                        tmp4 = setsuf(clist[i], 'i');
        !           288:                av[0] = "cpp";
        !           289:                av[1] = clist[i];
        !           290:                av[2] = exflag ? "-" : tmp4;
        !           291:                if(Fflag)
        !           292:                        av[2] = tmp6;   /* mjm */
        !           293:                na = 3;
        !           294:                for(pv=ptemp; pv <pvt; pv++)
        !           295:                        if(!Fflag || *(*pv+1) != 'P')   /* mjm */
        !           296:                        av[na++] = *pv;         /* mjm: no -P when -F */
        !           297:                av[na++] = "-Uvax";     /*god: (5/23) get rid of vax define */
        !           298:                av[na++] = "-Dpdp11=1"; /*god: (5/23) and define pdp11 */
        !           299:                av[na++]=0;
        !           300:                if (callsys(passp, av)) {
        !           301:                        cflag++;
        !           302:                        eflag++;
        !           303:                        continue;
        !           304:                }
        !           305:                if(Fflag) {             /* mjm */
        !           306:                        av[0] = "fpp";
        !           307:                        av[1] = tmp6;
        !           308:                        av[2] = tmp4;
        !           309:                        av[3] = tmp7;
        !           310:                        av[4] = rhopt;
        !           311:                        av[5] = 0;
        !           312:                        if (callsys(passf, av)) {       /* mjm */
        !           313:                                eflag++;
        !           314:                                continue;
        !           315:                        }
        !           316:                }
        !           317:                av[0]= "11c0";          /*god*/
        !           318:                if (pflag) {
        !           319:                        cflag++;
        !           320:                        continue;
        !           321:                }
        !           322:                j = 1;
        !           323:                if (zflag)
        !           324:                        av[j++] = "-u";
        !           325:                av[j++] = tmp4;
        !           326:                av[j++] = tmp1;
        !           327:                av[j++] = tmp2;
        !           328:                if (proflag)
        !           329:                        av[j++] = "-P";
        !           330:                av[j++] = 0;
        !           331:                if (callsys(pass0, av)) {
        !           332:                        cflag++;
        !           333:                        eflag++;
        !           334:                        continue;
        !           335:                }
        !           336:                av[0] = "11c1";         /*god*/
        !           337:                av[1] = tmp1;
        !           338:                av[2] = tmp2;
        !           339:                if (sflag)
        !           340:                        assource = tmp3 = setsuf(clist[i], 's');
        !           341:                av[3] = tmp3;
        !           342:                if (oflag)
        !           343:                        av[3] = tmp5;
        !           344:                av[4] = 0;
        !           345:                if(callsys(pass1, av)) {
        !           346:                        cflag++;
        !           347:                        eflag++;
        !           348:                        continue;
        !           349:                }
        !           350:                if (oflag) {
        !           351:                        av[0] = "11c2"; /*god*/
        !           352:                        av[1] = tmp5;
        !           353:                        av[2] = tmp3;
        !           354:                        av[3] = 0;
        !           355:                        if (callsys(pass2, av)) {
        !           356:                                unlink(tmp3);
        !           357:                                assource = tmp5;
        !           358:                        } 
        !           359:                        else
        !           360:                                unlink(tmp5);
        !           361:                }
        !           362:                if (sflag)
        !           363:                        continue;
        !           364: assemble:
        !           365:                av[0] = "11as";         /*god*/
        !           366:                av[1] = "-u";
        !           367:                av[2] = "-o";
        !           368:                av[3] = setsuf(clist[i], 'o');
        !           369:                av[4] = assource;
        !           370:                av[5] = 0;
        !           371:                cunlink(tmp1);
        !           372:                cunlink(tmp2);
        !           373:                cunlink(tmp4);
        !           374:                if (callsys(BINPATH(11as), av) > 1) {   /*god*/
        !           375:                        cflag++;
        !           376:                        eflag++;
        !           377:                        continue;
        !           378:                }
        !           379:        }
        !           380: nocom:
        !           381:        if (cflag==0 && nl!=0) {
        !           382:                i = 0;
        !           383:                av[0] = "11ld";                 /*god*/
        !           384:                av[1] = "-X";
        !           385:                av[2] = pref;
        !           386:                j = 3;
        !           387:                if (outfile) {
        !           388:                        av[j++] = "-o";
        !           389:                        av[j++] = outfile;
        !           390:                }
        !           391:                while(i<nl)
        !           392:                        av[j++] = llist[i++];
        !           393:                av[j++] = 0;
        !           394:                eflag |= callsys(BINPATH(11ld), av);    /*god*/
        !           395:                if (nc==1 && nxo==1 && eflag==0)
        !           396:                        cunlink(setsuf(clist[0], 'o'));
        !           397:        }
        !           398:        dexit();
        !           399: }
        !           400: 
        !           401: idexit()
        !           402: {
        !           403:        eflag = 100;
        !           404:        dexit();
        !           405: }
        !           406: 
        !           407: dexit()
        !           408: {
        !           409:        if (!pflag) {
        !           410:                cunlink(tmp1);
        !           411:                cunlink(tmp2);
        !           412:                if (sflag==0)
        !           413:                        cunlink(tmp3);
        !           414:                cunlink(tmp4);
        !           415:                cunlink(tmp5);
        !           416:                cunlink(tmp0);
        !           417:        }
        !           418:        if(Fflag) {             /* mjm */
        !           419:                cunlink(tmp6);
        !           420:                cunlink(tmp7);
        !           421:                cunlink(tmp0);
        !           422:        }
        !           423:        exit(eflag);
        !           424: }
        !           425: 
        !           426: error(s, x)
        !           427: char *s, *x;
        !           428: {
        !           429:        fprintf(exflag?stderr:stdout, s, x);
        !           430:        putc('\n', exflag? stderr : stdout);
        !           431:        cflag++;
        !           432:        eflag++;
        !           433: }
        !           434: 
        !           435: 
        !           436: 
        !           437: 
        !           438: getsuf(as)
        !           439: char as[];
        !           440: {
        !           441:        register int c;
        !           442:        register char *s;
        !           443:        register int t;
        !           444: 
        !           445:        s = as;
        !           446:        c = 0;
        !           447:        while(t = *s++)
        !           448:                if (t=='/')
        !           449:                        c = 0;
        !           450:                else
        !           451:                        c++;
        !           452:        s -= 3;
        !           453:        if (c<=14 && c>2 && *s++=='.')
        !           454:                return(*s);
        !           455:        return(0);
        !           456: }
        !           457: 
        !           458: char *
        !           459: setsuf(as, ch)
        !           460: char *as;
        !           461: {
        !           462:        register char *s, *s1;
        !           463: 
        !           464:        s = s1 = copy(as);
        !           465:        while(*s)
        !           466:                if (*s++ == '/')
        !           467:                        s1 = s;
        !           468:        s[-1] = ch;
        !           469:        return(s1);
        !           470: }
        !           471: 
        !           472: callsys(f, v)
        !           473: char f[], *v[]; 
        !           474: {
        !           475:        int t, status;
        !           476:        register char **vp;     /* god */
        !           477: 
        !           478:        if(vflag) {     /* god & mjm */
        !           479:                vp = v;
        !           480:                fprintf(stderr,"+ ");
        !           481:                while (*vp)
        !           482:                        fprintf(stderr,"%s ",*vp++);
        !           483:                fprintf(stderr, "\n");
        !           484:        }
        !           485: 
        !           486:        if ((t=fork())==0) {
        !           487:                execv(f, v);
        !           488:                printf("Can't find %s\n", f);
        !           489:                exit(100);
        !           490:        } else
        !           491:                if (t == -1) {
        !           492:                        printf("Try again\n");
        !           493:                        return(100);
        !           494:                }
        !           495:        while(t!=wait(&status))
        !           496:                ;
        !           497:        if (t = status&0377) {
        !           498:                if (t!=SIGINT) {
        !           499:                        printf("Fatal error (%d) in %s\n", t,f); /*mjm*/
        !           500:                        eflag = 8;
        !           501:                }
        !           502:                dexit();
        !           503:        }
        !           504:        return((status>>8) & 0377);
        !           505: }
        !           506: 
        !           507: char *
        !           508: copy(s)
        !           509: register char *s;
        !           510: {
        !           511:        register char *ns;
        !           512: 
        !           513:        ns = stralloc(strlen(s));
        !           514:        return(strcpy(ns, s));
        !           515: }
        !           516: 
        !           517: char *
        !           518: stralloc(n)
        !           519: {
        !           520:        char *malloc();
        !           521:        register char *s;
        !           522: 
        !           523:        s = malloc(n+1);
        !           524:        if (s==NULL) {
        !           525:                error("out of space", (char *)NULL);
        !           526:                dexit();
        !           527:        }
        !           528: }
        !           529: 
        !           530: nodup(l, os)
        !           531: char **l, *os;
        !           532: {
        !           533:        register char *t, *s;
        !           534:        register int c;
        !           535: 
        !           536:        s = os;
        !           537:        if (getsuf(s) != 'o')
        !           538:                return(1);
        !           539:        while(t = *l++) {
        !           540:                while(c = *s++)
        !           541:                        if (c != *t++)
        !           542:                                break;
        !           543:                if (*t=='\0' && c=='\0')
        !           544:                        return(0);
        !           545:                s = os;
        !           546:        }
        !           547:        return(1);
        !           548: }
        !           549: 
        !           550: cunlink(f)
        !           551: char *f;
        !           552: {
        !           553:        if (f==NULL)
        !           554:                return;
        !           555:        unlink(f);
        !           556: }

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