chiark / gitweb /
rename recentact to lowvol
[inn-innduct.git] / lib / parsedate.y
1 %{
2 /*  $Id: parsedate.y 6372 2003-05-31 19:48:28Z rra $
3 **
4 **  Originally written by Steven M. Bellovin <smb@research.att.com> while
5 **  at the University of North Carolina at Chapel Hill.  Later tweaked by
6 **  a couple of people on Usenet.  Completely overhauled by Rich $alz
7 **  <rsalz@osf.org> and Jim Berets <jberets@bbn.com> in August, 1990.
8 **  Further revised (removed obsolete constructs and cleaned up timezone
9 **  names) in August, 1991, by Rich.  Paul Eggert <eggert@twinsun.com>
10 **  helped in September, 1992.
11 **
12 **  This grammar has six shift/reduce conflicts.
13 **
14 **  This code is in the public domain and has no copyright.
15 */
16
17 #include "config.h"
18 #include "clibrary.h"
19 #include <ctype.h>
20
21 #if defined(_HPUX_SOURCE)
22 # include <alloca.h>
23 #endif
24
25 #ifdef TM_IN_SYS_TIME
26 # include <sys/time.h>
27 #else
28 # include <time.h>
29 #endif
30
31 #include "libinn.h"
32
33
34 #define yylhs           date_yylhs
35 #define yylen           date_yylen
36 #define yydefred        date_yydefred
37 #define yydgoto         date_yydgoto
38 #define yysindex        date_yysindex
39 #define yyrindex        date_yyrindex
40 #define yygindex        date_yygindex
41 #define yytable         date_yytable
42 #define yycheck         date_yycheck
43 #define yyparse         date_parse
44 #define yylex           date_lex
45 #define yyerror         date_error
46 #define yymaxdepth      date_yymaxdepth
47
48
49 static int date_lex(void);
50
51 int yyparse(void);
52
53     /* See the LeapYears table in Convert. */
54 #define EPOCH           1970
55 #define END_OF_TIME     2038
56     /* Constants for general time calculations. */
57 #define DST_OFFSET      1
58 #define SECSPERDAY      (24L * 60L * 60L)
59     /* Readability for TABLE stuff. */
60 #define HOUR(x)         (x * 60)
61
62 #define LPAREN          '('
63 #define RPAREN          ')'
64 #define IS7BIT(x)       ((unsigned int)(x) < 0200)
65
66
67 /*
68 **  An entry in the lexical lookup table.
69 */
70 typedef struct _TABLE {
71     const char * name;
72     int          type;
73     time_t       value;
74 } TABLE;
75
76 /*
77 **  Daylight-savings mode:  on, off, or not yet known.
78 */
79 typedef enum _DSTMODE {
80     DSTon, DSToff, DSTmaybe
81 } DSTMODE;
82
83 /*
84 **  Meridian:  am, pm, or 24-hour style.
85 */
86 typedef enum _MERIDIAN {
87     MERam, MERpm, MER24
88 } MERIDIAN;
89
90
91 /*
92 **  Global variables.  We could get rid of most of them by using a yacc
93 **  union, but this is more efficient.  (This routine predates the
94 **  yacc %union construct.)
95 */
96 static char     *yyInput;
97 static DSTMODE  yyDSTmode;
98 static int      yyHaveDate;
99 static int      yyHaveRel;
100 static int      yyHaveTime;
101 static time_t   yyTimezone;
102 static time_t   yyDay;
103 static time_t   yyHour;
104 static time_t   yyMinutes;
105 static time_t   yyMonth;
106 static time_t   yySeconds;
107 static time_t   yyYear;
108 static MERIDIAN yyMeridian;
109 static time_t   yyRelMonth;
110 static time_t   yyRelSeconds;
111
112
113 /* extern struct tm     *localtime(); */
114
115 static void             date_error(const char *s);
116 %}
117
118 %union {
119     time_t              Number;
120     enum _MERIDIAN      Meridian;
121 }
122
123 %token  tDAY tDAYZONE tMERIDIAN tMONTH tMONTH_UNIT tSEC_UNIT tSNUMBER
124 %token  tUNUMBER tZONE
125
126 %type   <Number>        tDAYZONE tMONTH tMONTH_UNIT tSEC_UNIT
127 %type   <Number>        tSNUMBER tUNUMBER tZONE numzone zone
128 %type   <Meridian>      tMERIDIAN o_merid
129
130 %%
131
132 spec    : /* NULL */
133         | spec item
134         ;
135
136 item    : time {
137             yyHaveTime++;
138 #if     defined(lint)
139             /* I am compulsive about lint natterings... */
140             if (yyHaveTime == -1) {
141                 YYERROR;
142             }
143 #endif  /* defined(lint) */
144         }
145         | time zone {
146             yyHaveTime++;
147             yyTimezone = $2;
148         }
149         | date {
150             yyHaveDate++;
151         }
152         | rel {
153             yyHaveRel = 1;
154         }
155         ;
156
157 time    : tUNUMBER o_merid {
158             if ($1 < 100) {
159                 yyHour = $1;
160                 yyMinutes = 0;
161             }
162             else {
163                 yyHour = $1 / 100;
164                 yyMinutes = $1 % 100;
165             }
166             yySeconds = 0;
167             yyMeridian = $2;
168         }
169         | tUNUMBER ':' tUNUMBER o_merid {
170             yyHour = $1;
171             yyMinutes = $3;
172             yySeconds = 0;
173             yyMeridian = $4;
174         }
175         | tUNUMBER ':' tUNUMBER numzone {
176             yyHour = $1;
177             yyMinutes = $3;
178             yyTimezone = $4;
179             yyMeridian = MER24;
180             yyDSTmode = DSToff;
181         }
182         | tUNUMBER ':' tUNUMBER ':' tUNUMBER o_merid {
183             yyHour = $1;
184             yyMinutes = $3;
185             yySeconds = $5;
186             yyMeridian = $6;
187         }
188         | tUNUMBER ':' tUNUMBER ':' tUNUMBER numzone {
189             yyHour = $1;
190             yyMinutes = $3;
191             yySeconds = $5;
192             yyTimezone = $6;
193             yyMeridian = MER24;
194             yyDSTmode = DSToff;
195         }
196         ;
197
198 zone    : tZONE {
199             $$ = $1;
200             yyDSTmode = DSToff;
201         }
202         | tDAYZONE {
203             $$ = $1;
204             yyDSTmode = DSTon;
205         }
206         | tZONE numzone {
207             /* Only allow "GMT+300" and "GMT-0800" */
208             if ($1 != 0) {
209                 YYABORT;
210             }
211             $$ = $2;
212             yyDSTmode = DSToff;
213         }
214         | numzone {
215             $$ = $1;
216             yyDSTmode = DSToff;
217         }
218         ;
219
220 numzone : tSNUMBER {
221             int         i;
222
223             /* Unix and GMT and numeric timezones -- a little confusing. */
224             if ($1 < 0) {
225                 /* Don't work with negative modulus. */
226                 $1 = -$1;
227                 if ($1 > 9999 || (i = $1 % 100) >= 60) {
228                     YYABORT;
229                 }
230                 $$ = ($1 / 100) * 60 + i;
231             }
232             else {
233                 if ($1 > 9999 || (i = $1 % 100) >= 60) {
234                     YYABORT;
235                 }
236                 $$ = -(($1 / 100) * 60 + i);
237             }
238         }
239         ;
240
241 date    : tUNUMBER '/' tUNUMBER {
242             yyMonth = $1;
243             yyDay = $3;
244         }
245         | tUNUMBER '/' tUNUMBER '/' tUNUMBER {
246             if ($1 > 100) {
247                 /* assume YYYY/MM/DD format, so need not to add 1900 */
248                 if ($1 > 999) {
249                     yyYear = $1;
250                 } else {
251                     yyYear = 1900 + $1;
252                 }
253                 yyMonth = $3;
254                 yyDay = $5;
255             }
256             else {
257                 /* assume MM/DD/YY* format */
258                 yyMonth = $1;
259                 yyDay = $3;
260                 if ($5 > 999) {
261                     /* assume year is YYYY format, so need not to add 1900 */
262                     yyYear = $5;
263                 } else if ($5 < 100) {
264                     /* assume year is YY format, so need to add 1900 */
265                     yyYear = $5 + (yyYear / 100 + (yyYear % 100 - $5) / 50) * 100;
266                 } else {
267                     yyYear = 1900 + $5;
268                 }
269             }
270         }
271         | tMONTH tUNUMBER {
272             yyMonth = $1;
273             yyDay = $2;
274         }
275         | tMONTH tUNUMBER ',' tUNUMBER {
276             yyMonth = $1;
277             yyDay = $2;
278             if ($4 > 999) {
279                 /* assume year is YYYY format, so need not to add 1900 */
280                 yyYear = $4;
281             } else if ($4 < 100) {
282                 /* assume year is YY format, so need to add 1900 */
283                 yyYear = $4 + (yyYear / 100 + (yyYear % 100 - $4) / 50) * 100;
284             } else {
285                 yyYear = 1900 + $4;
286             }
287         }
288         | tUNUMBER tMONTH {
289             yyDay = $1;
290             yyMonth = $2;
291         }
292         | tUNUMBER tMONTH tUNUMBER {
293             yyDay = $1;
294             yyMonth = $2;
295             if ($3 > 999) {
296                 /* assume year is YYYY format, so need not to add 1900 */
297                 yyYear = $3;
298             } else if ($3 < 100) {
299                 /* assume year is YY format, so need to add 1900 */
300                 yyYear = $3 + (yyYear / 100 + (yyYear % 100 - $3) / 50) * 100;
301             } else {
302                 yyYear = 1900 + $3;
303             }
304         }
305         | tDAY ',' tUNUMBER tMONTH tUNUMBER {
306             yyDay = $3;
307             yyMonth = $4;
308             if ($5 > 999) {
309                 /* assume year is YYYY format, so need not to add 1900 */
310                 yyYear = $5;
311             } else if ($5 < 100) {
312                 /* assume year is YY format, so need to add 1900 */
313                 yyYear = $5 + (yyYear / 100 + (yyYear % 100 - $5) / 50) * 100;
314             } else {
315                 yyYear = 1900 + $5;
316             }
317         }
318         ;
319
320 rel     : tSNUMBER tSEC_UNIT {
321             yyRelSeconds += $1 * $2;
322         }
323         | tUNUMBER tSEC_UNIT {
324             yyRelSeconds += $1 * $2;
325         }
326         | tSNUMBER tMONTH_UNIT {
327             yyRelMonth += $1 * $2;
328         }
329         | tUNUMBER tMONTH_UNIT {
330             yyRelMonth += $1 * $2;
331         }
332         ;
333
334 o_merid : /* NULL */ {
335             $$ = MER24;
336         }
337         | tMERIDIAN {
338             $$ = $1;
339         }
340         ;
341
342 %%
343
344 /* Month and day table. */
345 static TABLE    MonthDayTable[] = {
346     { "january",        tMONTH,  1 },
347     { "february",       tMONTH,  2 },
348     { "march",          tMONTH,  3 },
349     { "april",          tMONTH,  4 },
350     { "may",            tMONTH,  5 },
351     { "june",           tMONTH,  6 },
352     { "july",           tMONTH,  7 },
353     { "august",         tMONTH,  8 },
354     { "september",      tMONTH,  9 },
355     { "october",        tMONTH, 10 },
356     { "november",       tMONTH, 11 },
357     { "december",       tMONTH, 12 },
358         /* The value of the day isn't used... */
359     { "sunday",         tDAY, 0 },
360     { "monday",         tDAY, 0 },
361     { "tuesday",        tDAY, 0 },
362     { "wednesday",      tDAY, 0 },
363     { "thursday",       tDAY, 0 },
364     { "friday",         tDAY, 0 },
365     { "saturday",       tDAY, 0 },
366 };
367
368 /* Time units table. */
369 static TABLE    UnitsTable[] = {
370     { "year",           tMONTH_UNIT,    12 },
371     { "month",          tMONTH_UNIT,    1 },
372     { "week",           tSEC_UNIT,      7 * 24 * 60 * 60 },
373     { "day",            tSEC_UNIT,      1 * 24 * 60 * 60 },
374     { "hour",           tSEC_UNIT,      60 * 60 },
375     { "minute",         tSEC_UNIT,      60 },
376     { "min",            tSEC_UNIT,      60 },
377     { "second",         tSEC_UNIT,      1 },
378     { "sec",            tSEC_UNIT,      1 },
379 };
380
381 /* Timezone table. */
382 static TABLE    TimezoneTable[] = {
383     { "gmt",    tZONE,     HOUR( 0) },  /* Greenwich Mean */
384     { "ut",     tZONE,     HOUR( 0) },  /* Universal */
385     { "utc",    tZONE,     HOUR( 0) },  /* Universal Coordinated */
386     { "cut",    tZONE,     HOUR( 0) },  /* Coordinated Universal */
387     { "z",      tZONE,     HOUR( 0) },  /* Greenwich Mean */
388     { "wet",    tZONE,     HOUR( 0) },  /* Western European */
389     { "bst",    tDAYZONE,  HOUR( 0) },  /* British Summer */
390     { "nst",    tZONE,     HOUR(3)+30 }, /* Newfoundland Standard */
391     { "ndt",    tDAYZONE,  HOUR(3)+30 }, /* Newfoundland Daylight */
392     { "ast",    tZONE,     HOUR( 4) },  /* Atlantic Standard */
393     { "adt",    tDAYZONE,  HOUR( 4) },  /* Atlantic Daylight */
394     { "est",    tZONE,     HOUR( 5) },  /* Eastern Standard */
395     { "edt",    tDAYZONE,  HOUR( 5) },  /* Eastern Daylight */
396     { "cst",    tZONE,     HOUR( 6) },  /* Central Standard */
397     { "cdt",    tDAYZONE,  HOUR( 6) },  /* Central Daylight */
398     { "mst",    tZONE,     HOUR( 7) },  /* Mountain Standard */
399     { "mdt",    tDAYZONE,  HOUR( 7) },  /* Mountain Daylight */
400     { "pst",    tZONE,     HOUR( 8) },  /* Pacific Standard */
401     { "pdt",    tDAYZONE,  HOUR( 8) },  /* Pacific Daylight */
402     { "yst",    tZONE,     HOUR( 9) },  /* Yukon Standard */
403     { "ydt",    tDAYZONE,  HOUR( 9) },  /* Yukon Daylight */
404     { "akst",   tZONE,     HOUR( 9) },  /* Alaska Standard */
405     { "akdt",   tDAYZONE,  HOUR( 9) },  /* Alaska Daylight */
406     { "hst",    tZONE,     HOUR(10) },  /* Hawaii Standard */
407     { "hast",   tZONE,     HOUR(10) },  /* Hawaii-Aleutian Standard */
408     { "hadt",   tDAYZONE,  HOUR(10) },  /* Hawaii-Aleutian Daylight */
409     { "ces",    tDAYZONE,  -HOUR(1) },  /* Central European Summer */
410     { "cest",   tDAYZONE,  -HOUR(1) },  /* Central European Summer */
411     { "mez",    tZONE,     -HOUR(1) },  /* Middle European */
412     { "mezt",   tDAYZONE,  -HOUR(1) },  /* Middle European Summer */
413     { "cet",    tZONE,     -HOUR(1) },  /* Central European */
414     { "met",    tZONE,     -HOUR(1) },  /* Middle European */
415     { "eet",    tZONE,     -HOUR(2) },  /* Eastern Europe */
416     { "msk",    tZONE,     -HOUR(3) },  /* Moscow Winter */
417     { "msd",    tDAYZONE,  -HOUR(3) },  /* Moscow Summer */
418     { "wast",   tZONE,     -HOUR(8) },  /* West Australian Standard */
419     { "wadt",   tDAYZONE,  -HOUR(8) },  /* West Australian Daylight */
420     { "hkt",    tZONE,     -HOUR(8) },  /* Hong Kong */
421     { "cct",    tZONE,     -HOUR(8) },  /* China Coast */
422     { "jst",    tZONE,     -HOUR(9) },  /* Japan Standard */
423     { "kst",    tZONE,     -HOUR(9) },  /* Korean Standard */
424     { "kdt",    tZONE,     -HOUR(9) },  /* Korean Daylight */
425     { "cast",   tZONE,     -(HOUR(9)+30) }, /* Central Australian Standard */
426     { "cadt",   tDAYZONE,  -(HOUR(9)+30) }, /* Central Australian Daylight */
427     { "east",   tZONE,     -HOUR(10) }, /* Eastern Australian Standard */
428     { "eadt",   tDAYZONE,  -HOUR(10) }, /* Eastern Australian Daylight */
429     { "nzst",   tZONE,     -HOUR(12) }, /* New Zealand Standard */
430     { "nzdt",   tDAYZONE,  -HOUR(12) }, /* New Zealand Daylight */
431
432     /* For completeness we include the following entries. */
433 #if     0
434
435     /* Duplicate names.  Either they conflict with a zone listed above
436      * (which is either more likely to be seen or just been in circulation
437      * longer), or they conflict with another zone in this section and
438      * we could not reasonably choose one over the other. */
439     { "fst",    tZONE,     HOUR( 2) },  /* Fernando De Noronha Standard */
440     { "fdt",    tDAYZONE,  HOUR( 2) },  /* Fernando De Noronha Daylight */
441     { "bst",    tZONE,     HOUR( 3) },  /* Brazil Standard */
442     { "est",    tZONE,     HOUR( 3) },  /* Eastern Standard (Brazil) */
443     { "edt",    tDAYZONE,  HOUR( 3) },  /* Eastern Daylight (Brazil) */
444     { "wst",    tZONE,     HOUR( 4) },  /* Western Standard (Brazil) */
445     { "wdt",    tDAYZONE,  HOUR( 4) },  /* Western Daylight (Brazil) */
446     { "cst",    tZONE,     HOUR( 5) },  /* Chile Standard */
447     { "cdt",    tDAYZONE,  HOUR( 5) },  /* Chile Daylight */
448     { "ast",    tZONE,     HOUR( 5) },  /* Acre Standard */
449     { "adt",    tDAYZONE,  HOUR( 5) },  /* Acre Daylight */
450     { "cst",    tZONE,     HOUR( 5) },  /* Cuba Standard */
451     { "cdt",    tDAYZONE,  HOUR( 5) },  /* Cuba Daylight */
452     { "est",    tZONE,     HOUR( 6) },  /* Easter Island Standard */
453     { "edt",    tDAYZONE,  HOUR( 6) },  /* Easter Island Daylight */
454     { "sst",    tZONE,     HOUR(11) },  /* Samoa Standard */
455     { "ist",    tZONE,     -HOUR(2) },  /* Israel Standard */
456     { "idt",    tDAYZONE,  -HOUR(2) },  /* Israel Daylight */
457     { "idt",    tDAYZONE,  -(HOUR(3)+30) }, /* Iran Daylight */
458     { "ist",    tZONE,     -(HOUR(3)+30) }, /* Iran Standard */
459     { "cst",     tZONE,     -HOUR(8) }, /* China Standard */
460     { "cdt",     tDAYZONE,  -HOUR(8) }, /* China Daylight */
461     { "sst",     tZONE,     -HOUR(8) }, /* Singapore Standard */
462
463     /* Dubious (e.g., not in Olson's TIMEZONE package) or obsolete. */
464     { "gst",    tZONE,     HOUR( 3) },  /* Greenland Standard */
465     { "wat",    tZONE,     -HOUR(1) },  /* West Africa */
466     { "at",     tZONE,     HOUR( 2) },  /* Azores */
467     { "gst",    tZONE,     -HOUR(10) }, /* Guam Standard */
468     { "nft",    tZONE,     HOUR(3)+30 }, /* Newfoundland */
469     { "idlw",   tZONE,     HOUR(12) },  /* International Date Line West */
470     { "mewt",   tZONE,     -HOUR(1) },  /* Middle European Winter */
471     { "mest",   tDAYZONE,  -HOUR(1) },  /* Middle European Summer */
472     { "swt",    tZONE,     -HOUR(1) },  /* Swedish Winter */
473     { "sst",    tDAYZONE,  -HOUR(1) },  /* Swedish Summer */
474     { "fwt",    tZONE,     -HOUR(1) },  /* French Winter */
475     { "fst",    tDAYZONE,  -HOUR(1) },  /* French Summer */
476     { "bt",     tZONE,     -HOUR(3) },  /* Baghdad */
477     { "it",     tZONE,     -(HOUR(3)+30) }, /* Iran */
478     { "zp4",    tZONE,     -HOUR(4) },  /* USSR Zone 3 */
479     { "zp5",    tZONE,     -HOUR(5) },  /* USSR Zone 4 */
480     { "ist",    tZONE,     -(HOUR(5)+30) }, /* Indian Standard */
481     { "zp6",    tZONE,     -HOUR(6) },  /* USSR Zone 5 */
482     { "nst",    tZONE,     -HOUR(7) },  /* North Sumatra */
483     { "sst",    tZONE,     -HOUR(7) },  /* South Sumatra */
484     { "jt",     tZONE,     -(HOUR(7)+30) }, /* Java (3pm in Cronusland!) */
485     { "nzt",    tZONE,     -HOUR(12) }, /* New Zealand */
486     { "idle",   tZONE,     -HOUR(12) }, /* International Date Line East */
487     { "cat",    tZONE,     HOUR(10) },  /* -- expired 1967 */
488     { "nt",     tZONE,     HOUR(11) },  /* -- expired 1967 */
489     { "ahst",   tZONE,     HOUR(10) },  /* -- expired 1983 */
490     { "hdt",    tDAYZONE,  HOUR(10) },  /* -- expired 1986 */
491 #endif  /* 0 */
492 };
493
494 \f
495
496 static void
497 date_error(const char *s)
498 {
499     s = s;                      /* ARGSUSED */
500     /* NOTREACHED */
501 }
502
503
504 static time_t
505 ToSeconds(time_t Hours, time_t Minutes, time_t Seconds, MERIDIAN Meridian)
506 {
507     if (Minutes < 0 || Minutes > 59 || Seconds < 0 || Seconds > 61)
508         return -1;
509     if (Meridian == MER24) {
510         if (Hours < 0 || Hours > 23)
511             return -1;
512     }
513     else {
514         if (Hours < 1 || Hours > 12)
515             return -1;
516         if (Hours == 12)
517             Hours = 0;
518         if (Meridian == MERpm)
519             Hours += 12;
520     }
521     return (Hours * 60L + Minutes) * 60L + Seconds;
522 }
523
524
525 static time_t
526 Convert(time_t Month, time_t Day, time_t Year, time_t Hours, time_t Minutes,
527         time_t Seconds, MERIDIAN Meridian, DSTMODE dst)
528 {
529     static int  DaysNormal[13] = {
530         0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
531     };
532     static int  DaysLeap[13] = {
533         0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
534     };
535     static int  LeapYears[] = {
536         1972, 1976, 1980, 1984, 1988, 1992, 1996,
537         2000, 2004, 2008, 2012, 2016, 2020, 2024, 2028, 2032, 2036
538     };
539     int                 *yp;
540     int                 *mp;
541     time_t              Julian;
542     int                 i;
543     time_t              tod;
544
545     /* Year should not be passed as a relative value, but absolute one.
546        so this should not happen, but just ensure it */
547     if (Year < 0)
548         Year = -Year;
549     if (Year < 100) {
550         Year += 1900;
551         if (Year < EPOCH)
552             Year += 100;
553     }
554     for (mp = DaysNormal, yp = LeapYears; yp < ARRAY_END(LeapYears); yp++)
555         if (Year == *yp) {
556             mp = DaysLeap;
557             break;
558         }
559     if (Year < EPOCH || Year > END_OF_TIME
560      || Month < 1 || Month > 12
561      /* NOSTRICT *//* conversion from long may lose accuracy */
562      || Day < 1 || Day > mp[(int)Month])
563         return -1;
564
565     Julian = Day - 1 + (Year - EPOCH) * 365;
566     for (yp = LeapYears; yp < ARRAY_END(LeapYears); yp++, Julian++)
567         if (Year <= *yp)
568             break;
569     for (i = 1; i < Month; i++)
570         Julian += *++mp;
571     Julian *= SECSPERDAY;
572     Julian += yyTimezone * 60L;
573     if ((tod = ToSeconds(Hours, Minutes, Seconds, Meridian)) < 0)
574         return -1;
575     Julian += tod;
576     tod = Julian;
577     if (dst == DSTon || (dst == DSTmaybe && localtime(&tod)->tm_isdst))
578         Julian -= DST_OFFSET * 60 * 60;
579     return Julian;
580 }
581
582
583 static time_t
584 DSTcorrect(time_t Start, time_t Future)
585 {
586     time_t      StartDay;
587     time_t      FutureDay;
588
589     StartDay = (localtime(&Start)->tm_hour + 1) % 24;
590     FutureDay = (localtime(&Future)->tm_hour + 1) % 24;
591     return (Future - Start) + (StartDay - FutureDay) * DST_OFFSET * 60 * 60;
592 }
593
594
595 static time_t
596 RelativeMonth(time_t Start, time_t RelMonth)
597 {
598     struct tm   *tm;
599     time_t      Month;
600     time_t      Year;
601
602     tm = localtime(&Start);
603     Month = 12 * tm->tm_year + tm->tm_mon + RelMonth;
604     Year = Month / 12;
605     Year += 1900;
606     Month = Month % 12 + 1;
607     return DSTcorrect(Start,
608             Convert(Month, (time_t)tm->tm_mday, Year,
609                 (time_t)tm->tm_hour, (time_t)tm->tm_min, (time_t)tm->tm_sec,
610                 MER24, DSTmaybe));
611 }
612
613
614 static int
615 LookupWord(char *buff, int length)
616 {
617     char *p;
618     const char *q;
619     TABLE *tp;
620     int c;
621
622     p = buff;
623     c = p[0];
624
625     /* See if we have an abbreviation for a month. */
626     if (length == 3 || (length == 4 && p[3] == '.'))
627         for (tp = MonthDayTable; tp < ARRAY_END(MonthDayTable); tp++) {
628             q = tp->name;
629             if (c == q[0] && p[1] == q[1] && p[2] == q[2]) {
630                 yylval.Number = tp->value;
631                 return tp->type;
632             }
633         }
634     else
635         for (tp = MonthDayTable; tp < ARRAY_END(MonthDayTable); tp++)
636             if (c == tp->name[0] && strcmp(p, tp->name) == 0) {
637                 yylval.Number = tp->value;
638                 return tp->type;
639             }
640
641     /* Try for a timezone. */
642     for (tp = TimezoneTable; tp < ARRAY_END(TimezoneTable); tp++)
643         if (c == tp->name[0] && p[1] == tp->name[1]
644          && strcmp(p, tp->name) == 0) {
645             yylval.Number = tp->value;
646             return tp->type;
647         }
648
649     /* Try the units table. */
650     for (tp = UnitsTable; tp < ARRAY_END(UnitsTable); tp++)
651         if (c == tp->name[0] && strcmp(p, tp->name) == 0) {
652             yylval.Number = tp->value;
653             return tp->type;
654         }
655
656     /* Strip off any plural and try the units table again. */
657     if (--length > 0 && p[length] == 's') {
658         p[length] = '\0';
659         for (tp = UnitsTable; tp < ARRAY_END(UnitsTable); tp++)
660             if (c == tp->name[0] && strcmp(p, tp->name) == 0) {
661                 p[length] = 's';
662                 yylval.Number = tp->value;
663                 return tp->type;
664             }
665         p[length] = 's';
666     }
667     length++;
668
669     /* Drop out any periods. */
670     for (p = buff, q = buff; *q; q++)
671         if (*q != '.')
672             *p++ = *q;
673     *p = '\0';
674
675     /* Try the meridians. */
676     if (buff[1] == 'm' && buff[2] == '\0') {
677         if (buff[0] == 'a') {
678             yylval.Meridian = MERam;
679             return tMERIDIAN;
680         }
681         if (buff[0] == 'p') {
682             yylval.Meridian = MERpm;
683             return tMERIDIAN;
684         }
685     }
686
687     /* If we saw any periods, try the timezones again. */
688     if (p - buff != length) {
689         c = buff[0];
690         for (p = buff, tp = TimezoneTable; tp < ARRAY_END(TimezoneTable); tp++)
691             if (c == tp->name[0] && p[1] == tp->name[1]
692             && strcmp(p, tp->name) == 0) {
693                 yylval.Number = tp->value;
694                 return tp->type;
695             }
696     }
697
698     /* Unknown word -- assume GMT timezone. */
699     yylval.Number = 0;
700     return tZONE;
701 }
702
703
704 static int
705 date_lex(void)
706 {
707     char                c;
708     char                *p;
709     char                buff[20];
710     int                 sign;
711     int                 i;
712     int                 nesting;
713
714     for ( ; ; ) {
715         /* Get first character after the whitespace. */
716         for ( ; ; ) {
717             while (CTYPE(isspace, (int)*yyInput))
718                 yyInput++;
719             c = *yyInput;
720
721             /* Ignore RFC 822 comments, typically time zone names. */
722             if (c != LPAREN)
723                 break;
724             for (nesting = 1; (c = *++yyInput) != RPAREN || --nesting; )
725                 if (c == LPAREN)
726                     nesting++;
727                 else if (!IS7BIT(c) || c == '\0' || c == '\r'
728                      || (c == '\\' && ((c = *++yyInput) == '\0' || !IS7BIT(c))))
729                     /* Lexical error: bad comment. */
730                     return '?';
731             yyInput++;
732         }
733
734         /* A number? */
735         if (CTYPE(isdigit, (int)c) || c == '-' || c == '+') {
736             if (c == '-' || c == '+') {
737                 sign = c == '-' ? -1 : 1;
738                 yyInput++;
739                 if (!CTYPE(isdigit, (int)*yyInput))
740                     /* Skip the plus or minus sign. */
741                     continue;
742             }
743             else
744                 sign = 0;
745             for (i = 0; (c = *yyInput++) != '\0' && CTYPE(isdigit, (int)c); )
746                 i = 10 * i + c - '0';
747             yyInput--;
748             yylval.Number = sign < 0 ? -i : i;
749             return sign ? tSNUMBER : tUNUMBER;
750         }
751
752         /* A word? */
753         if (CTYPE(isalpha, (int)c)) {
754             for (p = buff; (c = *yyInput++) == '.' || CTYPE(isalpha, (int)c); )
755                 if (p < &buff[sizeof buff - 1])
756                     *p++ = CTYPE(isupper, (int)c) ? tolower(c) : c;
757             *p = '\0';
758             yyInput--;
759             return LookupWord(buff, p - buff);
760         }
761
762         return *yyInput++;
763     }
764 }
765
766
767 time_t
768 parsedate(char *p, TIMEINFO *now)
769 {
770     struct tm           *tm;
771     TIMEINFO            ti;
772     time_t              Start;
773
774     yyInput = p;
775     if (now == NULL) {
776         now = &ti;
777         GetTimeInfo(&ti);
778     }
779
780     tm = localtime(&now->time);
781     yyYear = tm->tm_year + 1900;
782     yyMonth = tm->tm_mon + 1;
783     yyDay = tm->tm_mday;
784     yyTimezone = now->tzone;
785     yyDSTmode = DSTmaybe;
786     yyHour = 0;
787     yyMinutes = 0;
788     yySeconds = 0;
789     yyMeridian = MER24;
790     yyRelSeconds = 0;
791     yyRelMonth = 0;
792     yyHaveDate = 0;
793     yyHaveRel = 0;
794     yyHaveTime = 0;
795
796     if (date_parse() || yyHaveTime > 1 || yyHaveDate > 1)
797         return -1;
798
799     if (yyHaveDate || yyHaveTime) {
800         Start = Convert(yyMonth, yyDay, yyYear, yyHour, yyMinutes, yySeconds,
801                     yyMeridian, yyDSTmode);
802         if (Start < 0)
803             return -1;
804     }
805     else {
806         Start = now->time;
807         if (!yyHaveRel)
808             Start -= (tm->tm_hour * 60L + tm->tm_min) * 60L + tm->tm_sec;
809     }
810
811     Start += yyRelSeconds;
812     if (yyRelMonth)
813         Start += RelativeMonth(Start, yyRelMonth);
814
815     /* Have to do *something* with a legitimate -1 so it's distinguishable
816      * from the error return value.  (Alternately could set errno on error.) */
817     return Start == -1 ? 0 : Start;
818 }
819
820
821 #if     defined(TEST)
822
823 #if     YYDEBUG
824 extern int      yydebug;
825 #endif  /* YYDEBUG */
826
827 /* ARGSUSED */
828 int
829 main(int ac, char *av[])
830 {
831     char        buff[128];
832     time_t      d;
833
834 #if     YYDEBUG
835     yydebug = 1;
836 #endif  /* YYDEBUG */
837
838     printf("Enter date, or blank line to exit.\n\t> ");
839     for ( ; ; ) {
840         printf("\t> ");
841         fflush(stdout);
842         if (gets(buff) == NULL || buff[0] == '\n')
843             break;
844 #if     YYDEBUG
845         if (strcmp(buff, "yydebug") == 0) {
846             yydebug = !yydebug;
847             printf("yydebug = %s\n", yydebug ? "on" : "off");
848             continue;
849         }
850 #endif  /* YYDEBUG */
851         d = parsedate(buff, (TIMEINFO *)NULL);
852         if (d == -1)
853             printf("Bad format - couldn't convert.\n");
854         else
855             printf("%s", ctime(&d));
856     }
857
858     exit(0);
859     /* NOTREACHED */
860 }
861 #endif  /* defined(TEST) */