Return to time.c CVS log

Up to [Research Unix] / researchv9 / cmd

Annotation of researchv9/cmd/time.c, revision 1.1.1.1

1.1       root        1: /* time command */
                      2: 
                      3: #include <stdio.h>
                      4: #include <signal.h>
                      5: #include <sys/types.h>
                      6: #include <sys/times.h>
                      7: #include <sys/vtimes.h>
                      8: 
                      9: extern int errno;
                     10: extern char *sys_errlist[];
                     11: int    vflag = 0;
                     12: char   output[BUFSIZ];
                     13: 
                     14: #define        U       0001
                     15: #define        S       0002
                     16: #define        R       0004
                     17: #define        T       0010
                     18: #define        D       0020
                     19: #define        M       0040
                     20: #define        F       0100
                     21: #define        I       0200
                     22: #define        O       0400
                     23: #define        ALL     0777
                     24: 
                     25: #define        t(x)    (flags&x)
                     26: 
                     27: int    flags = U|S|R;
                     28: char   names[] = "usrtdmfio";
                     29: 
                     30: main(argc, argv)
                     31: char **argv;
                     32: {
                     33:        double x;
                     34:        int status;
                     35:        struct vtimes vt;
                     36:        time_t before, after;
                     37:        char buf[BUFSIZ];
                     38:        register char *p;
                     39:        register i, pid;
                     40: 
                     41:        setbuf(stderr, buf);
                     42:        if(argc>1 && argv[1][0]=='-') {
                     43:                flags = 0;
                     44:                for(flags=0; argc>1 && argv[1][0]=='-'; --argc, argv++)
                     45:                        for(p=argv[1]+1; *p; p++) {
                     46:                                if(*p == 'v')
                     47:                                        flags = ALL;
                     48:                                else if((i=index(*p, names)) < 0)
                     49:                                        fprintf(stderr, "time: bad flag %c\n", *p);
                     50:                                else
                     51:                                        flags |= 1<<i;
                     52:                        }
                     53:        }
                     54:        if(argc <= 1) {
                     55:                fprintf(stderr, "usage: time [-usrtdmfio] [-v] cmd\n");
                     56:                exit(1);
                     57:        }
                     58:        time(&before);
                     59:        pid = fork();
                     60:        if(pid == -1) {
                     61:                perror("Try again");
                     62:                exit(1);
                     63:        }
                     64:        if(pid == 0) {
                     65:                execvp(argv[1], &argv[1]);
                     66:                fprintf(stderr, "%s: %s\n", argv[1], sys_errlist[errno]);
                     67:                exit(1);
                     68:        }
                     69:        signal(SIGINT, SIG_IGN);
                     70:        signal(SIGQUIT, SIG_IGN);
                     71:        while(wait(&status) != pid)
                     72:                ;
                     73:        time(&after);
                     74:        vtimes((struct vtimes *)0, &vt);
                     75:        if((status&0377) != 0)
                     76:                fprintf(stderr,"Command terminated abnormally.\n");
                     77:        x = vt.vm_utime+vt.vm_stime;
                     78:        if(t(U))
                     79:                add("%.1fu", (double)vt.vm_utime/60);
                     80:        if(t(S))
                     81:                add("%.1fs", (double)vt.vm_stime/60);
                     82:        if(t(R))
                     83:                add("%dr", after-before);
                     84:        if(t(T))
                     85:                add("%.0ft", vt.vm_ixrss/2/x);
                     86:        if(t(D))
                     87:                add("%.0fd", vt.vm_idsrss/2/x);
                     88:        if(t(M))
                     89:                add("%dm", vt.vm_maxrss/2);
                     90:        if(t(F))
                     91:                add("%df", vt.vm_majflt);
                     92:        if(t(I))
                     93:                add("%di", vt.vm_inblk);
                     94:        if(t(O))
                     95:                add("%do", vt.vm_oublk);
                     96:        add("\t");
                     97:        for(i=1; i<argc; i++) {
                     98:                add("%s", argv[i]);
                     99:                if(i > 4) {
                    100:                        add("...");
                    101:                        break;
                    102:                }
                    103:        }
                    104:        fprintf(stderr, "%s\n", output);
                    105:        return (status&0377)? -1 : (status>>8)&0377;
                    106: }
                    107: add(a, b, c, d, e)
                    108:        char *a;
                    109:        int b, c, d, e;
                    110: {
                    111:        static beenhere=0;
                    112:        if(beenhere)
                    113:                strcat(output, " ");
                    114:        sprintf(output+strlen(output), a, b, c, d, e);
                    115:        beenhere++;
                    116: }
                    117: index(c, s)
                    118:        register char *s;
                    119: {
                    120:        register i;
                    121:        for(i=0; *s; i++, s++)
                    122:                if(*s == c)
                    123:                        return i;
                    124:        return -1;
                    125: }

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