Return to date.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / spms / src / bin / plog

Annotation of 43BSD/contrib/spms/src/bin/plog/date.c, revision 1.1.1.1

1.1       root        1: /* $Header$ */
                      2: 
                      3: #include <ctype.h>
                      4: #include "date.h"
                      5: #include "null.h"
                      6: #include "yesno.h"
                      7: /*
                      8:  * date template character codes
                      9:  */
                     10: #define        L       1                       /* a lower case chararacter */
                     11: #define U      2                       /* an upper case character */
                     12: #define        S       3                       /* a space */
                     13: #define        D       4                       /* a digit */
                     14: #define        O       5                       /* an optional digit or space */
                     15: #define        C       6                       /* a colon */
                     16: #define        N       7                       /* a newline */
                     17: /*
                     18:  * date templates
                     19:  */
                     20: static char ctypes[] =
                     21:        {U,L,L,S,U,L,L,S,O,D,S,D,D,C,D,D,C,D,D,S,D,D,D,D,0};
                     22: static char tmztypes[] =
                     23:        {U,L,L,S,U,L,L,S,O,D,S,D,D,C,D,D,C,D,D,S,U,U,U,S,D,D,D,D,0};
                     24: static char *mon_tab[] =
                     25:        {
                     26:        "illegal month",
                     27:        "Jan",
                     28:        "Feb",
                     29:        "Mar",
                     30:        "Apr",
                     31:        "May",
                     32:        "Jun",
                     33:        "Jul",
                     34:        "Aug",
                     35:        "Sep",
                     36:        "Oct",
                     37:        "Nov",
                     38:        "Dec"
                     39:        };
                     40: /*
                     41:  * cmatch() matchs a date against a given template. Returns constant 1 if
                     42:  * there is a match, otherwise 0.
                     43:  */
                     44: static
                     45: cmatch(date, template)
                     46:        register char *date;            /* date string */
                     47:        register char *template;        /* template array */
                     48: {
                     49:        register int c;                 /* comparison character */
                     50: 
                     51:        for (c = *date++; c != '\0' && *template != 0; c= *date++)
                     52:                switch (*template++)
                     53:                        {
                     54:                case L:
                     55:                        if (!islower(c))
                     56:                                return(0);
                     57:                        break;
                     58:                case U:
                     59:                        if (!isupper(c))
                     60:                                return(0);
                     61:                        break;
                     62:                case S:
                     63:                        if (c != ' ')
                     64:                                return(0);
                     65:                        break;
                     66:                case D:
                     67:                        if (!isdigit(c))
                     68:                                return(0);
                     69:                        break;
                     70:                case O:
                     71:                        if (c != ' ' && !isdigit(c))
                     72:                                return(0);
                     73:                        break;
                     74:                case C:
                     75:                        if (c != ':')
                     76:                                return(0);
                     77:                        break;
                     78:                case N:
                     79:                        if (c != '\n')
                     80:                                return(0);
                     81:                        break;
                     82:                }
                     83:        if (c != '\0' || *template != 0)
                     84:                return(0);
                     85:        return(1);
                     86: }
                     87: 
                     88: 
                     89: 
                     90: /*
                     91:  * isdate() tests if date is a ctime(3) generated date string.
                     92:  * The ctypes template is used as the criterion of correctness. Also
                     93:  * a possible trailing timezone is checked by the tmztype template.
                     94:  * Returns constant 1 if valid, otherwise 0.
                     95:  */
                     96: isdate(date)
                     97:        char *date;                     /* date string */
                     98: {
                     99:        int cmatch();                   /* match date against template */
                    100: 
                    101:        if (cmatch(date, ctypes) == 1)
                    102:                return(1);
                    103:        return(cmatch(date, tmztypes));
                    104: }
                    105: 
                    106: 
                    107: 
                    108: /*
                    109:  * parsedate() breaks down the time returned by ctime(3) into a DATE
                    110:  * struct. Returns constant NO if a bad date, otherwise YES.
                    111:  */
                    112: parsedate(cdate, dt)
                    113:        char *cdate;                    /* ctime(3) generated date string */
                    114:        DATE *dt;                       /* pointer to broken-down time struct */
                    115: {
                    116:        int atoi();                     /* convert alpha string to integer */
                    117:        int cmatch();                   /* match date against template */
                    118:        int strncmp();                  /* compare n characters in string */
                    119: 
                    120:        if (cmatch(cdate, ctypes) == 1)
                    121:                {
                    122:                dt->t_year = atoi(cdate+20);
                    123:                }
                    124:        else if (cmatch(cdate, tmztypes) == 1)
                    125:                {
                    126:                dt->t_year = atoi(cdate+24);
                    127:                }
                    128:        else    {
                    129:                return(NO);
                    130:                }
                    131:        for (dt->t_mon = 12; dt->t_mon > 0; dt->t_mon--)
                    132:                if (strncmp(mon_tab[dt->t_mon], cdate+4, 3) == 0)
                    133:                        break;
                    134:        if (dt->t_mon <= 0)
                    135:                return(NO);
                    136:        dt->t_day = atoi(cdate+8);
                    137:        dt->t_hour = atoi(cdate+11);
                    138:        dt->t_min = atoi(cdate+14);
                    139:        dt->t_sec = atoi(cdate+17);
                    140:        return(YES);
                    141: }

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