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