Enhance fix of 0b81a300d9e7cf78b6bc11d8c870f57fa81fcdc4.
[mmh] / sbr / dtimep.lex
1 /* dtimep.lex exceeds the default table capacities for some old versions
2  * of lex (and the minimum defaults as specified by POSIX).  The following
3  * choices meet or exceed the lex defaults for older SunOS4.x, Solaris,
4  * HPUX, and AIX.
5  */
6 %e4000
7 %p7000
8 %n2500
9 %a5000
10 %{
11 #include <h/nmh.h>
12 #include <h/tws.h>
13
14   /* Since we're looking at a string at a time, don't worry about
15    *  wrapping to the next buffer.
16    */
17 #define yywrap() 1
18 #define YY_SKIP_YYWRAP
19
20 #define YY_NO_INPUT
21
22   /* This is the tricky thing that makes this function cool.  We
23    *  replace the traditional int yylex(void) declaration with our
24    *  dparsetime() declaration, essentially piggy-backing off the
25    *  utility of the yylex() function and adding what we need to make
26    *  the parsing function useful to us.
27    */
28 #define YY_DECL struct tws *dparsetime(char *lexstr)
29
30   /* yyerminate() is called after the input string is matched to
31    * completion (actually, when the lexer reaches an EOF).  The only
32    * thing that really needs to be in this macro function is the
33    * return call, which must be substituted inline into dparsetime.
34    */
35
36 #define yyterminate() (void)yy_delete_buffer(lexhandle); \
37         if(!(tw.tw_flags & TW_SUCC)) { \
38                 return (struct tws *)NULL; \
39         } \
40         if(tw.tw_year < 1970) \
41                 tw.tw_year += 1900; \
42         if(tw.tw_year < 1970) \
43                 tw.tw_year += 100; \
44         return(&tw)
45
46 /*
47  * Patchable flag that says how to interpret NN/NN/NN dates. When
48  * true, we do it European style: DD/MM/YY. When false, we do it
49  * American style: MM/DD/YY.  Of course, these are all non-RFC822
50  * compliant.
51  */
52 int europeandate = 0;
53
54 /*
55  * Table to convert month names to numeric month.  We use the
56  * fact that the low order 5 bits of the sum of the 2nd & 3rd
57  * characters of the name is a hash with no collisions for the 12
58  * valid month names.  (The mask to 5 bits maps any combination of
59  * upper and lower case into the same hash value).
60  */
61 static int month_map[] = {
62         0,
63         6,      /* 1 - Jul */
64         3,      /* 2 - Apr */
65         5,      /* 3 - Jun */
66         0,
67         10,     /* 5 - Nov */
68         0,
69         1,      /* 7 - Feb */
70         11,     /* 8 - Dec */
71         0,
72         0,
73         0,
74         0,
75         0,
76         0,
77         0,      /*15 - Jan */
78         0,
79         0,
80         0,
81         2,      /*19 - Mar */
82         0,
83         8,      /*21 - Sep */
84         0,
85         9,      /*23 - Oct */
86         0,
87         0,
88         4,      /*26 - May */
89         0,
90         7       /*28 - Aug */
91 };
92
93 /*
94  * Lookup table for day-of-week using the same hash trick as for above name-of-
95  * month table, but using the first and second character, not second and third.
96  *
97  * Compute index into table using: (day_name[0] & 7) + (day_name[1] & 4)
98  */
99 static int day_map[] = {
100         0,
101         0,
102         0,
103         6,      /* 3 - Sat */
104         4,      /* 4 - Thu */
105         0,
106         5,      /* 6 - Fri */
107         0,      /* 7 - Sun */
108         2,      /* 8 - Tue */
109         1       /* 9 - Mon */,
110         0,
111         3       /*11 - Wed */
112 };
113
114 /* The SET* macros will parse for the appropriate field, and leave the
115  * cp pointer at the first character after the desired field. Be
116  * careful with variable-length fields or alpha-num mixes.
117
118  * The SKIP* macros skip over characters of a particular class and
119  * leave cp at the position of the first character that doesn't match
120  * that class. Correspondingly, SKIPTO* skips until it reaches a
121  * character of a particular class.
122  */
123
124 #define INIT() { cp = yytext;}
125 #define SETWDAY()  { tw.tw_wday= day_map[(cp[0] & 7) + (cp[1] & 4)]; \
126         tw.tw_flags &= ~TW_SDAY; tw.tw_flags |= TW_SEXP; SKIPA(); }
127 #define SETMON()  { cp++; tw.tw_mon = month_map[(cp[0] + cp[1]) & 0x1f]; \
128         SKIPA(); }
129 #define SETMON_NUM()  { tw.tw_mon = atoi(cp)-1; SKIPD(); }
130 #define SETYEAR()  { tw.tw_year = atoi(cp); SKIPD(); }
131 #define SETDAY()  { tw.tw_mday = atoi(cp); tw.tw_flags |= TW_YES; SKIPD(); }
132 #define SETTIME()  { tw.tw_hour = atoi(cp); cp += 2; SKIPTOD(); \
133         tw.tw_min = atoi(cp); cp += 2; if(*cp == ':') { \
134         tw.tw_sec = atoi(++cp); SKIPD(); } }
135 #define SETZONE(x)  { tw.tw_zone = ((x)/100)*60+(x)%100; \
136         tw.tw_flags |= TW_SZEXP; SKIPD(); }
137 #define SETDST()  { tw.tw_flags |= TW_DST; }
138 #define SKIPD()  { while ( isdigit(*cp++) ) ; --cp; }
139 #define SKIPTOD()  { while ( !isdigit(*cp++) ) ; --cp; }
140 #define SKIPA()  { while ( isalpha(*cp++) ) ; --cp; }
141 #define SKIPTOA()  { while ( !isalpha(*cp++) ) ; --cp; }
142 #define SKIPSP()  { while ( isspace(*cp++) ) ; --cp; }
143 #define SKIPTOSP()  { while ( !isspace(*cp++) ) ; --cp; }
144
145 #ifdef ADJUST_NUMERIC_ONLY_TZ_OFFSETS_WRT_DST
146 # ifdef HAVE_SYS_TIME_H
147 #  include <sys/time.h>
148 # endif
149 #include <time.h>
150
151 static void
152 zonehack (struct tws *tw)
153 {
154         register struct tm *tm;
155
156         if (dmktime (tw) == (time_t) -1)
157                 return;
158
159         tm = localtime (&tw->tw_clock);
160         if (tm->tm_isdst) {
161                 tw->tw_flags |= TW_DST;
162                 tw->tw_zone -= 60;
163         }
164 }
165 #endif /* ADJUST_NUMERIC_ONLY_TZ_OFFSETS_WRT_DST */
166 %}
167
168 sun     ([Ss]un(day)?)
169 mon     ([Mm]on(day)?)
170 tue     ([Tt]ue(sday)?)
171 wed     ([Ww]ed(nesday)?)
172 thu     ([Tt]hu(rsday)?)
173 fri     ([Ff]ri(day)?)
174 sat     ([Ss]at(urday)?)
175
176 DAY     ({sun}|{mon}|{tue}|{wed}|{thu}|{fri}|{sat})
177
178 jan     ([Jj]an(uary)?)
179 feb     ([Ff]eb(ruary)?)
180 mar     ([Mm]ar(ch)?)
181 apr     ([Aa]pr(il)?)
182 may     ([Mm]ay)
183 jun     ([Jj]un(e)?)
184 jul     ([Jj]ul(y)?)
185 aug     ([Aa]ug(ust)?)
186 sep     ([Ss]ep(tember)?)
187 oct     ([Oo]ct(ober)?)
188 nov     ([Nn]ov(ember)?)
189 dec     ([Dd]ec(ember)?)
190
191 MONTH   ({jan}|{feb}|{mar}|{apr}|{may}|{jun}|{jul}|{aug}|{sep}|{oct}|{nov}|{dec})
192
193 TIME    ({D}:{d}{d}(:{d}{d})?)
194
195 /*
196  * The year can either be 2 digits, or 4. However, after
197  * Y2K, we found that some MUA were reporting the year 100, hence
198  * the middle term here. yyterminate() resolves the actual
199  * issues with 2-digit years.
200  */
201
202 YEAR    (({d}{d})|(1{d}{d})|({d}{4}))
203
204 w       ([ \t]*)
205 W       ([ \t]+)
206 D       ([0-9]?[0-9])
207 d       [0-9]
208 nl      [ \t\n()]
209
210 %%
211 %{
212         /* This section begins the definition of dparsetime().
213          * Put here any local variable definitions and initializations */
214
215         YY_BUFFER_STATE lexhandle;
216
217         register unsigned char *cp;
218         static struct tws tw;
219
220         memset(&tw,0,sizeof(struct tws));
221
222         lexhandle = yy_scan_string(lexstr);
223 %}
224
225 {DAY}","?{W}{MONTH}{W}{D}{W}{TIME}{W}{YEAR}  {
226         INIT();
227         SETWDAY();
228         SKIPTOA();
229         SETMON();
230         SKIPTOD();
231         SETDAY();
232         SKIPTOD();
233         SETTIME();
234         SKIPTOD();
235         SETYEAR();
236 }
237
238 {DAY}","?{W}{D}{W}{MONTH}{W}{YEAR}{W}{TIME}  {
239         INIT();
240         SETWDAY();
241         SKIPTOD();
242         SETDAY();
243         SKIPTOA();
244         SETMON();
245         SKIPTOD();
246         SETYEAR();
247         SKIPTOD();
248         SETTIME();
249 }
250 {D}{W}{MONTH}{W}{YEAR}{W}{TIME}  {
251         INIT();
252         SETDAY();
253         SKIPTOA();
254         SETMON();
255         SKIPTOD();
256         SETYEAR();
257         SKIPTOD();
258         SETTIME();
259 }
260 {DAY}","?{W}{MONTH}{W}{D}","?{W}{YEAR}","?{W}{TIME}  {
261         INIT();
262         SETWDAY();
263         SKIPTOA();
264         SETMON();
265         SKIPTOD();
266         SETDAY();
267         SKIPTOD();
268         SETYEAR();
269         SKIPTOD();
270         SETTIME();
271 }
272 {DAY}","?{W}{MONTH}{W}{D}","?{W}{YEAR}  {
273         INIT();
274         SETWDAY();
275         SKIPTOA();
276         SETMON();
277         SKIPTOD();
278         SETDAY();
279         SKIPTOD();
280         SETYEAR();
281 }
282 {MONTH}{W}{D}","?{W}{YEAR}","?{W}{DAY}  {
283         INIT();
284         SETMON();
285         SKIPTOD();
286         SETDAY();
287         SKIPTOD();
288         SETYEAR();
289         SKIPTOA();
290         SETWDAY();
291 }
292 {MONTH}{W}{D}","?{W}{YEAR}  {
293         INIT();
294         SETMON();
295         SKIPTOD();
296         SETDAY();
297         SKIPTOD();
298         SETYEAR();
299 }
300 {D}("-"|"/"){D}("-"|"/"){YEAR}{W}{TIME}  {
301         INIT();
302         if(europeandate) {
303           /* DD/MM/YY */
304         SETDAY();
305         SKIPTOD();
306         SETMON_NUM();
307         } else {
308           /* MM/DD/YY */
309         SETMON_NUM();
310         SKIPTOD();
311         SETDAY();
312         }
313         SKIPTOD();
314         SETYEAR();
315         SKIPTOD();
316         SETTIME();
317 }
318 {D}("-"|"/"){D}("-"|"/"){YEAR}  {
319         INIT();
320         if(europeandate) {
321                 /* DD/MM/YY */
322                 SETDAY();
323                 SKIPTOD();
324                 SETMON_NUM();
325         } else {
326                 /* MM/DD/YY */
327                 SETMON_NUM();
328                 SKIPTOD();
329                 SETDAY();
330         }
331         SKIPTOD();
332         SETYEAR();
333 }
334
335 "[Aa][Mm]"
336 "[Pp][Mm]"  tw.tw_hour += 12;
337
338 "+"{D}{d}{d}  {
339         INIT();
340         SKIPTOD();
341         SETZONE(atoi(cp));
342 #ifdef ADJUST_NUMERIC_ONLY_TZ_OFFSETS_WRT_DST
343         zonehack (&tw);
344 #endif /* ADJUST_NUMERIC_ONLY_TZ_OFFSETS_WRT_DST */
345         yyterminate();
346 }
347 "-"{D}{d}{d}  {
348         INIT();
349         SKIPTOD();
350         SETZONE(-atoi(cp));
351 #ifdef ADJUST_NUMERIC_ONLY_TZ_OFFSETS_WRT_DST
352         zonehack (&tw);
353 #endif /* ADJUST_NUMERIC_ONLY_TZ_OFFSETS_WRT_DST */
354         yyterminate();
355
356 }
357 {nl}("ut"|"UT")         INIT(); SETZONE(0); yyterminate();
358 {nl}("gmt"|"GMT")       INIT(); SETZONE(0); yyterminate();
359 {nl}("est"|"EST")       INIT(); SETZONE(-500); yyterminate();
360 {nl}("edt"|"EDT")       { INIT(); SETDST(); SETZONE(-500); yyterminate(); }
361 {nl}("cst"|"CST")       INIT(); SETZONE(-600); yyterminate();
362 {nl}("cdt"|"CDT")       { INIT(); SETDST(); SETZONE(-600); yyterminate(); }
363 {nl}("mst"|"MST")       INIT(); SETZONE(-700); yyterminate();
364 {nl}("mdt"|"MDT")       { INIT(); SETDST(); SETZONE(-700); yyterminate(); }
365 {nl}("pst"|"PST")       INIT(); SETZONE(-800); yyterminate();
366 {nl}("pdt"|"PDT")       { INIT(); SETDST(); SETZONE(-800); yyterminate(); }
367 {nl}("nst"|"NST")       INIT(); SETZONE(-330); yyterminate();
368 {nl}("ast"|"AST")       INIT(); SETZONE(-400); yyterminate();
369 {nl}("adt"|"ADT")       { INIT(); SETDST(); SETZONE(-400); yyterminate(); }
370 {nl}("hst"|"HST")       INIT(); SETZONE(-1000); yyterminate();
371 {nl}("hdt"|"HDT")       { INIT(); SETDST(); SETZONE(-1000); yyterminate(); }
372 .|\n
373
374 %%
375 /* This is a portable way to squash a warning about the yyunput()
376  * function being static but never used. It costs us a tiny amount
377  * of extra code in the binary but the other options are:
378  * "%option nounput" which is flex-specific
379  * makefile hackery just to compile dtimep.c with different flags
380  */
381 void dtimep_yyunput(int c)
382 {
383         unput(c);
384 }