Return to b.i CVS log

Up to [Research Unix] / researchv10no / cmd / ccom / vax / tests

Annotation of researchv10no/cmd/ccom/vax/tests/b.i, revision 1.1

1.1     ! root        1: typedef        unsigned char   u_char;
        !             2: typedef        unsigned short  u_short;
        !             3: typedef        unsigned int    u_int;
        !             4: typedef        unsigned long   u_long;
        !             5: typedef        struct  _physadr { int r[1]; } *physadr;
        !             6: typedef        int     daddr_t;
        !             7: typedef        char *  caddr_t;
        !             8: typedef        u_short ino_t;
        !             9: typedef        int     swblk_t;
        !            10: typedef        int     size_t;
        !            11: typedef        int     time_t;
        !            12: typedef        int     label_t[14];
        !            13: typedef        short   dev_t;
        !            14: typedef        int     off_t;
        !            15: typedef long   portid_t;
        !            16: typedef struct fd_set { int fds_bits[1]; } fd_set;
        !            17: extern struct  _iobuf {
        !            18:        int     _cnt;
        !            19:        unsigned char   *_ptr;
        !            20:        unsigned char   *_base;
        !            21:        short   _flag;
        !            22:        char    _file;
        !            23: } _iob[20];
        !            24: struct _iobuf  *fopen();
        !            25: struct _iobuf  *fdopen();
        !            26: struct _iobuf  *freopen();
        !            27: long   ftell();
        !            28: char   *fgets();
        !            29: extern char    _ctype[];
        !            30: typedef int    (*SIG_TYP)();
        !            31: SIG_TYP signal();
        !            32: struct dir
        !            33: {
        !            34:        ino_t   d_ino;
        !            35:        char    d_name[14];
        !            36: };
        !            37: struct vtimes {
        !            38:        int     vm_utime;               
        !            39:        int     vm_stime;               
        !            40:        
        !            41:        unsigned vm_idsrss;             
        !            42:        unsigned vm_ixrss;              
        !            43:        int     vm_maxrss;              
        !            44:        int     vm_majflt;              
        !            45:        int     vm_minflt;              
        !            46:        int     vm_nswap;               
        !            47:        int     vm_inblk;               
        !            48:        int     vm_oublk;               
        !            49: };
        !            50: struct timeb
        !            51: {
        !            52:        time_t  time;
        !            53:        unsigned short millitm;
        !            54:        short   timezone;
        !            55:        short   dstflag;
        !            56: };
        !            57: struct vtimes newv, oldv;
        !            58: struct timeb newt, oldt;
        !            59: char   *cpp = "/lib/cpp";
        !            60: char   *ccom = "/usr/pjw/comp/vcc/comp.sv";
        !            61: char   *c2 = "/lib/c2";
        !            62: char   *as = "/bin/as";
        !            63: char   *ld = "/bin/ld";
        !            64: char   *crt0 = "/lib/crt0.o";
        !            65: char   tmp0[30];               
        !            66: char   *tmp1, *tmp2, *tmp3, *tmp4, *tmp5;
        !            67: char   *outfile;
        !            68: char   *savestr(), *strspl(), *setsuf();
        !            69: int    idexit();
        !            70: char   **av, **clist, **llist, **plist;
        !            71: int    cflag, eflag, gflag, oflag, pflag, sflag, wflag, Rflag, exflag, proflag;
        !            72: int    vflag; 
        !            73: char   *dflag;
        !            74: int    exfail;
        !            75: char   *chpass;
        !            76: char   *npassname;
        !            77: extern int     optind;
        !            78: extern int     opterr;
        !            79: extern char    *optarg;
        !            80: extern int     optopt;
        !            81: int    nc, nl, np, nxo, na;
        !            82: main(argc, argv)
        !            83:        char **argv;
        !            84: {
        !            85:        char *t;
        !            86:        char *assource;
        !            87:        int i, j, c;
        !            88:        
        !            89:        av = (char **)calloc(argc+10, sizeof (char **));
        !            90:        clist = (char **)calloc(argc, sizeof (char **));
        !            91:        llist = (char **)calloc(argc, sizeof (char **));
        !            92:        plist = (char **)calloc(argc, sizeof (char **));
        !            93:        opterr = 0;
        !            94:        while (optind<argc) switch (c = getopt(argc, argv, "vsSo:ROPgwEpPcD:I:U:C:t:B:l:d:")) {
        !            95:        case 'v':
        !            96:                vflag++;
        !            97:                continue;
        !            98:        case 'S':
        !            99:                sflag++;
        !           100:                cflag++;
        !           101:                continue;
        !           102:        case 'l':
        !           103:                llist[nl++] = strspl("-l", optarg);
        !           104:                continue;
        !           105:        case 'o':
        !           106:                outfile = optarg;
        !           107:                switch (getsuf(outfile)) {
        !           108:                case 'c':
        !           109:                case 'o':
        !           110:                        error("-o would overwrite %s", outfile);
        !           111:                        exit(8);
        !           112:                }
        !           113:                continue;
        !           114:        case 'R':
        !           115:                Rflag++;
        !           116:                continue;
        !           117:        case 'O':
        !           118:                oflag++;
        !           119:                continue;
        !           120:        case 'p':
        !           121:                proflag++;
        !           122:                continue;
        !           123:        case 'g':
        !           124:                gflag++;
        !           125:                continue;
        !           126:        case 'w':
        !           127:                wflag++;
        !           128:                continue;
        !           129:        case 'E':
        !           130:                exflag++;
        !           131:        case 'P':
        !           132:                pflag++;
        !           133:                t = strspl("-", "x");
        !           134:                t[1] = optopt;
        !           135:                plist[np++] = t;
        !           136:        case 'c':
        !           137:                cflag++;
        !           138:                continue;
        !           139:        case 'D':
        !           140:        case 'I':
        !           141:        case 'U':
        !           142:        case 'C':
        !           143:                plist[np] = strspl("-X", optarg);
        !           144:                plist[np++][1] = c;
        !           145:                continue;
        !           146:        case 't':
        !           147:                if (chpass)
        !           148:                        error("-t overwrites earlier option", 0);
        !           149:                chpass = optarg;
        !           150:                if (chpass[0]==0)
        !           151:                        chpass = "012p";
        !           152:                continue;
        !           153:        case 'B':
        !           154:                if (npassname)
        !           155:                        error("-B overwrites earlier option", 0);
        !           156:                npassname = optarg;
        !           157:                if (npassname[0]==0)
        !           158:                        npassname = "/usr/c/o";
        !           159:                continue;
        !           160:        case 'd':
        !           161:                dflag = strspl("-d", optarg);
        !           162:                continue;
        !           163:        case '?':
        !           164:        case 's':
        !           165:                t = strspl("-", "x");
        !           166:                t[1] = optopt;
        !           167:                llist[nl++] = t;
        !           168:                continue;
        !           169:        case (-1):
        !           170:                t = argv[optind];
        !           171:                optind++;
        !           172:                c = getsuf(t);
        !           173:                if (c=='c' || c=='s' || c=='i' || exflag) {
        !           174:                        clist[nc++] = t;
        !           175:                        t = setsuf(t, 'o');
        !           176:                }
        !           177:                if (nodup(llist, t)) {
        !           178:                        llist[nl++] = t;
        !           179:                        if (getsuf(t)=='o')
        !           180:                                nxo++;
        !           181:                }
        !           182:        }
        !           183:        if (gflag) {
        !           184:                if (oflag)
        !           185:                        fprintf((&_iob[2]), "cc: warning: -g disables -O\n");
        !           186:                oflag = 0;
        !           187:        }
        !           188:        if (npassname && chpass ==0)
        !           189:                chpass = "012p";
        !           190:        if (chpass && npassname==0)
        !           191:                npassname = "/usr/new";
        !           192:        if (chpass)
        !           193:        for (t=chpass; *t; t++) {
        !           194:                switch (*t) {
        !           195:                case '0':
        !           196:                        ccom = strspl(npassname, "ccom");
        !           197:                        continue;
        !           198:                case '2':
        !           199:                        c2 = strspl(npassname, "c2");
        !           200:                        continue;
        !           201:                case 'p':
        !           202:                        cpp = strspl(npassname, "cpp");
        !           203:                        continue;
        !           204:                }
        !           205:        }
        !           206:        if (proflag)
        !           207:                crt0 = "/lib/mcrt0.o";
        !           208:        if (nc==0)
        !           209:                goto nocom;
        !           210:        if (signal(2    ,       (int (*)())1) !=        (int (*)())1)
        !           211:                (void)signal(2  , idexit);
        !           212:        if (signal(15   ,       (int (*)())1) !=        (int (*)())1)
        !           213:                (void)signal(15 , idexit);
        !           214:        if (pflag==0)
        !           215:                sprintf(tmp0, "/tmp/ctm%05.5d", getpid());
        !           216:        tmp1 = strspl(tmp0, "1");
        !           217:        tmp2 = strspl(tmp0, "2");
        !           218:        tmp3 = strspl(tmp0, "3");
        !           219:        if (pflag==0)
        !           220:                tmp4 = strspl(tmp0, "4");
        !           221:        if (oflag)
        !           222:                tmp5 = strspl(tmp0, "5");
        !           223:        for (i=0; i<nc; i++) {
        !           224:                int suffix = getsuf(clist[i]);
        !           225:                if (nc > 1) {
        !           226:                        printf("%s:\n", clist[i]);
        !           227:                        fflush((&_iob[1]));
        !           228:                }
        !           229:                if (suffix == 's') {
        !           230:                        assource = clist[i];
        !           231:                        goto assemble;
        !           232:                } else
        !           233:                        assource = tmp3;
        !           234:                if (suffix == 'i')
        !           235:                        goto compile;
        !           236:                if (pflag)
        !           237:                        tmp4 = setsuf(clist[i], 'i');
        !           238:                av[0] = "cpp";
        !           239:                av[1] = clist[i];
        !           240:                av[2] = exflag ? "-" : tmp4;
        !           241:                na = 3;
        !           242:                for (j = 0; j < np; j++)
        !           243:                        av[na++] = plist[j];
        !           244:                av[na++] = 0;
        !           245:                switch (callsys(cpp, av)) {
        !           246:                        case 0:
        !           247:                                break;
        !           248:                        default:
        !           249:                                if (callsys("/lib/cpre",av)) {
        !           250:                                        exfail++;
        !           251:                                        exflag++;
        !           252:                                }
        !           253:                }
        !           254:                if (pflag || exfail) {
        !           255:                        cflag++;
        !           256:                        continue;
        !           257:                }
        !           258:                if (sflag)
        !           259:                        assource = tmp3 = setsuf(clist[i], 's');
        !           260: compile:
        !           261:                av[0] = "ccom";
        !           262:                av[1] = suffix=='i'? clist[i]: tmp4;
        !           263:                av[2] = oflag? tmp5:tmp3;
        !           264:                na = 3;
        !           265:                if (proflag)
        !           266:                        av[na++] = "-XP";
        !           267:                if (gflag)
        !           268:                        av[na++] = "-Xg";
        !           269:                if (wflag)
        !           270:                        av[na++] = "-w";
        !           271:                av[na] = 0;
        !           272:                if (callsys(ccom, av)) {
        !           273:                        cflag++;
        !           274:                        eflag++;
        !           275:                        continue;
        !           276:                }
        !           277:                if (oflag) {
        !           278:                        av[0] = "c2"; av[1] = tmp5; av[2] = tmp3; av[3] = 0;
        !           279:                        if (callsys(c2, av)) {
        !           280:                                unlink(tmp3);
        !           281:                                tmp3 = assource = tmp5;
        !           282:                        } else
        !           283:                                unlink(tmp5);
        !           284:                }
        !           285:                if (sflag)
        !           286:                        continue;
        !           287:        assemble:
        !           288:                        if (tmp1) unlink(tmp1);         if (tmp2) unlink(tmp2);         if (tmp4) unlink(tmp4);
        !           289:                av[0] = "as"; av[1] = "-o"; av[2] = setsuf(clist[i], 'o');
        !           290:                na = 3;
        !           291:                if (Rflag)
        !           292:                        av[na++] = "-R";
        !           293:                if (dflag)
        !           294:                        av[na++] = dflag;
        !           295:                av[na++] = assource;
        !           296:                av[na] = 0;
        !           297:                if (callsys(as, av) > 1) {
        !           298:                        cflag++;
        !           299:                        eflag++;
        !           300:                        continue;
        !           301:                }
        !           302:        }
        !           303: nocom:
        !           304:        if (cflag==0 && nl!=0) {
        !           305:                i = 0;
        !           306:                av[0] = "ld"; av[1] = "-X"; av[2] = crt0; na = 3;
        !           307:                if (outfile) {
        !           308:                        av[na++] = "-o";
        !           309:                        av[na++] = outfile;
        !           310:                }
        !           311:                while (i < nl)
        !           312:                        av[na++] = llist[i++];
        !           313:                if (gflag)
        !           314:                        av[na++] = "-lg";
        !           315:                av[na++] = "-lc";
        !           316:                av[na++] = 0;
        !           317:                eflag |= callsys(ld, av);
        !           318:                if (nc==1 && nxo==1 && eflag==0)
        !           319:                        unlink(setsuf(clist[0], 'o'));
        !           320:        }
        !           321:        dexit();
        !           322: }
        !           323: idexit()
        !           324: {
        !           325:        eflag = 100;
        !           326:        dexit();
        !           327: }
        !           328: dexit()
        !           329: {
        !           330:        if (!pflag) {
        !           331:                        if (tmp1) unlink(tmp1);
        !           332:                        if (tmp2) unlink(tmp2);
        !           333:                if (sflag==0)
        !           334:                                if (tmp3) unlink(tmp3);
        !           335:                        if (tmp4) unlink(tmp4);
        !           336:                        if (tmp5) unlink(tmp5);
        !           337:        }
        !           338:        exit(eflag);
        !           339: }
        !           340: error(s, x)
        !           341:        char *s, *x;
        !           342: {
        !           343:        struct _iobuf *diag = exflag ? (&_iob[2]) : (&_iob[1]);
        !           344:        fprintf(diag, "cc: ");
        !           345:        fprintf(diag, s, x);
        !           346:         (--( diag)->_cnt>=0? ((int)(*( diag)->_ptr++=(unsigned)('\n'))):_flsbuf((unsigned)('\n'), diag));
        !           347:        exfail++;
        !           348:        cflag++;
        !           349:        eflag++;
        !           350: }
        !           351: getsuf(as)
        !           352: char as[];
        !           353: {
        !           354:        register int c;
        !           355:        register char *s;
        !           356:        register int t;
        !           357:        s = as;
        !           358:        c = 0;
        !           359:        while (t = *s++)
        !           360:                if (t=='/')
        !           361:                        c = 0;
        !           362:                else
        !           363:                        c++;
        !           364:        s -= 3;
        !           365:        if (c <= 14 && c > 2 && *s++ == '.')
        !           366:                return (*s);
        !           367:        return (0);
        !           368: }
        !           369: char *
        !           370: setsuf(as, ch)
        !           371:        char *as;
        !           372: {
        !           373:        register char *s, *s1;
        !           374:        s = s1 = savestr(as);
        !           375:        while (*s)
        !           376:                if (*s++ == '/')
        !           377:                        s1 = s;
        !           378:        s[-1] = ch;
        !           379:        return (s1);
        !           380: }
        !           381: callsys(f, v)
        !           382:        char *f, **v;
        !           383: {
        !           384:        int t, status;
        !           385:        register char **vp;     
        !           386:        if(vflag) {     
        !           387:                vp = v;
        !           388:                fprintf((&_iob[2]),"+ ");
        !           389:                while (*vp)
        !           390:                        fprintf((&_iob[2]),"%s ",*vp++);
        !           391:                fprintf((&_iob[2]), "\n");
        !           392:        }
        !           393:        ftime(&oldt);
        !           394:        vtimes(0, &oldv);
        !           395:        t = vfork();
        !           396:        if (t == -1) {
        !           397:                printf("No more processes\n");
        !           398:                return (100);
        !           399:        }
        !           400:        if (t == 0) {
        !           401:                execv(f, v);
        !           402:                printf("Can't find %s\n", f);
        !           403:                fflush((&_iob[1]));
        !           404:                _exit(100);
        !           405:        }
        !           406:        while (t != wait(&status))
        !           407:                ;
        !           408:        ftime(&newt);
        !           409:        vtimes(0, &newv);
        !           410:        printf("%s\n", f);
        !           411:        printf("real %g user %g sys %g ", newt.time - oldt.time
        !           412:                + newt.millitm / 1000. - oldt.millitm / 1000.,
        !           413:                (newv.vm_utime - oldv.vm_utime) / 60.,
        !           414:                (newv.vm_stime - oldv.vm_stime) / 60.);
        !           415:        printf("reads %d writes %d\n", newv.vm_inblk - oldv.vm_inblk,
        !           416:                newv.vm_oublk - oldv.vm_oublk);
        !           417:        if ((t=(status&0377)) != 0 && t!=14) {
        !           418:                if (t!=2) {
        !           419:                        printf("Fatal error in %s\n", f);
        !           420:                        eflag = 8;
        !           421:                }
        !           422:                dexit();
        !           423:        }
        !           424:        return ((status>>8) & 0377);
        !           425: }
        !           426: nodup(l, os)
        !           427:        char **l, *os;
        !           428: {
        !           429:        register char *t, *s;
        !           430:        register int c;
        !           431:        s = os;
        !           432:        if (getsuf(s) != 'o')
        !           433:                return (1);
        !           434:        while (t = *l++) {
        !           435:                while (c = *s++)
        !           436:                        if (c != *t++)
        !           437:                                break;
        !           438:                if (*t==0 && c==0)
        !           439:                        return (0);
        !           440:                s = os;
        !           441:        }
        !           442:        return (1);
        !           443: }
        !           444: char   *savetab;
        !           445: int    saveleft;
        !           446: char *
        !           447: savestr(cp)
        !           448:        register char *cp;
        !           449: {
        !           450:        register int len;
        !           451:        len = strlen(cp) + 1;
        !           452:        if (len > saveleft) {
        !           453:                saveleft = 1024;
        !           454:                if (len > saveleft)
        !           455:                        saveleft = len;
        !           456:                savetab = (char *)malloc(saveleft);
        !           457:                if (savetab == 0) {
        !           458:                        fprintf((&_iob[2]), "ran out of memory (savestr)\n");
        !           459:                        exit(1);
        !           460:                }
        !           461:        }
        !           462:        strncpy(savetab, cp, len);
        !           463:        cp = savetab;
        !           464:        savetab += len;
        !           465:        saveleft -= len;
        !           466:        return (cp);
        !           467: }
        !           468: char *
        !           469: strspl(left, right)
        !           470:        char *left, *right;
        !           471: {
        !           472:        char buf[1024];
        !           473:        strcpy(buf, left);
        !           474:        strcat(buf, right);
        !           475:        return (savestr(buf));
        !           476: }

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