dlls/oleaut32/parsedt.c

   1 /*
   2 PostgreSQL Data Base Management System (formerly known as Postgres, then
   3 as Postgres95).
   4
   5 Copyright (c) 1994-7 Regents of the University of California
   6
   7 Permission to use, copy, modify, and distribute this software and its
   8 documentation for any purpose, without fee, and without a written agreement
   9 is hereby granted, provided that the above copyright notice and this
  10 paragraph and the following two paragraphs appear in all copies.
  11
  12 IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
  13 DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING
  14 LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS
  15 DOCUMENTATION, EVEN IF THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE
  16 POSSIBILITY OF SUCH DAMAGE.
  17
  18 THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
  19 INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  20 AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  21 ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATIONS TO
  22 PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  23 */
  24
  25 /*-------------------------------------------------------------------------
  26  *
  27  * dt.c--
  28  *        Functions for the built-in type "dt".
  29  *
  30  * Copyright (c) 1994, Regents of the University of California
  31  *
  32  *
  33  *-------------------------------------------------------------------------
  34  */
  35 #include <time.h>
  36 #include <stdio.h>
  37 #include <ctype.h>
  38 #include <math.h>
  39 #include <string.h>
  40 #include <sys/types.h>
  41 #include <errno.h>
  42 #include <limits.h>
  43 #include <sys/timeb.h>
  44
  45 #include "parsedt.h"
  46
  47 static datetkn *datebsearch(char *key, datetkn *base, unsigned int nel);
  48 static int      DecodeDate(char *str, int fmask, int *tmask, struct tm * tm);
  49 static int DecodeNumber(int flen, char *field,
  50                          int fmask, int *tmask, struct tm * tm, double *fsec);
  51 static int DecodeNumberField(int len, char *str,
  52                                   int fmask, int *tmask, struct tm * tm, double *fsec);
  53 static int      DecodeSpecial(int field, char *lowtoken, int *val);
  54 static int DecodeTime(char *str, int fmask, int *tmask,
  55                    struct tm * tm, double *fsec);
  56 static int      DecodeTimezone(char *str, int *tzp);
  57
  58 #define USE_DATE_CACHE 1
  59 #define ROUND_ALL 0
  60
  61 static const int mdays[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 0};
  62
  63 static const char * const months[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
  64 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", NULL};
  65
  66 static const char * const days[] = {"Sunday", "Monday", "Tuesday", "Wednesday",
  67 "Thursday", "Friday", "Saturday", NULL};
  68
  69 /* those three vars are useless, and not even initialized, so
  70  * I'd rather remove them all (EPP)
  71  */
  72 int     DateStyle;
  73 bool    EuroDates;
  74 int     CTimeZone;
  75
  76 #define UTIME_MINYEAR (1901)
  77 #define UTIME_MINMONTH (12)
  78 #define UTIME_MINDAY (14)
  79 #define UTIME_MAXYEAR (2038)
  80 #define UTIME_MAXMONTH (01)
  81 #define UTIME_MAXDAY (18)
  82
  83 #define IS_VALID_UTIME(y,m,d) (((y > UTIME_MINYEAR) \
  84  || ((y == UTIME_MINYEAR) && ((m > UTIME_MINMONTH) \
  85   || ((m == UTIME_MINMONTH) && (d >= UTIME_MINDAY))))) \
  86  && ((y < UTIME_MAXYEAR) \
  87  || ((y == UTIME_MAXYEAR) && ((m < UTIME_MAXMONTH) \
  88   || ((m == UTIME_MAXMONTH) && (d <= UTIME_MAXDAY))))))
  89
  90
  91
  92
  93 /*****************************************************************************
  94  *       PRIVATE ROUTINES                                                                                                                *
  95  *****************************************************************************/
  96
  97 /* definitions for squeezing values into "value" */
  98 #define ABS_SIGNBIT             (char) 0200
  99 #define VALMASK                 (char) 0177
 100 #define NEG(n)                  ((n)|ABS_SIGNBIT)
 101 #define SIGNEDCHAR(c)   ((c)&ABS_SIGNBIT? -((c)&VALMASK): (c))
 102 #define FROMVAL(tp)             (-SIGNEDCHAR((tp)->value) * 10) /* uncompress */
 103 #define TOVAL(tp, v)    ((tp)->value = ((v) < 0? NEG((-(v))/10): (v)/10))
 104
 105 /*
 106  * to keep this table reasonably small, we divide the lexval for TZ and DTZ
 107  * entries by 10 and truncate the text field at MAXTOKLEN characters.
 108  * the text field is not guaranteed to be NULL-terminated.
 109  */
 110 static datetkn datetktbl[] = {
 111 /*              text                    token   lexval */
 112         {EARLY, RESERV, DTK_EARLY}, /* "-infinity" reserved for "early time" */
 113         {"acsst", DTZ, 63},                     /* Cent. Australia */
 114         {"acst", TZ, 57},                       /* Cent. Australia */
 115         {DA_D, ADBC, AD},                       /* "ad" for years >= 0 */
 116         {"abstime", IGNOREFIELD, 0},            /* "abstime" for pre-v6.1 "Invalid
 117                                                                  * Abstime" */
 118         {"adt", DTZ, NEG(18)},          /* Atlantic Daylight Time */
 119         {"aesst", DTZ, 66},                     /* E. Australia */
 120         {"aest", TZ, 60},                       /* Australia Eastern Std Time */
 121         {"ahst", TZ, 60},                       /* Alaska-Hawaii Std Time */
 122         {"allballs", RESERV, DTK_ZULU},         /* 00:00:00 */
 123         {"am", AMPM, AM},
 124         {"apr", MONTH, 4},
 125         {"april", MONTH, 4},
 126         {"ast", TZ, NEG(24)},           /* Atlantic Std Time (Canada) */
 127         {"at", IGNOREFIELD, 0},                 /* "at" (throwaway) */
 128         {"aug", MONTH, 8},
 129         {"august", MONTH, 8},
 130         {"awsst", DTZ, 54},                     /* W. Australia */
 131         {"awst", TZ, 48},                       /* W. Australia */
 132         {DB_C, ADBC, BC},                       /* "bc" for years < 0 */
 133         {"bst", TZ, 6},                         /* British Summer Time */
 134         {"bt", TZ, 18},                         /* Baghdad Time */
 135         {"cadt", DTZ, 63},                      /* Central Australian DST */
 136         {"cast", TZ, 57},                       /* Central Australian ST */
 137         {"cat", TZ, NEG(60)},           /* Central Alaska Time */
 138         {"cct", TZ, 48},                        /* China Coast */
 139         {"cdt", DTZ, NEG(30)},          /* Central Daylight Time */
 140         {"cet", TZ, 6},                         /* Central European Time */
 141         {"cetdst", DTZ, 12},            /* Central European Dayl.Time */
 142         {"cst", TZ, NEG(36)},           /* Central Standard Time */
 143         {DCURRENT, RESERV, DTK_CURRENT},        /* "current" is always now */
 144         {"dec", MONTH, 12},
 145         {"december", MONTH, 12},
 146         {"dnt", TZ, 6},                         /* Dansk Normal Tid */
 147         {"dow", RESERV, DTK_DOW},       /* day of week */
 148         {"doy", RESERV, DTK_DOY},       /* day of year */
 149         {"dst", DTZMOD, 6},
 150         {"east", TZ, NEG(60)},          /* East Australian Std Time */
 151         {"edt", DTZ, NEG(24)},          /* Eastern Daylight Time */
 152         {"eet", TZ, 12},                        /* East. Europe, USSR Zone 1 */
 153         {"eetdst", DTZ, 18},            /* Eastern Europe */
 154         {EPOCH, RESERV, DTK_EPOCH}, /* "epoch" reserved for system epoch time */
 155 #if USE_AUSTRALIAN_RULES
 156         {"est", TZ, 60},                        /* Australia Eastern Std Time */
 157 #else
 158         {"est", TZ, NEG(30)},           /* Eastern Standard Time */
 159 #endif
 160         {"feb", MONTH, 2},
 161         {"february", MONTH, 2},
 162         {"fri", DOW, 5},
 163         {"friday", DOW, 5},
 164         {"fst", TZ, 6},                         /* French Summer Time */
 165         {"fwt", DTZ, 12},                       /* French Winter Time  */
 166         {"gmt", TZ, 0},                         /* Greenwish Mean Time */
 167         {"gst", TZ, 60},                        /* Guam Std Time, USSR Zone 9 */
 168         {"hdt", DTZ, NEG(54)},          /* Hawaii/Alaska */
 169         {"hmt", DTZ, 18},                       /* Hellas ? ? */
 170         {"hst", TZ, NEG(60)},           /* Hawaii Std Time */
 171         {"idle", TZ, 72},                       /* Intl. Date Line, East */
 172         {"idlw", TZ, NEG(72)},          /* Intl. Date Line,,    est */
 173         {LATE, RESERV, DTK_LATE},       /* "infinity" reserved for "late time" */
 174         {INVALID, RESERV, DTK_INVALID},         /* "invalid" reserved for invalid
 175                                                                                  * time */
 176         {"ist", TZ, 12},                        /* Israel */
 177         {"it", TZ, 22},                         /* Iran Time */
 178         {"jan", MONTH, 1},
 179         {"january", MONTH, 1},
 180         {"jst", TZ, 54},                        /* Japan Std Time,USSR Zone 8 */
 181         {"jt", TZ, 45},                         /* Java Time */
 182         {"jul", MONTH, 7},
 183         {"july", MONTH, 7},
 184         {"jun", MONTH, 6},
 185         {"june", MONTH, 6},
 186         {"kst", TZ, 54},                        /* Korea Standard Time */
 187         {"ligt", TZ, 60},                       /* From Melbourne, Australia */
 188         {"mar", MONTH, 3},
 189         {"march", MONTH, 3},
 190         {"may", MONTH, 5},
 191         {"mdt", DTZ, NEG(36)},          /* Mountain Daylight Time */
 192         {"mest", DTZ, 12},                      /* Middle Europe Summer Time */
 193         {"met", TZ, 6},                         /* Middle Europe Time */
 194         {"metdst", DTZ, 12},            /* Middle Europe Daylight Time */
 195         {"mewt", TZ, 6},                        /* Middle Europe Winter Time */
 196         {"mez", TZ, 6},                         /* Middle Europe Zone */
 197         {"mon", DOW, 1},
 198         {"monday", DOW, 1},
 199         {"mst", TZ, NEG(42)},           /* Mountain Standard Time */
 200         {"mt", TZ, 51},                         /* Moluccas Time */
 201         {"ndt", DTZ, NEG(15)},          /* Nfld. Daylight Time */
 202         {"nft", TZ, NEG(21)},           /* Newfoundland Standard Time */
 203         {"nor", TZ, 6},                         /* Norway Standard Time */
 204         {"nov", MONTH, 11},
 205         {"november", MONTH, 11},
 206         {NOW, RESERV, DTK_NOW},         /* current transaction time */
 207         {"nst", TZ, NEG(21)},           /* Nfld. Standard Time */
 208         {"nt", TZ, NEG(66)},            /* Nome Time */
 209         {"nzdt", DTZ, 78},                      /* New Zealand Daylight Time */
 210         {"nzst", TZ, 72},                       /* New Zealand Standard Time */
 211         {"nzt", TZ, 72},                        /* New Zealand Time */
 212         {"oct", MONTH, 10},
 213         {"october", MONTH, 10},
 214         {"on", IGNOREFIELD, 0},                 /* "on" (throwaway) */
 215         {"pdt", DTZ, NEG(42)},          /* Pacific Daylight Time */
 216         {"pm", AMPM, PM},
 217         {"pst", TZ, NEG(48)},           /* Pacific Standard Time */
 218         {"sadt", DTZ, 63},                      /* S. Australian Dayl. Time */
 219         {"sast", TZ, 57},                       /* South Australian Std Time */
 220         {"sat", DOW, 6},
 221         {"saturday", DOW, 6},
 222         {"sep", MONTH, 9},
 223         {"sept", MONTH, 9},
 224         {"september", MONTH, 9},
 225         {"set", TZ, NEG(6)},            /* Seychelles Time ?? */
 226         {"sst", DTZ, 12},                       /* Swedish Summer Time */
 227         {"sun", DOW, 0},
 228         {"sunday", DOW, 0},
 229         {"swt", TZ, 6},                         /* Swedish Winter Time  */
 230         {"thu", DOW, 4},
 231         {"thur", DOW, 4},
 232         {"thurs", DOW, 4},
 233         {"thursday", DOW, 4},
 234         {TODAY, RESERV, DTK_TODAY}, /* midnight */
 235         {TOMORROW, RESERV, DTK_TOMORROW},       /* tomorrow midnight */
 236         {"tue", DOW, 2},
 237         {"tues", DOW, 2},
 238         {"tuesday", DOW, 2},
 239         {"undefined", RESERV, DTK_INVALID}, /* "undefined" pre-v6.1 invalid
 240                                                                                  * time */
 241         {"ut", TZ, 0},
 242         {"utc", TZ, 0},
 243         {"wadt", DTZ, 48},                      /* West Australian DST */
 244         {"wast", TZ, 42},                       /* West Australian Std Time */
 245         {"wat", TZ, NEG(6)},            /* West Africa Time */
 246         {"wdt", DTZ, 54},                       /* West Australian DST */
 247         {"wed", DOW, 3},
 248         {"wednesday", DOW, 3},
 249         {"weds", DOW, 3},
 250         {"wet", TZ, 0},                         /* Western Europe */
 251         {"wetdst", DTZ, 6},                     /* Western Europe */
 252         {"wst", TZ, 48},                        /* West Australian Std Time */
 253         {"ydt", DTZ, NEG(48)},          /* Yukon Daylight Time */
 254         {YESTERDAY, RESERV, DTK_YESTERDAY}, /* yesterday midnight */
 255         {"yst", TZ, NEG(54)},           /* Yukon Standard Time */
 256         {"zp4", TZ, NEG(24)},           /* GMT +4  hours. */
 257         {"zp5", TZ, NEG(30)},           /* GMT +5  hours. */
 258         {"zp6", TZ, NEG(36)},           /* GMT +6  hours. */
 259         {"z", RESERV, DTK_ZULU},        /* 00:00:00 */
 260         {ZULU, RESERV, DTK_ZULU},       /* 00:00:00 */
 261 };
 262
 263 static unsigned int szdatetktbl = sizeof datetktbl / sizeof datetktbl[0];
 264
 265
 266
 267 #if USE_DATE_CACHE
 268 datetkn    *datecache[MAXDATEFIELDS] = {NULL};
 269
 270 datetkn    *deltacache[MAXDATEFIELDS] = {NULL};
 271
 272 #endif
 273
 274
 275 /*
 276  * Calendar time to Julian date conversions.
 277  * Julian date is commonly used in astronomical applications,
 278  *      since it is numerically accurate and computationally simple.
 279  * The algorithms here will accurately convert between Julian day
 280  *      and calendar date for all non-negative Julian days
 281  *      (i.e. from Nov 23, -4713 on).
 282  *
 283  * Ref: Explanatory Supplement to the Astronomical Almanac, 1992.
 284  *      University Science Books, 20 Edgehill Rd. Mill Valley CA 94941.
 285  *
 286  * Use the algorithm by Henry Fliegel, a former NASA/JPL colleague
 287  *      now at Aerospace Corp. (hi, Henry!)
 288  *
 289  * These routines will be used by other date/time packages - tgl 97/02/25
 290  */
 291
 292 /* Set the minimum year to one greater than the year of the first valid day
 293  *      to avoid having to check year and day both. - tgl 97/05/08
 294  */
 295
 296 #define JULIAN_MINYEAR (-4713)
 297 #define JULIAN_MINMONTH (11)
 298 #define JULIAN_MINDAY (23)
 299
 300 #define IS_VALID_JULIAN(y,m,d) ((y > JULIAN_MINYEAR) \
 301  || ((y == JULIAN_MINYEAR) && ((m > JULIAN_MINMONTH) \
 302   || ((m == JULIAN_MINMONTH) && (d >= JULIAN_MINDAY)))))
 303
 304 int
 305 date2j(int y, int m, int d)
 306 {
 307         int                     m12 = (m - 14) / 12;
 308
 309         return ((1461 * (y + 4800 + m12)) / 4 + (367 * (m - 2 - 12 * (m12))) / 12
 310                         - (3 * ((y + 4900 + m12) / 100)) / 4 + d - 32075);
 311 }       /* date2j() */
 312
 313 void
 314 j2date(int jd, int *year, int *month, int *day)
 315 {
 316         int                     j,
 317                                 y,
 318                                 m,
 319                                 d;
 320
 321         int                     i,
 322                                 l,
 323                                 n;
 324
 325         l = jd + 68569;
 326         n = (4 * l) / 146097;
 327         l -= (146097 * n + 3) / 4;
 328         i = (4000 * (l + 1)) / 1461001;
 329         l += 31 - (1461 * i) / 4;
 330         j = (80 * l) / 2447;
 331         d = l - (2447 * j) / 80;
 332         l = j / 11;
 333         m = (j + 2) - (12 * l);
 334         y = 100 * (n - 49) + i + l;
 335
 336         *year = y;
 337         *month = m;
 338         *day = d;
 339         return;
 340 }       /* j2date() */
 341
 342
 343
 344
 345 /*
 346  * parse and convert date in timestr (the normal interface)
 347  *
 348  * Returns the number of seconds since epoch (J2000)
 349  */
 350
 351 /* ParseDateTime()
 352  * Break string into tokens based on a date/time context.
 353  */
 354 int
 355 ParseDateTime(char *timestr, char *lowstr,
 356                           char **field, int *ftype, int maxfields, int *numfields)
 357 {
 358         int                     nf = 0;
 359         char       *cp = timestr;
 360         char       *lp = lowstr;
 361
 362 #ifdef DATEDEBUG
 363         printf("ParseDateTime- input string is %s\n", timestr);
 364 #endif
 365         /* outer loop through fields */
 366         while (*cp != '\0')
 367         {
 368                 field[nf] = lp;
 369
 370                 /* leading digit? then date or time */
 371                 if (isdigit(*cp) || (*cp == '.'))
 372                 {
 373                         *lp++ = *cp++;
 374                         while (isdigit(*cp))
 375                                 *lp++ = *cp++;
 376                         /* time field? */
 377                         if (*cp == ':')
 378                         {
 379                                 ftype[nf] = DTK_TIME;
 380                                 while (isdigit(*cp) || (*cp == ':') || (*cp == '.'))
 381                                         *lp++ = *cp++;
 382
 383                         }
 384                         /* date field? allow embedded text month */
 385                         else if ((*cp == '-') || (*cp == '/') || (*cp == '.'))
 386                         {
 387                                 ftype[nf] = DTK_DATE;
 388                                 while (isalnum(*cp) || (*cp == '-') || (*cp == '/') || (*cp == '.'))
 389                                         *lp++ = tolower(*cp++);
 390
 391                         }
 392
 393                         /*
 394                          * otherwise, number only and will determine year, month, or
 395                          * day later
 396                          */
 397                         else
 398                                 ftype[nf] = DTK_NUMBER;
 399
 400                 }
 401
 402                 /*
 403                  * text? then date string, month, day of week, special, or
 404                  * timezone
 405                  */
 406                 else if (isalpha(*cp))
 407                 {
 408                         ftype[nf] = DTK_STRING;
 409                         *lp++ = tolower(*cp++);
 410                         while (isalpha(*cp))
 411                                 *lp++ = tolower(*cp++);
 412
 413                         /* full date string with leading text month? */
 414                         if ((*cp == '-') || (*cp == '/') || (*cp == '.'))
 415                         {
 416                                 ftype[nf] = DTK_DATE;
 417                                 while (isdigit(*cp) || (*cp == '-') || (*cp == '/') || (*cp == '.'))
 418                                         *lp++ = tolower(*cp++);
 419                         }
 420
 421                         /* skip leading spaces */
 422                 }
 423                 else if (isspace(*cp))
 424                 {
 425                         cp++;
 426                         continue;
 427
 428                         /* sign? then special or numeric timezone */
 429                 }
 430                 else if ((*cp == '+') || (*cp == '-'))
 431                 {
 432                         *lp++ = *cp++;
 433                         /* soak up leading whitespace */
 434                         while (isspace(*cp))
 435                                 cp++;
 436                         /* numeric timezone? */
 437                         if (isdigit(*cp))
 438                         {
 439                                 ftype[nf] = DTK_TZ;
 440                                 *lp++ = *cp++;
 441                                 while (isdigit(*cp) || (*cp == ':'))
 442                                         *lp++ = *cp++;
 443
 444                                 /* special? */
 445                         }
 446                         else if (isalpha(*cp))
 447                         {
 448                                 ftype[nf] = DTK_SPECIAL;
 449                                 *lp++ = tolower(*cp++);
 450                                 while (isalpha(*cp))
 451                                         *lp++ = tolower(*cp++);
 452
 453                                 /* otherwise something wrong... */
 454                         }
 455                         else
 456                                 return -1;
 457
 458                         /* ignore punctuation but use as delimiter */
 459                 }
 460                 else if (ispunct(*cp))
 461                 {
 462                         cp++;
 463                         continue;
 464
 465                 }
 466                 else
 467                         return -1;
 468
 469                 /* force in a delimiter */
 470                 *lp++ = '\0';
 471                 nf++;
 472                 if (nf > MAXDATEFIELDS)
 473                         return -1;
 474 #ifdef DATEDEBUG
 475                 printf("ParseDateTime- set field[%d] to %s type %d\n", (nf - 1), field[nf - 1], ftype[nf - 1]);
 476 #endif
 477         }
 478
 479         *numfields = nf;
 480
 481         return 0;
 482 }       /* ParseDateTime() */
 483
 484
 485 /* DecodeDateTime()
 486  * Interpret previously parsed fields for general date and time.
 487  * Return 0 if full date, 1 if only time, and -1 if problems.
 488  *              External format(s):
 489  *                              "<weekday> <month>-<day>-<year> <hour>:<minute>:<second>"
 490  *                              "Fri Feb-7-1997 15:23:27"
 491  *                              "Feb-7-1997 15:23:27"
 492  *                              "2-7-1997 15:23:27"
 493  *                              "1997-2-7 15:23:27"
 494  *                              "1997.038 15:23:27"             (day of year 1-366)
 495  *              Also supports input in compact time:
 496  *                              "970207 152327"
 497  *                              "97038 152327"
 498  *
 499  * Use the system-provided functions to get the current time zone
 500  *      if not specified in the input string.
 501  * If the date is outside the time_t system-supported time range,
 502  *      then assume GMT time zone. - tgl 97/05/27
 503  */
 504 int
 505 DecodeDateTime(char **field, int *ftype, int nf,
 506                            int *dtype, struct tm * tm, double *fsec, int *tzp)
 507 {
 508         int                     fmask = 0,
 509                                 tmask,
 510                                 type;
 511         int                     i;
 512         int                     flen,
 513                                 val;
 514         int                     mer = HR24;
 515         int                     bc = FALSE;
 516
 517         *dtype = DTK_DATE;
 518         tm->tm_hour = 0;
 519         tm->tm_min = 0;
 520         tm->tm_sec = 0;
 521         *fsec = 0;
 522         tm->tm_isdst = -1;                      /* don't know daylight savings time status
 523                                                                  * apriori */
 524         if (tzp != NULL)
 525                 *tzp = 0;
 526
 527         for (i = 0; i < nf; i++)
 528         {
 529 #ifdef DATEDEBUG
 530                 printf("DecodeDateTime- field[%d] is %s (type %d)\n", i, field[i], ftype[i]);
 531 #endif
 532                 switch (ftype[i])
 533                 {
 534                         case DTK_DATE:
 535                                 if (DecodeDate(field[i], fmask, &tmask, tm) != 0)
 536                                         return -1;
 537                                 break;
 538
 539                         case DTK_TIME:
 540                                 if (DecodeTime(field[i], fmask, &tmask, tm, fsec) != 0)
 541                                         return -1;
 542
 543                                 /*
 544                                  * check upper limit on hours; other limits checked in
 545                                  * DecodeTime()
 546                                  */
 547                                 if (tm->tm_hour > 23)
 548                                         return -1;
 549                                 break;
 550
 551                         case DTK_TZ:
 552                                 if (tzp == NULL)
 553                                         return -1;
 554                                 if (DecodeTimezone(field[i], tzp) != 0)
 555                                         return -1;
 556                                 tmask = DTK_M(TZ);
 557                                 break;
 558
 559                         case DTK_NUMBER:
 560                                 flen = strlen(field[i]);
 561
 562                                 if (flen > 4)
 563                                 {
 564                                         if (DecodeNumberField(flen, field[i], fmask, &tmask, tm, fsec) != 0)
 565                                                 return -1;
 566
 567                                 }
 568                                 else
 569                                 {
 570                                         if (DecodeNumber(flen, field[i], fmask, &tmask, tm, fsec) != 0)
 571                                                 return -1;
 572                                 }
 573                                 break;
 574
 575                         case DTK_STRING:
 576                         case DTK_SPECIAL:
 577                                 type = DecodeSpecial(i, field[i], &val);
 578 #ifdef DATEDEBUG
 579                                 printf("DecodeDateTime- special field[%d] %s type=%d value=%d\n", i, field[i], type, val);
 580 #endif
 581                                 if (type == IGNOREFIELD)
 582                                         continue;
 583
 584                                 tmask = DTK_M(type);
 585                                 switch (type)
 586                                 {
 587                                         case RESERV:
 588 #ifdef DATEDEBUG
 589                                                 printf("DecodeDateTime- RESERV field %s value is %d\n", field[i], val);
 590 #endif
 591                                                 switch (val)
 592                                                 {
 593
 594                                                         default:
 595                                                                 *dtype = val;
 596                                                 }
 597
 598                                                 break;
 599
 600                                         case MONTH:
 601 #ifdef DATEDEBUG
 602                                                 printf("DecodeDateTime- month field %s value is %d\n", field[i], val);
 603 #endif
 604                                                 tm->tm_mon = val;
 605                                                 break;
 606
 607                                                 /*
 608                                                  * daylight savings time modifier (solves "MET
 609                                                  * DST" syntax)
 610                                                  */
 611                                         case DTZMOD:
 612                                                 tmask |= DTK_M(DTZ);
 613                                                 tm->tm_isdst = 1;
 614                                                 if (tzp == NULL)
 615                                                         return -1;
 616                                                 *tzp += val * 60;
 617                                                 break;
 618
 619                                         case DTZ:
 620
 621                                                 /*
 622                                                  * set mask for TZ here _or_ check for DTZ later
 623                                                  * when getting default timezone
 624                                                  */
 625                                                 tmask |= DTK_M(TZ);
 626                                                 tm->tm_isdst = 1;
 627                                                 if (tzp == NULL)
 628                                                         return -1;
 629                                                 *tzp = val * 60;
 630                                                 break;
 631
 632                                         case TZ:
 633                                                 tm->tm_isdst = 0;
 634                                                 if (tzp == NULL)
 635                                                         return -1;
 636                                                 *tzp = val * 60;
 637                                                 break;
 638
 639                                         case IGNOREFIELD:
 640                                                 break;
 641
 642                                         case AMPM:
 643                                                 mer = val;
 644                                                 break;
 645
 646                                         case ADBC:
 647                                                 bc = (val == BC);
 648                                                 break;
 649
 650                                         case DOW:
 651                                                 tm->tm_wday = val;
 652                                                 break;
 653
 654                                         default:
 655                                                 return -1;
 656                                 }
 657                                 break;
 658
 659                         default:
 660                                 return -1;
 661                 }
 662
 663 #ifdef DATEDEBUG
 664                 printf("DecodeDateTime- field[%d] %s (%08x/%08x) value is %d\n",
 665                            i, field[i], fmask, tmask, val);
 666 #endif
 667
 668                 if (tmask & fmask)
 669                         return -1;
 670                 fmask |= tmask;
 671         }
 672
 673         /* there is no year zero in AD/BC notation; i.e. "1 BC" == year 0 */
 674         if (bc)
 675                 tm->tm_year = -(tm->tm_year - 1);
 676
 677         if ((mer != HR24) && (tm->tm_hour > 12))
 678                 return -1;
 679         if ((mer == AM) && (tm->tm_hour == 12))
 680                 tm->tm_hour = 0;
 681         else if ((mer == PM) && (tm->tm_hour != 12))
 682                 tm->tm_hour += 12;
 683
 684 #ifdef DATEDEBUG
 685         printf("DecodeDateTime- mask %08x (%08x)", fmask, DTK_DATE_M);
 686         printf(" set y%04d m%02d d%02d", tm->tm_year, tm->tm_mon, tm->tm_mday);
 687         printf(" %02d:%02d:%02d\n", tm->tm_hour, tm->tm_min, tm->tm_sec);
 688 #endif
 689
 690         if ((*dtype == DTK_DATE) && ((fmask & DTK_DATE_M) != DTK_DATE_M))
 691                 return ((fmask & DTK_TIME_M) == DTK_TIME_M) ? 1 : -1;
 692
 693         /* timezone not specified? then find local timezone if possible */
 694         if ((*dtype == DTK_DATE) && ((fmask & DTK_DATE_M) == DTK_DATE_M)
 695                 && (tzp != NULL) && (!(fmask & DTK_M(TZ))))
 696         {
 697
 698                 /*
 699                  * daylight savings time modifier but no standard timezone? then
 700                  * error
 701                  */
 702                 if (fmask & DTK_M(DTZMOD))
 703                         return -1;
 704
 705                 if (IS_VALID_UTIME(tm->tm_year, tm->tm_mon, tm->tm_mday))
 706                 {
 707 #ifdef USE_POSIX_TIME
 708                         tm->tm_year -= 1900;
 709                         tm->tm_mon -= 1;
 710                         tm->tm_isdst = -1;
 711                         mktime(tm);
 712                         tm->tm_year += 1900;
 713                         tm->tm_mon += 1;
 714
 715 #ifdef HAVE_INT_TIMEZONE
 716                         *tzp = ((tm->tm_isdst > 0) ? (timezone - 3600) : timezone);
 717
 718 #else                                                   /* !HAVE_INT_TIMEZONE */
 719                         *tzp = -(tm->tm_gmtoff);        /* tm_gmtoff is Sun/DEC-ism */
 720 #endif
 721
 722 #else                                                   /* !USE_POSIX_TIME */
 723                         *tzp = CTimeZone;
 724 #endif
 725                 }
 726                 else
 727                 {
 728                         tm->tm_isdst = 0;
 729                         *tzp = 0;
 730                 }
 731         }
 732
 733         return 0;
 734 }       /* DecodeDateTime() */
 735
 736
 737 /* DecodeTimeOnly()
 738  * Interpret parsed string as time fields only.
 739  */
 740 int
 741 DecodeTimeOnly(char **field, int *ftype, int nf, int *dtype, struct tm * tm, double *fsec)
 742 {
 743         int                     fmask,
 744                                 tmask,
 745                                 type;
 746         int                     i;
 747         int                     flen,
 748                                 val;
 749         int                     mer = HR24;
 750
 751         *dtype = DTK_TIME;
 752         tm->tm_hour = 0;
 753         tm->tm_min = 0;
 754         tm->tm_sec = 0;
 755         tm->tm_isdst = -1;                      /* don't know daylight savings time status
 756                                                                  * apriori */
 757         *fsec = 0;
 758
 759         fmask = DTK_DATE_M;
 760
 761         for (i = 0; i < nf; i++)
 762         {
 763 #ifdef DATEDEBUG
 764                 printf("DecodeTimeOnly- field[%d] is %s (type %d)\n", i, field[i], ftype[i]);
 765 #endif
 766                 switch (ftype[i])
 767                 {
 768                         case DTK_TIME:
 769                                 if (DecodeTime(field[i], fmask, &tmask, tm, fsec) != 0)
 770                                         return -1;
 771                                 break;
 772
 773                         case DTK_NUMBER:
 774                                 flen = strlen(field[i]);
 775
 776                                 if (DecodeNumberField(flen, field[i], fmask, &tmask, tm, fsec) != 0)
 777                                         return -1;
 778                                 break;
 779
 780                         case DTK_STRING:
 781                         case DTK_SPECIAL:
 782                                 type = DecodeSpecial(i, field[i], &val);
 783 #ifdef DATEDEBUG
 784                                 printf("DecodeTimeOnly- special field[%d] %s type=%d value=%d\n", i, field[i], type, val);
 785 #endif
 786                                 if (type == IGNOREFIELD)
 787                                         continue;
 788
 789                                 tmask = DTK_M(type);
 790                                 switch (type)
 791                                 {
 792                                         case RESERV:
 793 #ifdef DATEDEBUG
 794                                                 printf("DecodeTimeOnly- RESERV field %s value is %d\n", field[i], val);
 795 #endif
 796                                                 switch (val)
 797                                                 {
 798
 799                                                         default:
 800                                                                 return -1;
 801                                                 }
 802
 803                                                 break;
 804
 805                                         case IGNOREFIELD:
 806                                                 break;
 807
 808                                         case AMPM:
 809                                                 mer = val;
 810                                                 break;
 811
 812                                         default:
 813                                                 return -1;
 814                                 }
 815                                 break;
 816
 817                         default:
 818                                 return -1;
 819                 }
 820
 821                 if (tmask & fmask)
 822                         return -1;
 823                 fmask |= tmask;
 824
 825 #ifdef DATEDEBUG
 826                 printf("DecodeTimeOnly- field[%d] %s value is %d\n", i, field[i], val);
 827 #endif
 828         }
 829
 830 #ifdef DATEDEBUG
 831         printf("DecodeTimeOnly- mask %08x (%08x)", fmask, DTK_TIME_M);
 832         printf(" %02d:%02d:%02d (%f)\n", tm->tm_hour, tm->tm_min, tm->tm_sec, *fsec);
 833 #endif
 834
 835         if ((mer != HR24) && (tm->tm_hour > 12))
 836                 return -1;
 837         if ((mer == AM) && (tm->tm_hour == 12))
 838                 tm->tm_hour = 0;
 839         else if ((mer == PM) && (tm->tm_hour != 12))
 840                 tm->tm_hour += 12;
 841
 842         if ((fmask & DTK_TIME_M) != DTK_TIME_M)
 843                 return -1;
 844
 845         return 0;
 846 }       /* DecodeTimeOnly() */
 847
 848
 849 /* DecodeDate()
 850  * Decode date string which includes delimiters.
 851  * Insist on a complete set of fields.
 852  */
 853 static int
 854 DecodeDate(char *str, int fmask, int *tmask, struct tm * tm)
 855 {
 856         double          fsec;
 857
 858         int                     nf = 0;
 859         int                     i,
 860                                 len;
 861         int                     type,
 862                                 val,
 863                                 dmask = 0;
 864         char       *field[MAXDATEFIELDS];
 865
 866         /* parse this string... */
 867         while ((*str != '\0') && (nf < MAXDATEFIELDS))
 868         {
 869                 /* skip field separators */
 870                 while (!isalnum(*str))
 871                         str++;
 872
 873                 field[nf] = str;
 874                 if (isdigit(*str))
 875                 {
 876                         while (isdigit(*str))
 877                                 str++;
 878                 }
 879                 else if (isalpha(*str))
 880                 {
 881                         while (isalpha(*str))
 882                                 str++;
 883                 }
 884
 885                 if (*str != '\0')
 886                         *str++ = '\0';
 887                 nf++;
 888         }
 889
 890         /* don't allow too many fields */
 891         if (nf > 3)
 892                 return -1;
 893
 894         *tmask = 0;
 895
 896         /* look first for text fields, since that will be unambiguous month */
 897         for (i = 0; i < nf; i++)
 898         {
 899                 if (isalpha(*field[i]))
 900                 {
 901                         type = DecodeSpecial(i, field[i], &val);
 902                         if (type == IGNOREFIELD)
 903                                 continue;
 904
 905                         dmask = DTK_M(type);
 906                         switch (type)
 907                         {
 908                                 case MONTH:
 909 #ifdef DATEDEBUG
 910                                         printf("DecodeDate- month field %s value is %d\n", field[i], val);
 911 #endif
 912                                         tm->tm_mon = val;
 913                                         break;
 914
 915                                 default:
 916 #ifdef DATEDEBUG
 917                                         printf("DecodeDate- illegal field %s value is %d\n", field[i], val);
 918 #endif
 919                                         return -1;
 920                         }
 921                         if (fmask & dmask)
 922                                 return -1;
 923
 924                         fmask |= dmask;
 925                         *tmask |= dmask;
 926
 927                         /* mark this field as being completed */
 928                         field[i] = NULL;
 929                 }
 930         }
 931
 932         /* now pick up remaining numeric fields */
 933         for (i = 0; i < nf; i++)
 934         {
 935                 if (field[i] == NULL)
 936                         continue;
 937
 938                 if ((len = strlen(field[i])) <= 0)
 939                         return -1;
 940
 941                 if (DecodeNumber(len, field[i], fmask, &dmask, tm, &fsec) != 0)
 942                         return -1;
 943
 944                 if (fmask & dmask)
 945                         return -1;
 946
 947                 fmask |= dmask;
 948                 *tmask |= dmask;
 949         }
 950
 951         return 0;
 952 }       /* DecodeDate() */
 953
 954
 955 /* DecodeTime()
 956  * Decode time string which includes delimiters.
 957  * Only check the lower limit on hours, since this same code
 958  *      can be used to represent time spans.
 959  */
 960 static int
 961 DecodeTime(char *str, int fmask, int *tmask, struct tm * tm, double *fsec)
 962 {
 963         char       *cp;
 964
 965         *tmask = DTK_TIME_M;
 966
 967         tm->tm_hour = strtol(str, &cp, 10);
 968         if (*cp != ':')
 969                 return -1;
 970         str = cp + 1;
 971         tm->tm_min = strtol(str, &cp, 10);
 972         if (*cp == '\0')
 973         {
 974                 tm->tm_sec = 0;
 975                 *fsec = 0;
 976
 977         }
 978         else if (*cp != ':')
 979         {
 980                 return -1;
 981
 982         }
 983         else
 984         {
 985                 str = cp + 1;
 986                 tm->tm_sec = strtol(str, &cp, 10);
 987                 if (*cp == '\0')
 988                         *fsec = 0;
 989                 else if (*cp == '.')
 990                 {
 991                         str = cp;
 992                         *fsec = strtod(str, &cp);
 993                         if (cp == str)
 994                                 return -1;
 995                 }
 996                 else
 997                         return -1;
 998         }
 999
1000         /* do a sanity check */
1001         if ((tm->tm_hour < 0)
1002                 || (tm->tm_min < 0) || (tm->tm_min > 59)
1003                 || (tm->tm_sec < 0) || (tm->tm_sec > 59))
1004                 return -1;
1005
1006         return 0;
1007 }       /* DecodeTime() */
1008
1009
1010 /* DecodeNumber()
1011  * Interpret numeric field as a date value in context.
1012  */
1013 static int
1014 DecodeNumber(int flen, char *str, int fmask, int *tmask, struct tm * tm, double *fsec)
1015 {
1016         int                     val;
1017         char       *cp;
1018
1019         *tmask = 0;
1020
1021         val = strtol(str, &cp, 10);
1022         if (cp == str)
1023                 return -1;
1024         if (*cp == '.')
1025         {
1026                 *fsec = strtod(cp, &cp);
1027                 if (*cp != '\0')
1028                         return -1;
1029         }
1030
1031 #ifdef DATEDEBUG
1032         printf("DecodeNumber- %s is %d fmask=%08x tmask=%08x\n", str, val, fmask, *tmask);
1033 #endif
1034
1035         /* enough digits to be unequivocal year? */
1036         if (flen == 4)
1037         {
1038 #ifdef DATEDEBUG
1039                 printf("DecodeNumber- match %d (%s) as year\n", val, str);
1040 #endif
1041                 *tmask = DTK_M(YEAR);
1042
1043                 /* already have a year? then see if we can substitute... */
1044                 if (fmask & DTK_M(YEAR))
1045                 {
1046                         if ((!(fmask & DTK_M(DAY)))
1047                                 && ((tm->tm_year >= 1) && (tm->tm_year <= 31)))
1048                         {
1049 #ifdef DATEDEBUG
1050                                 printf("DecodeNumber- misidentified year previously; swap with day %d\n", tm->tm_mday);
1051 #endif
1052                                 tm->tm_mday = tm->tm_year;
1053                                 *tmask = DTK_M(DAY);
1054                         }
1055                 }
1056
1057                 tm->tm_year = val;
1058
1059                 /* special case day of year? */
1060         }
1061         else if ((flen == 3) && (fmask & DTK_M(YEAR))
1062                          && ((val >= 1) && (val <= 366)))
1063         {
1064                 *tmask = (DTK_M(DOY) | DTK_M(MONTH) | DTK_M(DAY));
1065                 tm->tm_yday = val;
1066                 j2date((date2j(tm->tm_year, 1, 1) + tm->tm_yday - 1),
1067                            &tm->tm_year, &tm->tm_mon, &tm->tm_mday);
1068
1069                 /* already have year? then could be month */
1070         }
1071         else if ((fmask & DTK_M(YEAR)) && (!(fmask & DTK_M(MONTH)))
1072                          && ((val >= 1) && (val <= 12)))
1073         {
1074 #ifdef DATEDEBUG
1075                 printf("DecodeNumber- match %d (%s) as month\n", val, str);
1076 #endif
1077                 *tmask = DTK_M(MONTH);
1078                 tm->tm_mon = val;
1079
1080                 /* no year and EuroDates enabled? then could be day */
1081         }
1082         else if ((EuroDates || (fmask & DTK_M(MONTH)))
1083                          && (!(fmask & DTK_M(YEAR)) && !(fmask & DTK_M(DAY)))
1084                          && ((val >= 1) && (val <= 31)))
1085         {
1086 #ifdef DATEDEBUG
1087                 printf("DecodeNumber- match %d (%s) as day\n", val, str);
1088 #endif
1089                 *tmask = DTK_M(DAY);
1090                 tm->tm_mday = val;
1091
1092         }
1093         else if ((!(fmask & DTK_M(MONTH)))
1094                          && ((val >= 1) && (val <= 12)))
1095         {
1096 #ifdef DATEDEBUG
1097                 printf("DecodeNumber- (2) match %d (%s) as month\n", val, str);
1098 #endif
1099                 *tmask = DTK_M(MONTH);
1100                 tm->tm_mon = val;
1101
1102         }
1103         else if ((!(fmask & DTK_M(DAY)))
1104                          && ((val >= 1) && (val <= 31)))
1105         {
1106 #ifdef DATEDEBUG
1107                 printf("DecodeNumber- (2) match %d (%s) as day\n", val, str);
1108 #endif
1109                 *tmask = DTK_M(DAY);
1110                 tm->tm_mday = val;
1111
1112         }
1113         else if (!(fmask & DTK_M(YEAR)))
1114         {
1115 #ifdef DATEDEBUG
1116                 printf("DecodeNumber- (2) match %d (%s) as year\n", val, str);
1117 #endif
1118                 *tmask = DTK_M(YEAR);
1119                 tm->tm_year = val;
1120                 if (tm->tm_year < 70)
1121                         tm->tm_year += 2000;
1122                 else if (tm->tm_year < 100)
1123                         tm->tm_year += 1900;
1124
1125         }
1126         else
1127                 return -1;
1128
1129         return 0;
1130 }       /* DecodeNumber() */
1131
1132
1133 /* DecodeNumberField()
1134  * Interpret numeric string as a concatenated date field.
1135  */
1136 static int
1137 DecodeNumberField(int len, char *str, int fmask, int *tmask, struct tm * tm, double *fsec)
1138 {
1139         char       *cp;
1140
1141         /* yyyymmdd? */
1142         if (len == 8)
1143         {
1144 #ifdef DATEDEBUG
1145                 printf("DecodeNumberField- %s is 8 character date fmask=%08x tmask=%08x\n", str, fmask, *tmask);
1146 #endif
1147
1148                 *tmask = DTK_DATE_M;
1149
1150                 tm->tm_mday = atoi(str + 6);
1151                 *(str + 6) = '\0';
1152                 tm->tm_mon = atoi(str + 4);
1153                 *(str + 4) = '\0';
1154                 tm->tm_year = atoi(str + 0);
1155
1156                 /* yymmdd or hhmmss? */
1157         }
1158         else if (len == 6)
1159         {
1160 #ifdef DATEDEBUG
1161                 printf("DecodeNumberField- %s is 6 characters fmask=%08x tmask=%08x\n", str, fmask, *tmask);
1162 #endif
1163                 if (fmask & DTK_DATE_M)
1164                 {
1165 #ifdef DATEDEBUG
1166                         printf("DecodeNumberField- %s is time field fmask=%08x tmask=%08x\n", str, fmask, *tmask);
1167 #endif
1168                         *tmask = DTK_TIME_M;
1169                         tm->tm_sec = atoi(str + 4);
1170                         *(str + 4) = '\0';
1171                         tm->tm_min = atoi(str + 2);
1172                         *(str + 2) = '\0';
1173                         tm->tm_hour = atoi(str + 0);
1174
1175                 }
1176                 else
1177                 {
1178 #ifdef DATEDEBUG
1179                         printf("DecodeNumberField- %s is date field fmask=%08x tmask=%08x\n", str, fmask, *tmask);
1180 #endif
1181                         *tmask = DTK_DATE_M;
1182                         tm->tm_mday = atoi(str + 4);
1183                         *(str + 4) = '\0';
1184                         tm->tm_mon = atoi(str + 2);
1185                         *(str + 2) = '\0';
1186                         tm->tm_year = atoi(str + 0);
1187                 }
1188
1189         }
1190         else if (strchr(str, '.') != NULL)
1191         {
1192 #ifdef DATEDEBUG
1193                 printf("DecodeNumberField- %s is time field fmask=%08x tmask=%08x\n", str, fmask, *tmask);
1194 #endif
1195                 *tmask = DTK_TIME_M;
1196                 tm->tm_sec = strtod((str + 4), &cp);
1197                 if (cp == (str + 4))
1198                         return -1;
1199                 if (*cp == '.')
1200                         *fsec = strtod(cp, NULL);
1201                 *(str + 4) = '\0';
1202                 tm->tm_min = strtod((str + 2), &cp);
1203                 *(str + 2) = '\0';
1204                 tm->tm_hour = strtod((str + 0), &cp);
1205
1206         }
1207         else
1208                 return -1;
1209
1210         return 0;
1211 }       /* DecodeNumberField() */
1212
1213
1214 /* DecodeTimezone()
1215  * Interpret string as a numeric timezone.
1216  */
1217 static int
1218 DecodeTimezone(char *str, int *tzp)
1219 {
1220         int                     tz;
1221         int                     hr,
1222                                 min;
1223         char       *cp;
1224         int                     len;
1225
1226         /* assume leading character is "+" or "-" */
1227         hr = strtol((str + 1), &cp, 10);
1228
1229         /* explicit delimiter? */
1230         if (*cp == ':')
1231         {
1232                 min = strtol((cp + 1), &cp, 10);
1233
1234                 /* otherwise, might have run things together... */
1235         }
1236         else if ((*cp == '\0') && ((len = strlen(str)) > 3))
1237         {
1238                 min = strtol((str + len - 2), &cp, 10);
1239                 *(str + len - 2) = '\0';
1240                 hr = strtol((str + 1), &cp, 10);
1241
1242         }
1243         else
1244                 min = 0;
1245
1246         tz = (hr * 60 + min) * 60;
1247         if (*str == '-')
1248                 tz = -tz;
1249
1250         *tzp = -tz;
1251         return *cp != '\0';
1252 }       /* DecodeTimezone() */
1253
1254
1255 /* DecodeSpecial()
1256  * Decode text string using lookup table.
1257  * Implement a cache lookup since it is likely that dates
1258  *      will be related in format.
1259  */
1260 static int
1261 DecodeSpecial(int field, char *lowtoken, int *val)
1262 {
1263         int                     type;
1264         datetkn    *tp;
1265
1266 #if USE_DATE_CACHE
1267         if ((datecache[field] != NULL)
1268                 && (strncmp(lowtoken, datecache[field]->token, TOKMAXLEN) == 0))
1269                 tp = datecache[field];
1270         else
1271         {
1272 #endif
1273                 tp = datebsearch(lowtoken, datetktbl, szdatetktbl);
1274 #if USE_DATE_CACHE
1275         }
1276         datecache[field] = tp;
1277 #endif
1278         if (tp == NULL)
1279         {
1280                 type = IGNOREFIELD;
1281                 *val = 0;
1282         }
1283         else
1284         {
1285                 type = tp->type;
1286                 switch (type)
1287                 {
1288                         case TZ:
1289                         case DTZ:
1290                         case DTZMOD:
1291                                 *val = FROMVAL(tp);
1292                                 break;
1293
1294                         default:
1295                                 *val = tp->value;
1296                                 break;
1297                 }
1298         }
1299
1300         return type;
1301 }       /* DecodeSpecial() */
1302
1303
1304
1305 /* datebsearch()
1306  * Binary search -- from Knuth (6.2.1) Algorithm B.  Special case like this
1307  * is WAY faster than the generic bsearch().
1308  */
1309 static datetkn *
1310 datebsearch(char *key, datetkn *base, unsigned int nel)
1311 {
1312         datetkn    *last = base + nel - 1,
1313                            *position;
1314         int                     result;
1315
1316         while (last >= base)
1317         {
1318                 position = base + ((last - base) >> 1);
1319                 result = key[0] - position->token[0];
1320                 if (result == 0)
1321                 {
1322                         result = strncmp(key, position->token, TOKMAXLEN);
1323                         if (result == 0)
1324                                 return position;
1325                 }
1326                 if (result < 0)
1327                         last = position - 1;
1328                 else
1329                         base = position + 1;
1330         }
1331         return NULL;
1332 }
1333
1334
1335