Return to time.c CVS log

Up to [Research Unix] / researchv10no / cmd / 2500

Annotation of researchv10no/cmd/2500/time.c, revision 1.1.1.1

1.1       root        1: #include       "hdr.h"
                      2: 
                      3: Time
                      4: gettime()
                      5: {
                      6:        char buf[64];
                      7:        Time t;
                      8: 
                      9:        if(cmd(4, "timer", buf, "%c%c%c", 0x61, 0x0C, 1)){
                     10:                t.h = t.m = t.s = t.f = 0;
                     11:                return(t);
                     12:        }
                     13:        return(atotime(buf+2));
                     14: }
                     15: 
                     16: settimer(t, who)
                     17:        Time t;
                     18: {
                     19:        cmd(0, "settimer", (char *)0, "%c%c%t", 0x44, who, t);
                     20: }
                     21: 
                     22: timer(type)
                     23: {
                     24:        char buf[64];
                     25:        Time t;
                     26: 
                     27:        if(cmd(4, "timer", buf, "%c%c%c", 0x61, 0x0C, type))
                     28:                return;
                     29:        t = atotime(buf+2);
                     30:        switch(buf[1])
                     31:        {
                     32:        case 0x04:      print("LTC: %T\n", t); break;
                     33:        case 0x14:      print("corrected LTC: %T\n", t); break;
                     34:        case 0x06:      print("VITC: %T\n", t); break;
                     35:        case 0x00:      print("TIMER-1: %T\n", t); break;
                     36:        case 0x01:      print("TIMER-2: %T\n", t); break;
                     37:        default:        print("unexpect timer return type %2.2ux\n", buf[1]);
                     38:        }
                     39: }
                     40: 
                     41: Time
                     42: atotime(b)
                     43:        char *b;
                     44: {
                     45: #define        M(x)    ((((x)>>4)&0x7)*10 + ((x)&0xF))
                     46:        Time t;
                     47: 
                     48:        t.f = M(b[0]&0x3F);
                     49:        t.s = M(b[1]);
                     50:        t.m = M(b[2]);
                     51:        t.h = M(b[3]);
                     52:        return(t);
                     53: }
                     54: 
                     55: taddfr(t, n)
                     56:        register Time *t;
                     57: {
                     58:        t->f += n;
                     59:        if(t->f >= 30){
                     60:                t->s += t->f/30;
                     61:                t->f %= 30;
                     62:                if(t->s >= 60){
                     63:                        t->m += t->s/60;
                     64:                        t->s %= 60;
                     65:                        if(t->m >= 60){
                     66:                                t->h += t->m/60;
                     67:                                t->m %= 60;
                     68:                        }
                     69:                }
                     70:        }
                     71: }
                     72: 
                     73: timecmp(t0, t1)
                     74:        Time t0, t1;
                     75: {
                     76:        register k;
                     77: 
                     78:        if(k = t0.h - t1.h) return(k);
                     79:        if(k = t0.m - t1.m) return(k);
                     80:        if(k = t0.s - t1.s) return(k);
                     81:        return(t0.f - t1.f);
                     82: }

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