git.marmaro.de Git - mmh/blob - sbr/dtimep.lex

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