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