![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to getdate.y CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / news / src|
Return to getdate.y CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / news / src |
1.1 root 1: %token ID MONTH DAY MERIDIAN NUMBER UNIT MUNIT SUNIT ZONE DAYZONE AGO
2: %{
3: /* Steven M. Bellovin (unc!smb) */
4: /* Dept. of Computer Science */
5: /* University of North Carolina at Chapel Hill */
6: /* @(#)getdate.y 2.12 4/16/85 */
7:
8: #include <sys/types.h>
9: #ifdef USG
10: struct timeb
11: {
12: time_t time;
13: unsigned short millitm;
14: short timezone;
15: short dstflag;
16: };
17: #else
18: #include <sys/timeb.h>
19: #endif
20: #include <ctype.h>
21:
22: #include "defs.h"
23: #if defined(BSD4_2) || defined (BSD4_1C)
24: #include <sys/time.h>
25: #else sane
26: #include <time.h>
27: #endif sane
28:
29: #define NULL 0
30: #define daysec (24L*60L*60L)
31: static int timeflag, zoneflag, dateflag, dayflag, relflag;
32: static time_t relsec, relmonth;
33: static int hh, mm, ss, merid, daylight;
34: static int dayord, dayreq;
35: static int month, day, year;
36: static int ourzone;
37: #define AM 1
38: #define PM 2
39: #define DAYLIGHT 1
40: #define STANDARD 2
41: #define MAYBE 3
42: %}
43:
44: %%
45: timedate: /* empty */
46: | timedate item;
47:
48: item: tspec =
49: {timeflag++;}
50: | zone =
51: {zoneflag++;}
52: | dtspec =
53: {dateflag++;}
54: | dyspec =
55: {dayflag++;}
56: | rspec =
57: {relflag++;}
58: | nspec;
59:
60: nspec: NUMBER =
61: {if (timeflag && dateflag && !relflag) year = $1;
62: else {timeflag++;hh = $1/100;mm = $1%100;ss = 0;merid = 24;}};
63:
64: tspec: NUMBER MERIDIAN =
65: {hh = $1; mm = 0; ss = 0; merid = $2;}
66: | NUMBER ':' NUMBER =
67: {hh = $1; mm = $3; merid = 24;}
68: | NUMBER ':' NUMBER MERIDIAN =
69: {hh = $1; mm = $3; merid = $4;}
70: | NUMBER ':' NUMBER ':' NUMBER =
71: {hh = $1; mm = $3; ss = $5; merid = 24;}
72: | NUMBER ':' NUMBER ':' NUMBER MERIDIAN =
73: {hh = $1; mm = $3; ss = $5; merid = $6;};
74:
75: zone: ZONE =
76: {ourzone = $1; daylight = STANDARD;}
77: | DAYZONE =
78: {ourzone = $1; daylight = DAYLIGHT;};
79:
80: dyspec: DAY =
81: {dayord = 1; dayreq = $1;}
82: | DAY ',' =
83: {dayord = 1; dayreq = $1;}
84: | NUMBER DAY =
85: {dayord = $1; dayreq = $2;};
86:
87: dtspec: NUMBER '/' NUMBER =
88: {month = $1; day = $3;}
89: | NUMBER '/' NUMBER '/' NUMBER =
90: {month = $1; day = $3; year = $5;}
91: | MONTH NUMBER =
92: {month = $1; day = $2;}
93: | MONTH NUMBER ',' NUMBER =
94: {month = $1; day = $2; year = $4;}
95: | NUMBER MONTH =
96: {month = $2; day = $1;}
97: | NUMBER MONTH NUMBER =
98: {month = $2; day = $1; year = $3;};
99:
100:
101: rspec: NUMBER UNIT =
102: {relsec += 60L * $1 * $2;}
103: | NUMBER MUNIT =
104: {relmonth += $1 * $2;}
105: | NUMBER SUNIT =
106: {relsec += $1;}
107: | UNIT =
108: {relsec += 60L * $1;}
109: | MUNIT =
110: {relmonth += $1;}
111: | SUNIT =
112: {relsec++;}
113: | rspec AGO =
114: {relsec = -relsec; relmonth = -relmonth;};
115: %%
116:
117: static int mdays[12] =
118: {31, 0, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
119: #define epoch 1970
120:
121: extern struct tm *localtime();
122: time_t dateconv(mm, dd, yy, h, m, s, mer, zone, dayflag)
123: int mm, dd, yy, h, m, s, mer, zone, dayflag;
124: {
125: time_t tod, jdate;
126: register int i;
127: time_t timeconv();
128:
129: if (yy < 0) yy = -yy;
130: if (yy < 100) yy += 1900;
131: mdays[1] = 28 + (yy%4 == 0 && (yy%100 != 0 || yy%400 == 0));
132: if (yy < epoch || yy > 1999 || mm < 1 || mm > 12 ||
133: dd < 1 || dd > mdays[--mm]) return (-1);
134: jdate = dd-1;
135: for (i=0; i<mm; i++) jdate += mdays[i];
136: for (i = epoch; i < yy; i++) jdate += 365 + (i%4 == 0);
137: jdate *= daysec;
138: jdate += zone * 60L;
139: if ((tod = timeconv(h, m, s, mer)) < 0) return (-1);
140: jdate += tod;
141: if (dayflag==DAYLIGHT || (dayflag==MAYBE&&localtime(&jdate)->tm_isdst))
142: jdate += -1*60*60;
143: return (jdate);
144: }
145:
146: time_t dayconv(ord, day, now) int ord, day; time_t now;
147: {
148: register struct tm *loctime;
149: time_t tod;
150: time_t daylcorr();
151:
152: tod = now;
153: loctime = localtime(&tod);
154: tod += daysec * ((day - loctime->tm_wday + 7) % 7);
155: tod += 7*daysec*(ord<=0?ord:ord-1);
156: return daylcorr(tod, now);
157: }
158:
159: time_t timeconv(hh, mm, ss, mer) register int hh, mm, ss, mer;
160: {
161: if (mm < 0 || mm > 59 || ss < 0 || ss > 59) return (-1);
162: switch (mer) {
163: case AM: if (hh < 1 || hh > 12) return(-1);
164: return (60L * ((hh%12)*60L + mm)+ss);
165: case PM: if (hh < 1 || hh > 12) return(-1);
166: return (60L * ((hh%12 +12)*60L + mm)+ss);
167: case 24: if (hh < 0 || hh > 23) return (-1);
168: return (60L * (hh*60L + mm)+ss);
169: default: return (-1);
170: }
171: }
172: time_t monthadd(sdate, relmonth) time_t sdate, relmonth;
173: {
174: struct tm *ltime;
175: time_t dateconv();
176: time_t daylcorr();
177: int mm, yy;
178:
179: if (relmonth == 0) return 0;
180: ltime = localtime(&sdate);
181: mm = 12*ltime->tm_year + ltime->tm_mon + relmonth;
182: yy = mm/12;
183: mm = mm%12 + 1;
184: return daylcorr(dateconv(mm, ltime->tm_mday, yy, ltime->tm_hour,
185: ltime->tm_min, ltime->tm_sec, 24, ourzone, MAYBE), sdate);
186: }
187:
188: time_t daylcorr(future, now) time_t future, now;
189: {
190: int fdayl, nowdayl;
191:
192: nowdayl = (localtime(&now)->tm_hour+1) % 24;
193: fdayl = (localtime(&future)->tm_hour+1) % 24;
194: return (future-now) + 60L*60L*(nowdayl-fdayl);
195: }
196:
197: static char *lptr;
198:
199: yylex()
200: {
201: extern int yylval;
202: int sign;
203: register char c;
204: register char *p;
205: char idbuf[20];
206: int pcnt;
207:
208: for (;;) {
209: while (isspace(*lptr)) lptr++;
210:
211: if (isdigit(c = *lptr) || c == '-' || c == '+') {
212: if (c== '-' || c == '+') {
213: if (c=='-') sign = -1;
214: else sign = 1;
215: if (!isdigit(*++lptr)) {
216: /* yylval = sign; return (NUMBER); */
217: return yylex(); /* skip the '-' sign */
218: }
219: } else sign = 1;
220: yylval = 0;
221: while (isdigit(c = *lptr++)) yylval = 10*yylval + c - '0';
222: yylval *= sign;
223: lptr--;
224: return (NUMBER);
225:
226: } else if (isalpha(c)) {
227: p = idbuf;
228: while (isalpha(c = *lptr++) || c=='.')
229: *p++ = c;
230: *p = '\0';
231: lptr--;
232: return (lookup(idbuf));
233: }
234:
235: else if (c == '(') {
236: pcnt = 0;
237: do {
238: c = *lptr++;
239: if (c == '\0') return(c);
240: else if (c == '(') pcnt++;
241: else if (c == ')') pcnt--;
242: } while (pcnt > 0);
243: }
244:
245: else return (*lptr++);
246: }
247: }
248:
249: struct table {
250: char *name;
251: int type, value;
252: };
253:
254: struct table mdtab[] = {
255: {"January", MONTH, 1},
256: {"February", MONTH, 2},
257: {"March", MONTH, 3},
258: {"April", MONTH, 4},
259: {"May", MONTH, 5},
260: {"June", MONTH, 6},
261: {"July", MONTH, 7},
262: {"August", MONTH, 8},
263: {"September", MONTH, 9},
264: {"Sept", MONTH, 9},
265: {"October", MONTH, 10},
266: {"November", MONTH, 11},
267: {"December", MONTH, 12},
268:
269: {"Sunday", DAY, 0},
270: {"Monday", DAY, 1},
271: {"Tuesday", DAY, 2},
272: {"Tues", DAY, 2},
273: {"Wednesday", DAY, 3},
274: {"Wednes", DAY, 3},
275: {"Thursday", DAY, 4},
276: {"Thur", DAY, 4},
277: {"Thurs", DAY, 4},
278: {"Friday", DAY, 5},
279: {"Saturday", DAY, 6},
280: {0, 0, 0}};
281:
282: #define HRS *60
283: #define HALFHR 30
284: struct table mztab[] = {
285: {"a.m.", MERIDIAN, AM},
286: {"am", MERIDIAN, AM},
287: {"p.m.", MERIDIAN, PM},
288: {"pm", MERIDIAN, PM},
289: {"nst", ZONE, 3 HRS + HALFHR}, /* Newfoundland */
290: {"n.s.t.", ZONE, 3 HRS + HALFHR},
291: {"ast", ZONE, 4 HRS}, /* Atlantic */
292: {"a.s.t.", ZONE, 4 HRS},
293: {"adt", DAYZONE, 4 HRS},
294: {"a.d.t.", DAYZONE, 4 HRS},
295: {"est", ZONE, 5 HRS}, /* Eastern */
296: {"e.s.t.", ZONE, 5 HRS},
297: {"edt", DAYZONE, 5 HRS},
298: {"e.d.t.", DAYZONE, 5 HRS},
299: {"cst", ZONE, 6 HRS}, /* Central */
300: {"c.s.t.", ZONE, 6 HRS},
301: {"cdt", DAYZONE, 6 HRS},
302: {"c.d.t.", DAYZONE, 6 HRS},
303: {"mst", ZONE, 7 HRS}, /* Mountain */
304: {"m.s.t.", ZONE, 7 HRS},
305: {"mdt", DAYZONE, 7 HRS},
306: {"m.d.t.", DAYZONE, 7 HRS},
307: {"pst", ZONE, 8 HRS}, /* Pacific */
308: {"p.s.t.", ZONE, 8 HRS},
309: {"pdt", DAYZONE, 8 HRS},
310: {"p.d.t.", DAYZONE, 8 HRS},
311: {"yst", ZONE, 9 HRS}, /* Yukon */
312: {"y.s.t.", ZONE, 9 HRS},
313: {"ydt", DAYZONE, 9 HRS},
314: {"y.d.t.", DAYZONE, 9 HRS},
315: {"hst", ZONE, 10 HRS}, /* Hawaii */
316: {"h.s.t.", ZONE, 10 HRS},
317: {"hdt", DAYZONE, 10 HRS},
318: {"h.d.t.", DAYZONE, 10 HRS},
319:
320: {"gmt", ZONE, 0 HRS},
321: {"g.m.t.", ZONE, 0 HRS},
322: {"bst", DAYZONE, 0 HRS}, /* British Summer Time */
323: {"b.s.t.", DAYZONE, 0 HRS},
324: {"eet", ZONE, 0 HRS}, /* European Eastern Time */
325: {"e.e.t.", ZONE, 0 HRS},
326: {"eest", DAYZONE, 0 HRS}, /* European Eastern Summer Time */
327: {"e.e.s.t.", DAYZONE, 0 HRS},
328: {"met", ZONE, -1 HRS}, /* Middle European Time */
329: {"m.e.t.", ZONE, -1 HRS},
330: {"mest", DAYZONE, -1 HRS}, /* Middle European Summer Time */
331: {"m.e.s.t.", DAYZONE, -1 HRS},
332: {"wet", ZONE, -2 HRS }, /* Western European Time */
333: {"w.e.t.", ZONE, -2 HRS },
334: {"west", DAYZONE, -2 HRS}, /* Western European Summer Time */
335: {"w.e.s.t.", DAYZONE, -2 HRS},
336:
337: {"jst", ZONE, -9 HRS}, /* Japan Standard Time */
338: {"j.s.t.", ZONE, -9 HRS}, /* Japan Standard Time */
339: /* No daylight savings time */
340:
341: {"aest", ZONE, -10 HRS}, /* Australian Eastern Time */
342: {"a.e.s.t.", ZONE, -10 HRS},
343: {"aesst", DAYZONE, -10 HRS}, /* Australian Eastern Summer Time */
344: {"a.e.s.s.t.", DAYZONE, -10 HRS},
345: {"acst", ZONE, -(9 HRS + HALFHR)}, /* Australian Central Time */
346: {"a.c.s.t.", ZONE, -(9 HRS + HALFHR)},
347: {"acsst", DAYZONE, -(9 HRS + HALFHR)}, /* Australian Central Summer */
348: {"a.c.s.s.t.", DAYZONE, -(9 HRS + HALFHR)},
349: {"awst", ZONE, -8 HRS}, /* Australian Western Time */
350: {"a.w.s.t.", ZONE, -8 HRS}, /* (no daylight time there, I'm told */
351: {0, 0, 0}};
352:
353: struct table unittb[] = {
354: {"year", MUNIT, 12},
355: {"month", MUNIT, 1},
356: {"fortnight", UNIT, 14*24*60},
357: {"week", UNIT, 7*24*60},
358: {"day", UNIT, 1*24*60},
359: {"hour", UNIT, 60},
360: {"minute", UNIT, 1},
361: {"min", UNIT, 1},
362: {"second", SUNIT, 1},
363: {"sec", SUNIT, 1},
364: {0, 0, 0}};
365:
366: struct table othertb[] = {
367: {"tomorrow", UNIT, 1*24*60},
368: {"yesterday", UNIT, -1*24*60},
369: {"today", UNIT, 0},
370: {"now", UNIT, 0},
371: {"last", NUMBER, -1},
372: {"this", UNIT, 0},
373: {"next", NUMBER, 2},
374: {"first", NUMBER, 1},
375: /* {"second", NUMBER, 2}, */
376: {"third", NUMBER, 3},
377: {"fourth", NUMBER, 4},
378: {"fifth", NUMBER, 5},
379: {"sixth", NUMBER, 6},
380: {"seventh", NUMBER, 7},
381: {"eigth", NUMBER, 8},
382: {"ninth", NUMBER, 9},
383: {"tenth", NUMBER, 10},
384: {"eleventh", NUMBER, 11},
385: {"twelfth", NUMBER, 12},
386: {"ago", AGO, 1},
387: {0, 0, 0}};
388:
389: struct table milzone[] = {
390: {"a", ZONE, 1 HRS},
391: {"b", ZONE, 2 HRS},
392: {"c", ZONE, 3 HRS},
393: {"d", ZONE, 4 HRS},
394: {"e", ZONE, 5 HRS},
395: {"f", ZONE, 6 HRS},
396: {"g", ZONE, 7 HRS},
397: {"h", ZONE, 8 HRS},
398: {"i", ZONE, 9 HRS},
399: {"k", ZONE, 10 HRS},
400: {"l", ZONE, 11 HRS},
401: {"m", ZONE, 12 HRS},
402: {"n", ZONE, -1 HRS},
403: {"o", ZONE, -2 HRS},
404: {"p", ZONE, -3 HRS},
405: {"q", ZONE, -4 HRS},
406: {"r", ZONE, -5 HRS},
407: {"s", ZONE, -6 HRS},
408: {"t", ZONE, -7 HRS},
409: {"u", ZONE, -8 HRS},
410: {"v", ZONE, -9 HRS},
411: {"w", ZONE, -10 HRS},
412: {"x", ZONE, -11 HRS},
413: {"y", ZONE, -12 HRS},
414: {"z", ZONE, 0 HRS},
415: {0, 0, 0}};
416:
417: lookup(id) char *id;
418: {
419: #define gotit (yylval=i->value, i->type)
420: #define getid for(j=idvar, k=id; *j++ = *k++; )
421:
422: char idvar[20];
423: register char *j, *k;
424: register struct table *i;
425: int abbrev;
426:
427: getid;
428: if (strlen(idvar) == 3) abbrev = 1;
429: else if (strlen(idvar) == 4 && idvar[3] == '.') {
430: abbrev = 1;
431: idvar[3] = '\0';
432: }
433: else abbrev = 0;
434:
435: if (islower(*idvar)) *idvar = toupper(*idvar);
436:
437: for (i = mdtab; i->name; i++) {
438: k = idvar;
439: for (j = i->name; *j++ == *k++;) {
440: if (abbrev && j==i->name+3) return gotit;
441: if (j[-1] == 0) return gotit;
442: }
443: }
444:
445: getid;
446: for (i = mztab; i->name; i++)
447: if (strcmp(i->name, idvar) == 0) return gotit;
448:
449: for (j = idvar; *j; j++) if (isupper(*j)) *j = tolower(*j);
450: for (i=mztab; i->name; i++)
451: if (strcmp(i->name, idvar) == 0) return gotit;
452:
453: getid;
454: for (i=unittb; i->name; i++)
455: if (strcmp(i->name, idvar) == 0) return gotit;
456:
457: if (idvar[strlen(idvar)-1] == 's') idvar[strlen(idvar)-1] = '\0';
458: for (i=unittb; i->name; i++)
459: if (strcmp(i->name, idvar) == 0) return gotit;
460:
461: getid;
462: for (i = othertb; i->name; i++)
463: if (strcmp(i->name, idvar) == 0) return gotit;
464:
465: getid;
466: if (strlen(idvar) == 1 && isalpha(*idvar)) {
467: if (isupper(*idvar)) *idvar = tolower(*idvar);
468: for (i = milzone; i->name; i++)
469: if (strcmp(i->name, idvar) == 0) return gotit;
470: }
471:
472: return(ID);
473: }
474:
475: time_t getdate(p, now) char *p; struct timeb *now;
476: {
477: #define mcheck(f) if (f>1) err++
478: time_t monthadd();
479: int err;
480: struct tm *lt;
481: struct timeb ftz;
482:
483: time_t sdate, tod;
484:
485: lptr = p;
486: if (now == ((struct timeb *) NULL)) {
487: now = &ftz;
488: ftime(&ftz);
489: }
490: lt = localtime(&now->time);
491: year = lt->tm_year;
492: month = lt->tm_mon+1;
493: day = lt->tm_mday;
494: relsec = 0; relmonth = 0;
495: timeflag=zoneflag=dateflag=dayflag=relflag=0;
496: ourzone = now->timezone;
497: daylight = MAYBE;
498: hh = mm = ss = 0;
499: merid = 24;
500:
501: if (err = yyparse()) return (-1);
502:
503: mcheck(timeflag);
504: mcheck(zoneflag);
505: mcheck(dateflag);
506: mcheck(dayflag);
507:
508: if (err) return (-1);
509: if (dateflag || timeflag || dayflag) {
510: sdate = dateconv(month,day,year,hh,mm,ss,merid,ourzone,daylight);
511: if (sdate < 0) return -1;
512: }
513: else {
514: sdate = now->time;
515: if (relflag == 0)
516: sdate -= (lt->tm_sec + lt->tm_min*60 +
517: lt->tm_hour*(60L*60L));
518: }
519:
520: sdate += relsec;
521: sdate += monthadd(sdate, relmonth);
522:
523: if (dayflag && !dateflag) {
524: tod = dayconv(dayord, dayreq, sdate);
525: sdate += tod;
526: }
527:
528: return sdate;
529: }
530:
531: yyerror(s) char *s;
532: {}
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.