Return to main.c CVS log

Up to [Research Unix] / researchv10no / cmd / mk / export

Annotation of researchv10no/cmd/mk/export/main.c, revision 1.1

1.1     ! root        1: #include       "mk.h"
        !             2: 
        !             3: #define                MKFILE          "mkfile"
        !             4: 
        !             5: static char *version = "@(#)mk general release 3";
        !             6: int debug;
        !             7: Rule *rules, *metarules;
        !             8: int nproclimit;
        !             9: int nflag = 0;
        !            10: int tflag = 0;
        !            11: int iflag = 0;
        !            12: int kflag = 0;
        !            13: int mflag = 0;
        !            14: int aflag = 0;
        !            15: int uflag = 0;
        !            16: char *explain = 0;
        !            17: Word *target1;
        !            18: int nreps = 1;
        !            19: Job *jobs;
        !            20: char *whatif = 0;
        !            21: #ifdef PROF
        !            22: short buf[10000];
        !            23: #endif
        !            24: 
        !            25: main(argc, argv)
        !            26:        char **argv;
        !            27: {
        !            28:        register Word *w;
        !            29:        register char *s;
        !            30:        char *files[256], **f = files, **ff;
        !            31:        char mkargs[256], *ma = mkargs;
        !            32:        int i;
        !            33:        int tfd = -1;
        !            34:        char *temp = "/tmp/mkargXXXXXX";
        !            35: 
        !            36:        *ma = 0;
        !            37:        for(argv++; *argv && (**argv == '-'); argv++)
        !            38:        {
        !            39:                for(s = argv[0]; *s; *ma++ = *s++);
        !            40:                *ma++ = ' ';
        !            41:                switch(argv[0][1])
        !            42:                {
        !            43:                case 'a':
        !            44:                        aflag = 1;
        !            45:                        break;
        !            46:                case 'd':
        !            47:                        if(*(s = &argv[0][2]))
        !            48:                                while(*s) switch(*s++)
        !            49:                                {
        !            50:                                case 'p':       debug |= D_PARSE; break;
        !            51:                                case 'g':       debug |= D_GRAPH; break;
        !            52:                                case 'e':       debug |= D_EXEC; break;
        !            53:                                }
        !            54:                        else
        !            55:                                debug = 0xFFFF;
        !            56:                        break;
        !            57:                case 'e':
        !            58:                        explain = &argv[0][2];
        !            59:                        break;
        !            60:                case 'f':
        !            61:                        if(*++argv == 0)
        !            62:                                usage();
        !            63:                        *f++ = *argv;
        !            64:                        for(s = argv[0]; *s; *ma++ = *s++);
        !            65:                        *ma++ = ' ';
        !            66:                        break;
        !            67:                case 'i':
        !            68:                        iflag = 1;
        !            69:                        break;
        !            70:                case 'k':
        !            71:                        kflag = 1;
        !            72:                        break;
        !            73:                case 'm':
        !            74:                        mflag = 1;
        !            75:                        aflag = nflag = 1;
        !            76:                        break;
        !            77:                case 'n':
        !            78:                        nflag = 1;
        !            79:                        break;
        !            80:                case 't':
        !            81:                        tflag = 1;
        !            82:                        break;
        !            83:                case 'u':
        !            84:                        uflag = 1;
        !            85:                        break;
        !            86:                case 'w':
        !            87:                        if(argv[0][2])
        !            88:                                whatif = &argv[0][2];
        !            89:                        else {
        !            90:                                if(*++argv == 0)
        !            91:                                        usage();
        !            92:                                whatif = &argv[0][0];
        !            93:                        }
        !            94:                        break;
        !            95:                default:
        !            96:                        usage();
        !            97:                }
        !            98:        }
        !            99: #ifdef PROF
        !           100:        {
        !           101:                extern etext();
        !           102:                monitor(main, etext, buf, sizeof buf, 300);
        !           103:        }
        !           104: #endif
        !           105: 
        !           106:        if(aflag)
        !           107:                iflag = 1;
        !           108: 
        !           109:        account();
        !           110:        syminit();
        !           111:        builtins();
        !           112:        initenv();
        !           113: 
        !           114:        /*
        !           115:                assignment args become null strings
        !           116:        */
        !           117:        for(i = 0; argv[i]; i++) if(strchr(argv[i], '=')){
        !           118:                for(s = argv[i]; *s; *ma++ = *s++);
        !           119:                *ma++ = ' ';
        !           120:                if(tfd < 0){
        !           121:                        mktemp(temp);
        !           122:                        close(creat(temp, 0600));
        !           123:                        if((tfd = open(temp, 2)) < 0){
        !           124:                                perror(temp);
        !           125:                                Exit();
        !           126:                        }
        !           127:                }
        !           128:                Fprint(tfd, "%s\n", argv[i]);
        !           129:                *argv[i] = 0;
        !           130:        }
        !           131:        if(tfd >= 0){
        !           132:                Fflush(tfd);
        !           133:                lseek(tfd, 0L, 0);
        !           134:                parse("command line args", tfd, 1, 1);
        !           135:                unlink(temp);
        !           136:        }
        !           137: 
        !           138:        if(ma != mkargs) ma--;
        !           139:        *ma = 0;
        !           140:        symlook("MKFLAGS", S_VAR, strdup(mkargs));
        !           141:        for(ma = mkargs, i = 0; argv[i]; i++){
        !           142:                if(*argv[i] == 0) continue;
        !           143:                if(i) *ma++ = ' ';
        !           144:                for(s = argv[i]; *s; *ma++ = *s++);
        !           145:        }
        !           146:        *ma = 0;
        !           147:        symlook("MKARGS", S_VAR, strdup(mkargs));
        !           148: 
        !           149:        if(f == files){
        !           150:                if(access(MKFILE, 4) == 0)
        !           151:                        parse(MKFILE, open(MKFILE, 0), 0, 1);
        !           152:        } else
        !           153:                for(ff = files; ff < f; ff++)
        !           154:                        parse(*ff, open(*ff, 0), 0, 1);
        !           155:        parsebuiltins();
        !           156:        if(DEBUG(D_PARSE)){
        !           157:                dumpw("default targets", target1);
        !           158:                dumpr("rules", rules);
        !           159:                dumpr("metarules", metarules);
        !           160:                dumpv("variables");
        !           161:        }
        !           162:        if(whatif)
        !           163:                timeinit(whatif);
        !           164:        execinit();
        !           165:        /* skip assignment args */
        !           166:        while(*argv && (**argv == 0))
        !           167:                argv++;
        !           168:        sigcatch();
        !           169:        if(*argv == 0){
        !           170:                if(target1)
        !           171:                        for(w = target1; w; w = w->next)
        !           172:                                mk(w->s);
        !           173:                else {
        !           174:                        Fprint(2, "mk: nothing to mk\n");
        !           175:                        Exit();
        !           176:                }
        !           177:        } else
        !           178:                for(; *argv; argv++)
        !           179:                        if(**argv)
        !           180:                                mk(*argv);
        !           181:        if(uflag)
        !           182:                praccount();
        !           183:        if(mflag)
        !           184:                makefile();
        !           185:        exit(0);
        !           186: }
        !           187: 
        !           188: usage()
        !           189: {
        !           190: 
        !           191:        Fprint(2, "Usage: mk [-f file] [-n] [-a] [-e] [-t] [-k] [-i] [-d[egp]] [targets ...]\n");
        !           192:        Exit();
        !           193: }
        !           194: 
        !           195: char *
        !           196: Malloc(n)
        !           197: {
        !           198:        register char *s;
        !           199: 
        !           200:        if(s = malloc(n))
        !           201:                return(s);
        !           202:        Fprint(2, "mk: cannot alloc %d bytes\n", n);
        !           203:        Exit();
        !           204:        return((char *)0);      /* shut cyntax up */
        !           205: }
        !           206: 
        !           207: Exit()
        !           208: {
        !           209:        while(wait((int *)0) >= 0)
        !           210:                ;
        !           211:        exit(1);
        !           212: }
        !           213: 
        !           214: char *
        !           215: strndup(s, n)
        !           216:        char *s;
        !           217: {
        !           218:        register char *goo;
        !           219: 
        !           220:        goo = Malloc(n);
        !           221:        memcpy(goo, s, n);
        !           222:        return(goo);
        !           223: }
        !           224: 
        !           225: initenv()
        !           226: {
        !           227:        extern char **environ;
        !           228:        register char **p, *s, *ss;
        !           229: 
        !           230:        for(p = environ; *p; p++){
        !           231:                s = shname(*p);
        !           232:                switch(*s)
        !           233:                {
        !           234:                case '=':
        !           235:                        *s = 0;
        !           236:                        ss = strdup(s+1);
        !           237:                        symlook(strdup(*p), S_VAR, ss)->value = ss;
        !           238:                        *s = '=';
        !           239:                        break;
        !           240:                case 0:
        !           241:                        ss = strdup("");
        !           242:                        symlook(strdup(*p), S_VAR, ss)->value = ss;
        !           243:                        break;
        !           244:                }
        !           245:        }
        !           246: }
        !           247: 
        !           248: assert(s, n)
        !           249:        char *s;
        !           250: {
        !           251:        if(!n){
        !           252:                Fprint(2, "mk: Assertion ``%s'' failed.\n", s);
        !           253:                Exit();
        !           254:        }
        !           255: }

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