![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to partime.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / rcs / src|
Return to partime.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / rcs / src |
1.1 root 1: /*
2: * PARTIME parse date/time string into a TM structure
3: *
4: * Usage:
5: * #include "time.h" -- expanded tm structure
6: * char *str; struct tm *tp;
7: * partime(str,tp);
8: * Returns:
9: * 0 if parsing failed
10: * else time values in specified TM structure (unspecified values
11: * set to TMNULL)
12: * Notes:
13: * This code is quasi-public; it may be used freely in like software.
14: * It is not to be sold, nor used in licensed software without
15: * permission of the author.
16: * For everyone's benefit, please report bugs and improvements!
17: * Copyright 1980 by Ken Harrenstien, SRI International.
18: * (ARPANET: KLH @ SRI)
19: */
20:
21: /* Hacknotes:
22: * If parsing changed so that no backup needed, could perhaps modify
23: * to use a FILE input stream. Need terminator, though.
24: * Perhaps should return 0 on success, else a non-zero error val?
25: * Flush AMPM from TM structure and handle locally within PARTIME,
26: * like midnight/noon?
27: */
28:
29: static char rcsid[]=
30: "$Header: /usr/wft/RCS/SRC/RCS/partime.c,v 1.1 82/05/06 11:38:26 wft Exp $";
31:
32: /* $Log: partime.c,v $
33: * Revision 1.1 82/05/06 11:38:26 wft
34: * Initial revision
35: *
36: */
37:
38: #include <stdio.h>
39: #include <ctype.h>
40: #include "time.h"
41:
42: static char timeid[] = TIMEID;
43:
44: struct tmwent {
45: char *went;
46: int wval;
47: char wflgs;
48: char wtype;
49: };
50: /* wflgs */
51: #define TWSPEC 01 /* Word wants special processing */
52: #define TWTIME 02 /* Word is a time value (absence implies date) */
53: #define TWDST 04 /* Word is a DST-type timezone */
54: #define TW1200 010 /* Word is NOON or MIDNIGHT (sigh) */
55:
56: int pt12hack();
57: int ptnoise();
58: struct tmwent tmwords [] = {
59: {"january",
60: 0,
61: 0,
62: TM_MON},
63: {"february", 1, 0, TM_MON},
64: {"march", 2, 0, TM_MON},
65: {"april", 3, 0, TM_MON},
66: {"may", 4, 0, TM_MON},
67: {"june", 5, 0, TM_MON},
68: {"july", 6, 0, TM_MON},
69: {"august", 7, 0, TM_MON},
70: {"september", 8, 0, TM_MON},
71: {"october", 9, 0, TM_MON},
72: {"november", 10, 0, TM_MON},
73: {"december", 11, 0, TM_MON},
74:
75: {"sunday", 0, 0, TM_WDAY},
76: {"monday", 1, 0, TM_WDAY},
77: {"tuesday", 2, 0, TM_WDAY},
78: {"wednesday", 3, 0, TM_WDAY},
79: {"thursday", 4, 0, TM_WDAY},
80: {"friday", 5, 0, TM_WDAY},
81: {"saturday", 6, 0, TM_WDAY},
82:
83: {"gmt", 0*60, TWTIME, TM_ZON}, /* Greenwich */
84: {"gst", 0*60, TWTIME, TM_ZON},
85: {"gdt", 0*60, TWTIME+TWDST, TM_ZON}, /* ?? */
86:
87: {"ast", 4*60, TWTIME, TM_ZON}, /* Atlantic */
88: {"est", 5*60, TWTIME, TM_ZON}, /* Eastern */
89: {"cst", 6*60, TWTIME, TM_ZON}, /* Central */
90: {"mst", 7*60, TWTIME, TM_ZON}, /* Mountain */
91: {"pst", 8*60, TWTIME, TM_ZON}, /* Pacific */
92: {"yst", 9*60, TWTIME, TM_ZON}, /* Yukon */
93: {"hst", 10*60, TWTIME, TM_ZON}, /* Hawaii */
94: {"bst", 11*60, TWTIME, TM_ZON}, /* Bering */
95:
96: {"adt", 4*60, TWTIME+TWDST, TM_ZON}, /* Atlantic */
97: {"edt", 5*60, TWTIME+TWDST, TM_ZON}, /* Eastern */
98: {"cdt", 6*60, TWTIME+TWDST, TM_ZON}, /* Central */
99: {"mdt", 7*60, TWTIME+TWDST, TM_ZON}, /* Mountain */
100: {"pdt", 8*60, TWTIME+TWDST, TM_ZON}, /* Pacific */
101: {"ydt", 9*60, TWTIME+TWDST, TM_ZON}, /* Yukon */
102: {"hdt", 10*60, TWTIME+TWDST, TM_ZON}, /* Hawaii */
103: {"bdt", 11*60, TWTIME+TWDST, TM_ZON}, /* Bering */
104:
105: {"daylight", 1, TWTIME+TWDST, TM_ZON}, /* Local Daylight */
106: {"standard", 1, TWTIME, TM_ZON}, /* Local Standard */
107: {"std", 1, TWTIME, TM_ZON}, /* " " */
108:
109: {"am", 1, TWTIME, TM_AMPM},
110: {"pm", 2, TWTIME, TM_AMPM},
111: {"noon", 12,TWTIME+TW1200, 0}, /* Special frobs */
112: {"midnight", 0, TWTIME+TW1200, 0},
113: {"at", (int)ptnoise, TWSPEC, 0}, /* Noise word */
114:
115: {0, 0, 0, 0}, /* Zero entry to terminate searches */
116: };
117:
118: #define TMWILD (-2) /* Value meaning item specified as wild-card */
119: /* (May use someday...) */
120:
121: struct token {
122: char *tcp; /* pointer to string */
123: int tcnt; /* # chars */
124: char tbrk; /* "break" char */
125: char tbrkl; /* last break char */
126: char tflg; /* 0 = alpha, 1 = numeric */
127: union { /* Resulting value; */
128: int tnum;/* either a #, or */
129: struct tmwent *ttmw;/* ptr to a tmwent. */
130: } tval;
131: };
132:
133: partime(astr, atm)
134: char *astr;
135: struct tm *atm;
136: { register int *tp;
137: register struct tmwent *twp;
138: register int i;
139: struct token btoken, atoken;
140: char *cp, ch;
141: int ord, midnoon;
142: int (*aproc)();
143:
144: tp = (int *)atm;
145: zaptime(tp); /* Initialize the TM structure */
146: midnoon = TMNULL; /* and our own temp stuff */
147: btoken.tcnt = btoken.tbrkl = 0;
148: btoken.tcp = astr;
149:
150: domore:
151: if(!ptitoken(btoken.tcp+btoken.tcnt,&btoken)) /* Get a token */
152: { if(btoken.tval.tnum) return(0); /* Read error? */
153: if(midnoon != TMNULL) /* EOF, wrap up */
154: return(pt12hack(tp, midnoon));
155: return(1); /* Win return! */
156: }
157: if(btoken.tflg == 0) /* Alpha? */
158: { twp = btoken.tval.ttmw; /* Yes, get ptr to entry */
159: if(twp->wflgs&TWSPEC) /* Special alpha crock */
160: { aproc = (int (*) ()) (twp->wval);
161: if(!(*aproc)(tp, twp, &btoken))
162: return(0); /* ERR: special word err */
163: goto domore;
164: }
165: if(twp->wflgs&TW1200)
166: if(ptstash(&midnoon,twp->wval))
167: return(0); /* ERR: noon/midnite clash */
168: else goto domore;
169: if(ptstash(&tp[twp->wtype],twp->wval))
170: return(0); /* ERR: val already set */
171: if(twp->wtype == TM_ZON) /* If was zone, hack DST */
172: if(ptstash(&tp[TM_ISDST],(twp->wflgs&TWDST)))
173: return(0); /* ERR: DST conflict */
174: goto domore;
175: }
176:
177: /* Token is number. Lots of hairy heuristics. */
178: if(btoken.tcnt >= 7) /* More than 6 digits in string? */
179: return(0); /* ERR: number too big */
180: if(btoken.tcnt == 6) /* 6 digits = HHMMSS. Needs special crock */
181: { /* since 6 digits are too big for integer! */
182: i = (btoken.tcp[0]-'0')*10 /* Gobble 1st 2 digits */
183: + btoken.tcp[1]-'0';
184: btoken.tcnt = 2; /* re-read last 4 chars */
185: goto coltime;
186: }
187:
188: i = btoken.tval.tnum; /* Value now known to be valid; get it. */
189: if( btoken.tcnt == 5 /* 5 digits = HMMSS */
190: || btoken.tcnt == 3) /* 3 digits = HMM */
191: { if(btoken.tcnt != 3)
192: if(ptstash(&tp[TM_SEC], i%100))
193: return(0); /* ERR: sec conflict */
194: else i /= 100;
195: hhmm4: if(ptstash(&tp[TM_MIN], i%100))
196: return(0); /* ERR: min conflict */
197: i /= 100;
198: hh2: if(ptstash(&tp[TM_HOUR], i))
199: return(0); /* ERR: hour conflict */
200: goto domore;
201: }
202:
203: if(btoken.tcnt == 4) /* 4 digits = YEAR or HHMM */
204: { if(tp[TM_YEAR] != TMNULL) goto hhmm4; /* Already got yr? */
205: if(tp[TM_HOUR] != TMNULL) goto year4; /* Already got hr? */
206: if((i%100) > 59) goto year4; /* MM >= 60? */
207: if(btoken.tbrk == ':') /* HHMM:SS ? */
208: if( ptstash(&tp[TM_HOUR],i/100)
209: || ptstash(&tp[TM_MIN], i%100))
210: return(0); /* ERR: hr/min clash */
211: else goto coltm2; /* Go handle SS */
212: if(btoken.tbrk != ',' && btoken.tbrk != '/'
213: && ptitoken(btoken.tcp+btoken.tcnt,&atoken) /* Peek */
214: && atoken.tflg == 0 /* alpha */
215: && (atoken.tval.ttmw->wflgs&TWTIME)) /* HHMM-ZON */
216: goto hhmm4;
217: if(btoken.tbrkl == '-' /* DD-Mon-YYYY */
218: || btoken.tbrkl == ',' /* Mon DD, YYYY */
219: || btoken.tbrkl == '/' /* MM/DD/YYYY */
220: || btoken.tbrkl == '.' /* DD.MM.YYYY */
221: || btoken.tbrk == '-' /* YYYY-MM-DD */
222: ) goto year4;
223: goto hhmm4; /* Give up, assume HHMM. */
224: }
225:
226: /* From this point on, assume tcnt == 1 or 2 */
227: /* 2 digits = YY, MM, DD, or HH (MM and SS caught at coltime) */
228: if(btoken.tbrk == ':') /* HH:MM[:SS] */
229: goto coltime; /* must be part of time. */
230: if(i > 31) goto yy2; /* If >= 32, only YY poss. */
231:
232: /* Check for numerical-format date */
233: for (cp = "/-."; ch = *cp++;)
234: { ord = (ch == '.' ? 0 : 1); /* n/m = D/M or M/D */
235: if(btoken.tbrk == ch) /* "NN-" */
236: { if(btoken.tbrkl != ch)
237: { if(ptitoken(btoken.tcp+btoken.tcnt,&atoken)
238: && atoken.tflg == 0
239: && atoken.tval.ttmw->wtype == TM_MON)
240: goto dd2;
241: if(ord)goto mm2; else goto dd2; /* "NN-" */
242: } /* "-NN-" */
243: if(tp[TM_DAY] == TMNULL
244: && tp[TM_YEAR] != TMNULL) /* If "YY-NN-" */
245: goto mm2; /* then always MM */
246: if(ord)goto dd2; else goto mm2;
247: }
248: if(btoken.tbrkl == ch /* "-NN" */
249: && tp[ord ? TM_MON : TM_DAY] != TMNULL)
250: if(tp[ord ? TM_DAY : TM_MON] == TMNULL) /* MM/DD */
251: if(ord)goto dd2; else goto mm2;
252: else goto yy2; /* "-YY" */
253: }
254:
255: /* At this point only YY, DD, and HH are left.
256: * YY is very unlikely since value is <= 32 and there was
257: * no numerical format date. Make one last try at YY
258: * before dropping through to DD vs HH code.
259: */
260: if(btoken.tcnt == 2 /* If 2 digits */
261: && tp[TM_HOUR] != TMNULL /* and already have hour */
262: && tp[TM_DAY] != TMNULL /* and day, but */
263: && tp[TM_YEAR] == TMNULL) /* no year, then assume */
264: goto yy2; /* that's what we have. */
265:
266: /* Now reduced to choice between HH and DD */
267: if(tp[TM_HOUR] != TMNULL) goto dd2; /* Have hour? Assume day. */
268: if(tp[TM_DAY] != TMNULL) goto hh2; /* Have day? Assume hour. */
269: if(i > 24) goto dd2; /* Impossible HH means DD */
270: if(!ptitoken(btoken.tcp+btoken.tcnt, &atoken)) /* Read ahead! */
271: if(atoken.tval.tnum) return(0); /* ERR: bad token */
272: else goto dd2; /* EOF, assume day. */
273: if( atoken.tflg == 0 /* If next token is an alpha */
274: && atoken.tval.ttmw->wflgs&TWTIME) /* time-spec, assume hour */
275: goto hh2; /* e.g. "3 PM", "11-EDT" */
276:
277: dd2: if(ptstash(&tp[TM_DAY],i)) /* Store day (1 based) */
278: return(0);
279: goto domore;
280:
281: mm2: if(ptstash(&tp[TM_MON], i-1)) /* Store month (make zero based) */
282: return(0);
283: goto domore;
284:
285: yy2: i += 1900;
286: year4: if(ptstash(&tp[TM_YEAR],i)) /* Store year (full number) */
287: return(0); /* ERR: year conflict */
288: goto domore;
289:
290: /* Hack HH:MM[[:]SS] */
291: coltime:
292: if(ptstash(&tp[TM_HOUR],i)) return(0);
293: if(!ptitoken(btoken.tcp+btoken.tcnt,&btoken))
294: return(!btoken.tval.tnum);
295: if(!btoken.tflg) return(0); /* ERR: HH:<alpha> */
296: if(btoken.tcnt == 4) /* MMSS */
297: if(ptstash(&tp[TM_MIN],btoken.tval.tnum/100)
298: || ptstash(&tp[TM_SEC],btoken.tval.tnum%100))
299: return(0);
300: else goto domore;
301: if(btoken.tcnt != 2
302: || ptstash(&tp[TM_MIN],btoken.tval.tnum))
303: return(0); /* ERR: MM bad */
304: if(btoken.tbrk != ':') goto domore; /* Seconds follow? */
305: coltm2: if(!ptitoken(btoken.tcp+btoken.tcnt,&btoken))
306: return(!btoken.tval.tnum);
307: if(!btoken.tflg || btoken.tcnt != 2 /* Verify SS */
308: || ptstash(&tp[TM_SEC], btoken.tval.tnum))
309: return(0); /* ERR: SS bad */
310: goto domore;
311: }
312:
313: /* Store date/time value, return 0 if successful.
314: * Fails if entry already set to a different value.
315: */
316: ptstash(adr,val)
317: int *adr;
318: { register int *a;
319: if( *(a=adr) != TMNULL)
320: return(*a != val);
321: *a = val;
322: return(0);
323: }
324:
325: /* This subroutine is invoked for NOON or MIDNIGHT when wrapping up
326: * just prior to returning from partime.
327: */
328: pt12hack(atp, aval)
329: int *atp, aval;
330: { register int *tp, i, h;
331: tp = atp;
332: if (((i=tp[TM_MIN]) && i != TMNULL) /* Ensure mins, secs */
333: || ((i=tp[TM_SEC]) && i != TMNULL)) /* are 0 or unspec'd */
334: return(0); /* ERR: MM:SS not 00:00 */
335: i = aval; /* Get 0 or 12 (midnite or noon) */
336: if ((h = tp[TM_HOUR]) == TMNULL /* If hour unspec'd, win */
337: || h == 12) /* or if 12:00 (matches either) */
338: tp[TM_HOUR] = i; /* Then set time */
339: else if(!(i == 0 /* Nope, but if midnight and */
340: &&(h == 0 || h == 24))) /* time matches, can pass. */
341: return(0); /* ERR: HH conflicts */
342: tp[TM_AMPM] = TMNULL; /* Always reset this value if won */
343: return(1);
344: }
345:
346: /* Null routine for no-op tokens */
347:
348: ptnoise() { return(1); }
349:
350: /* Get a token and identify it to some degree.
351: * Returns 0 on failure; token.tval will be 0 for normal EOF, otherwise
352: * hit error of some sort
353: */
354:
355: ptitoken(astr, tkp)
356: register struct token *tkp;
357: struct token *astr;
358: {
359: register char *cp;
360: register int i;
361:
362: tkp->tval.tnum = 0;
363: if(pttoken(astr,tkp) == 0)
364: #ifdef DEBUG
365: printf("EOF\n");
366: #endif DEBUG
367: return(0);
368: cp = tkp->tcp;
369:
370: #ifdef DEBUG
371: i = cp[tkp->tcnt];
372: cp[tkp->tcnt] = 0;
373: printf("Token: \"%s\" ",cp);
374: cp[tkp->tcnt] = i;
375: #endif DEBUG
376:
377: if(tkp->tflg)
378: for(i = tkp->tcnt; i > 0; i--)
379: tkp->tval.tnum = (int)tkp->tval.tnum*10 + ((*cp++)-'0');
380: else
381: { i = ptmatchstr(cp, tkp->tcnt, tmwords, sizeof (struct tmwent));
382: tkp->tval.tnum = i ? i : -1; /* Set -1 for error */
383:
384: #ifdef DEBUG
385: if(!i) printf("Not found!\n");
386: #endif DEBUG
387:
388: if(!i) return(0);
389: }
390:
391: #ifdef DEBUG
392: if(tkp->tflg)
393: printf("Val: %d.\n",tkp->tval.tnum);
394: else printf("Found: \"%s\", val: %d., type %d\n",
395: tkp->tval.ttmw->went,tkp->tval.ttmw->wval,tkp->tval.ttmw->wtype);
396: #endif DEBUG
397:
398: return(1);
399: }
400:
401: /* Read token from input string into token structure */
402: pttoken(astr,tkp)
403: register struct token *tkp;
404: char *astr;
405: {
406: register char *cp;
407: register int c;
408:
409: tkp->tcp = cp = astr;
410: tkp->tbrkl = tkp->tbrk; /* Set "last break" */
411: tkp->tcnt = tkp->tbrk = tkp->tflg = 0;
412:
413: while(c = *cp++)
414: { switch(c)
415: { case ' ': case '\t': /* Flush all whitespace */
416: while((c = *cp++) && isspace(c));
417: cp--; /* Drop thru to handle brk */
418: case '(': case ')': /* Perhaps any non-alphanum */
419: case '-': case ',': /* shd qualify as break? */
420: case '/': case ':': case '.': /* Break chars */
421: if(tkp->tcnt == 0) /* If no token yet */
422: { tkp->tcp = cp; /* ignore the brk */
423: tkp->tbrkl = c;
424: continue; /* and go on. */
425: }
426: tkp->tbrk = c;
427: return(tkp->tcnt);
428: }
429: if(tkp->tcnt == 0) /* If first char of token, */
430: tkp->tflg = isdigit(c); /* determine type */
431: if(( isdigit(c) && tkp->tflg) /* If not first, make sure */
432: ||(!isdigit(c) && !tkp->tflg)) /* char matches type */
433: tkp->tcnt++; /* Win, add to token. */
434: else {
435: cp--; /* Wrong type, back up */
436: tkp->tbrk = c;
437: return(tkp->tcnt);
438: }
439: }
440: return(tkp->tcnt); /* When hit EOF */
441: }
442:
443:
444: ptmatchstr(astr,cnt,astruc,size)
445: char *astr;
446: int cnt,size;
447: struct tmwent *astruc;
448: { register char *cp, *mp;
449: register int c;
450: struct tmwent *lastptr;
451: struct integ { int word; }; /* For getting at array ptr */
452: int i;
453:
454: lastptr = 0;
455: for(;mp = (char *)((struct integ *)astruc)->word; astruc += 1)
456: { cp = astr;
457: for(i = cnt; i > 0; i--)
458: { switch((c = *cp++) ^ *mp++) /* XOR the chars */
459: { case 0: continue; /* Exact match */
460: case 040: if(isalpha(c))
461: continue;
462: }
463: break;
464: }
465: if(i==0)
466: if(*mp == 0) return((unsigned int)astruc); /* Exact match */
467: else if(lastptr) return(0); /* Ambiguous */
468: else lastptr = astruc; /* 1st ambig */
469: }
470: return((unsigned int)lastptr);
471: }
472:
473:
474:
475: zaptime(atm)
476: struct tm *atm;
477: /* clears atm */
478: { register int *tp, i;
479: tp = (int *)atm;
480: i = (sizeof (struct tm))/(sizeof (int));
481: do *tp++ = TMNULL; /* Set entry to "unspecified" */
482: while(--i); /* Faster than FOR */
483: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.