Return to timec.c CVS log

Up to [Research Unix] / researchv9 / libc / gen

Annotation of researchv9/libc/gen/timec.c, revision 1.1.1.1

1.1       root        1: #include <time.h>
                      2: #include <libc.h>
                      3: #include <sys/types.h>
                      4: #include <sys/timeb.h>
                      5: #include <ctype.h>
                      6: 
                      7: static
                      8: reduce(fp,n)
                      9: int *fp;
                     10: {
                     11:        int val = 0;
                     12:        for( ; *fp<0;  *fp+=n)
                     13:                val--;
                     14:        val += *fp/n;
                     15:        *fp %= n;
                     16:        return val;
                     17: }
                     18: 
                     19: static char Month[][3] = {"jan","feb","mar","apr","may","jun",
                     20:                "jul","aug","sep","oct","nov","dec","\0"};
                     21: static char Zone[][3] = {"gmt","est","edt","cst","cdt",
                     22:                "mst","mdt","pst","pdt","\0"};
                     23: static int Diff[] = {0,5*60,4*60,6*60,5*60,7*60,6*60,8*60,7*60};
                     24: static int mday[] = {0,31,59,90,120,151,181,212,243,273,304,334};
                     25: 
                     26: long timegm(tp)
                     27: struct tm *tp;
                     28: {
                     29:        int n;
                     30:        struct tm tm;
                     31:        tm = *tp;
                     32:        tm.tm_year += reduce(&tm.tm_mon, 12);
                     33:        tm.tm_yday += mday[tm.tm_mon] + tm.tm_mday
                     34:                - ((tm.tm_year%4!=0)|(tm.tm_mon<3));
                     35:        tm.tm_min += reduce(&tm.tm_sec, 60);
                     36:        tm.tm_hour += reduce(&tm.tm_min, 60);
                     37:        tm.tm_yday += reduce(&tm.tm_hour, 24);
                     38:        tm.tm_year += 4*reduce(&tm.tm_yday, 4*365+1);
                     39:        while(tm.tm_yday >= (n = 365+((tm.tm_year%4)==0)))
                     40:                tm.tm_yday -= n, tm.tm_year++;
                     41:        return  tm.tm_sec + 60*(tm.tm_min +
                     42:                60*(tm.tm_hour + 24L*(tm.tm_yday +
                     43:                365*(tm.tm_year-70) + (tm.tm_year-69)/4)));
                     44: }
                     45: 
                     46: long timelocal(tp,zone)
                     47: struct tm *tp;
                     48: char *zone;
                     49: {
                     50:        struct timeb systime;
                     51:        long date;
                     52:        date = timegm(tp);
                     53:        if(zone==0) {
                     54:                ftime(&systime);
                     55:                date += systime.timezone*60L;
                     56:                if(systime.dstflag &&
                     57:                   localtime(&date)->tm_isdst)
                     58:                        date -= 3600;
                     59:        } else 
                     60:                date += Diff[serialno(zone,Zone)];
                     61:        return date;
                     62: }
                     63: 
                     64: static char *breaks = "\t ,:\n";
                     65: 
                     66: static char *
                     67: skipfld(s)
                     68: char *s;
                     69: {
                     70:        char *t = strpbrk(s,breaks);
                     71:        return t!=0? t: s+strlen(s);
                     72: }
                     73: 
                     74: static char*
                     75: skipbrk(s)
                     76: char *s;
                     77: {
                     78:        return s + strspn(s,breaks);
                     79: }
                     80: 
                     81: long
                     82: timec(s)
                     83: char *s;
                     84: {
                     85:        char *t;
                     86:        struct tm tm;
                     87:        char *zone = 0;
                     88:        tm.tm_sec = tm.tm_min = tm.tm_hour = 0;
                     89:        tm.tm_mon = tm.tm_mday = tm.tm_yday = 0;
                     90:        for(s=skipbrk(s); isalpha(*s); s=skipbrk(skipfld(s)))
                     91:                tm.tm_mon = serialno(s,Month);
                     92:        tm.tm_mday = atoi(s);
                     93:        s = skipbrk(skipfld(s));
                     94:        t = skipfld(s);
                     95:        if(*t==':') {
                     96:                tm.tm_hour = atoi(s);
                     97:                tm.tm_min = atoi(++t);
                     98:                t = skipfld(t);
                     99:                if(*t==':') {
                    100:                        tm.tm_sec = atoi(++t);
                    101:                        t = skipfld(t);
                    102:                }
                    103:                s = skipbrk(t);
                    104:        }
                    105:        tm.tm_year = atoi(s);
                    106:        if(tm.tm_year!=0)
                    107:                s = skipbrk(skipfld(s));
                    108:        if(isalpha(*s)) {
                    109:                zone = s;
                    110:                s = skipbrk(skipfld(s));
                    111:        }
                    112:        if(tm.tm_year==0)
                    113:                tm.tm_year = atoi(s);
                    114:        tm.tm_year -= 1900;
                    115:        if(tm.tm_year < 0) {
                    116:                long clock;
                    117:                time(&clock);
                    118:                tm.tm_year = localtime(&clock)->tm_year;
                    119:                if(timelocal(&tm,zone) > clock)
                    120:                        tm.tm_year--;
                    121:        }
                    122:        return timelocal(&tm,zone);
                    123: }
                    124: 
                    125: static
                    126: serialno(item,list)
                    127: char *item, list[][3];
                    128: {
                    129:        register i,j;
                    130:        for(i=0; list[i][0]; i++)
                    131:                for(j=0; j<3; j++)
                    132:                        if(tolower(item[j])!=list[i][j])
                    133:                                break;
                    134:                        else if(j==2)
                    135:                                return i;
                    136:        return 0;
                    137: }

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