Return to time.c CVS log

Up to [CSRG BSD Unix] / 40BSD / cmd

Annotation of 40BSD/cmd/time.c, revision 1.1

1.1     ! root        1: static char *sccsid = "@(#)time.c      4.2 (Berkeley) 10/9/80";
        !             2: /* time command */
        !             3: 
        !             4: #include <stdio.h>
        !             5: #include <signal.h>
        !             6: #include <sys/types.h>
        !             7: #include <sys/times.h>
        !             8: 
        !             9: extern int errno;
        !            10: extern char *sys_errlist[];
        !            11: 
        !            12: main(argc, argv)
        !            13: char **argv;
        !            14: {
        !            15:        struct tms buffer, obuffer;
        !            16:        int status;
        !            17:        register p;
        !            18:        time_t before, after;
        !            19: 
        !            20:        if(argc<=1)
        !            21:                exit(0);
        !            22:        time(&before);
        !            23:        p = fork();
        !            24:        if(p == -1) {
        !            25:                fprintf(stderr, "Try again.\n");
        !            26:                exit(1);
        !            27:        }
        !            28:        if(p == 0) {
        !            29:                execvp(argv[1], &argv[1]);
        !            30:                fprintf(stderr, "%s: %s\n", argv[1], sys_errlist[errno]);
        !            31:                exit(1);
        !            32:        }
        !            33:        signal(SIGINT, SIG_IGN);
        !            34:        signal(SIGQUIT, SIG_IGN);
        !            35:        times(&obuffer);
        !            36:        while(wait(&status) != p)
        !            37:                times(&obuffer);
        !            38:        time(&after);
        !            39:        if((status&0377) != 0)
        !            40:                fprintf(stderr,"Command terminated abnormally.\n");
        !            41:        times(&buffer);
        !            42:        printt("real", (after-before) * 60);
        !            43:        printt("user", buffer.tms_cutime - obuffer.tms_cutime);
        !            44:        printt("sys ", buffer.tms_cstime - obuffer.tms_cstime);
        !            45:        fprintf(stderr, "\n");
        !            46:        exit(status>>8);
        !            47: }
        !            48: 
        !            49: char quant[] = { 6, 10, 10, 6, 10, 6, 10, 10, 10 };
        !            50: char *pad  = "000      ";
        !            51: char *sep  = "\0\0.\0:\0:\0\0";
        !            52: char *nsep = "\0\0.\0 \0 \0\0";
        !            53: 
        !            54: printt(s, a)
        !            55: char *s;
        !            56: long a;
        !            57: {
        !            58:        char digit[9];
        !            59:        register i;
        !            60:        char c;
        !            61:        int nonzero;
        !            62: 
        !            63:        for(i=0; i<9; i++) {
        !            64:                digit[i] = a % quant[i];
        !            65:                a /= quant[i];
        !            66:        }
        !            67:        nonzero = 0;
        !            68:        while(--i>0) {
        !            69:                c = digit[i]!=0 ? digit[i]+'0':
        !            70:                    nonzero ? '0':
        !            71:                    pad[i];
        !            72:                if (c)
        !            73:                fprintf(stderr,"%c",c);
        !            74:                nonzero |= digit[i];
        !            75:                c = nonzero?sep[i]:nsep[i];
        !            76:                if (c)
        !            77:                fprintf(stderr,"%c",c);
        !            78:        }
        !            79:        fprintf(stderr," %s ",s);
        !            80: }

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