Return to time.c CVS log

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

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

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