Return to time.c CVS log

Up to [MW Coherent from dump] / coherent / b / bin

Annotation of coherent/b/bin/time.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * Time command
                      3:  */
                      4: 
                      5: #include <stdio.h>
                      6: #include <sys/timeb.h>
                      7: #include <sys/times.h>
                      8: #include <signal.h>
                      9: #include <sys/machine.h>
                     10: 
                     11: #define        MILLI   1000            /* Parts of a second */
                     12: 
                     13: extern char    *signame[];
                     14: 
                     15: main(argc, argv)
                     16: char *argv[];
                     17: {
                     18:        if (argc <= 1) {
                     19:                exit(0);
                     20:        }
                     21:        dotime(argc-1, argv+1);
                     22:        exit(0);
                     23: }
                     24: 
                     25: dotime(argc, argv)
                     26: char *argv[];
                     27: {
                     28:        int pid, status;
                     29:        register n;
                     30:        struct timeb before, after;
                     31:        struct tbuffer tb;
                     32:        long tdiff;
                     33:        int tpart;
                     34:        char *command = argv[0];
                     35: 
                     36:        ftime(&before);
                     37:        if ((pid = fork()) < 0) {
                     38:                eprint("Try again.\n");
                     39:                exit(1);
                     40:        }
                     41:        if (pid) {
                     42:                signal(SIGHUP, SIG_IGN);
                     43:                signal(SIGINT, SIG_IGN);
                     44:                signal(SIGQUIT, SIG_IGN);
                     45:                signal(SIGTERM, SIG_IGN);
                     46:                while (wait(&status) >= 0)
                     47:                        if (n = status&0177) {
                     48:                                if (n <= NSIG)
                     49:                                        eprint("%s", signame[n]);
                     50:                                else
                     51:                                        eprint("sig. %d", n);
                     52:                                if (status & 0200)
                     53:                                        eprint(" -- core dumped");
                     54:                                fprintf(stderr ,"\n");
                     55:                        }
                     56:                ftime(&after);
                     57:                times(&tb);
                     58:                tdiff = after.time-before.time;
                     59:                tpart = after.millitm - before.millitm;
                     60:                if (tpart < 0) {
                     61:                        tpart += MILLI;
                     62:                        tdiff--;
                     63:                }
                     64:                eprint("\n");
                     65:                output("Real:", tdiff, (tpart+MILLI/20)/(MILLI/10));
                     66:                tpart = tb.tb_cutime%HZ;
                     67:                output("User:", tb.tb_cutime/HZ, (tpart+HZ/20)/(HZ/10));
                     68:                tpart = tb.tb_cstime%HZ;
                     69:                output("Sys: ", tb.tb_cstime/HZ, (tpart+HZ/20)/(HZ/10));
                     70:        } else {
                     71:                execvp(command, argv);
                     72:                eprint("%s: not found\n", command);
                     73:                exit(1);
                     74:        }
                     75:        exit(n);
                     76: }
                     77: 
                     78: /*
                     79:  * Format the output for a time entry.
                     80:  */
                     81: output(name, tsec, tenths)
                     82: char *name;
                     83: long tsec;
                     84: {
                     85:        long hours;
                     86:        int mins;
                     87:        int secs;
                     88: 
                     89:        /*
                     90:         * Fudge for sloppy rounding above
                     91:         */
                     92:        if (tenths > 9) {
                     93:                tenths = 0;
                     94:                tsec++;
                     95:        }
                     96:        hours = tsec/(60*60);
                     97:        tsec %= (60*60);
                     98:        mins = tsec/60;
                     99:        secs = tsec%60;
                    100:        eprint("%s", name);
                    101:        if (hours != 0)
                    102:                eprint("%5d:%02d:%02d", (int)hours, mins, secs);
                    103:        else {
                    104:                eprint("      ");
                    105:                if (mins)
                    106:                        eprint("%2d:%02d", mins, secs);
                    107:                else
                    108:                        eprint("   %2d", secs);
                    109:        }
                    110:        eprint(".%d\n", tenths);
                    111: }
                    112: 
                    113: /* VARARGS */
                    114: eprint(x)
                    115: {
                    116:        fprintf(stderr, "%r", &x);
                    117: }

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