?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixed some issues found by winapi_check.
[wine/dcerpc.git] / dlls / oleaut32 / parsedt.c
blob57eb33d9f08231e921521574b166487ecf8d5ce1
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 <limits.h>
42 #include <sys/timeb.h>
43
44 #include "parsedt.h"
45
46 static datetkn *datebsearch(char *key, datetkn *base, unsigned int nel);
47 static int DecodeDate(char *str, int fmask, int *tmask, struct tm * tm);
48 static int DecodeNumber(int flen, char *field,
49 int fmask, int *tmask, struct tm * tm, double *fsec);
50 static int DecodeNumberField(int len, char *str,
51 int fmask, int *tmask, struct tm * tm, double *fsec);
52 static int DecodeSpecial(int field, char *lowtoken, int *val);
53 static int DecodeTime(char *str, int fmask, int *tmask,
54 struct tm * tm, double *fsec);
55 static int DecodeTimezone(char *str, int *tzp);
56
57 #define USE_DATE_CACHE 1
58 #define ROUND_ALL 0
59
60 static const int mdays[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 0};
61
62 static const char * const months[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
63 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", NULL};
64
65 static const char * const days[] = {"Sunday", "Monday", "Tuesday", "Wednesday",
66 "Thursday", "Friday", "Saturday", NULL};
67
68 /* those three vars are useless, and not even initialized, so
69 * I'd rather remove them all (EPP)
70 */
71 int DateStyle;
72 bool EuroDates;
73 int CTimeZone;
74
75 #define UTIME_MINYEAR (1901)
76 #define UTIME_MINMONTH (12)
77 #define UTIME_MINDAY (14)
78 #define UTIME_MAXYEAR (2038)
79 #define UTIME_MAXMONTH (01)
80 #define UTIME_MAXDAY (18)
81
82 /* Assumes month in 1..12. Note tm_mon is 0..11 */
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_mon is 0->11, so need to subtract one from value in table */
605 tm->tm_mon = val-1;
606 break;
607
608 /*
609 * daylight savings time modifier (solves "MET
610 * DST" syntax)
611 */
612 case DTZMOD:
613 tmask |= DTK_M(DTZ);
614 tm->tm_isdst = 1;
615 if (tzp == NULL)
616 return -1;
617 *tzp += val * 60;
618 break;
619
620 case DTZ:
621
622 /*
623 * set mask for TZ here _or_ check for DTZ later
624 * when getting default timezone
625 */
626 tmask |= DTK_M(TZ);
627 tm->tm_isdst = 1;
628 if (tzp == NULL)
629 return -1;
630 *tzp = val * 60;
631 break;
632
633 case TZ:
634 tm->tm_isdst = 0;
635 if (tzp == NULL)
636 return -1;
637 *tzp = val * 60;
638 break;
639
640 case IGNOREFIELD:
641 break;
642
643 case AMPM:
644 mer = val;
645 break;
646
647 case ADBC:
648 bc = (val == BC);
649 break;
650
651 case DOW:
652 tm->tm_wday = val;
653 break;
654
655 default:
656 return -1;
657 }
658 break;
659
660 default:
661 return -1;
662 }
663
664 #ifdef DATEDEBUG
665 printf("DecodeDateTime- field[%d] %s (%08x/%08x) value is %d\n",
666 i, field[i], fmask, tmask, val);
667 #endif
668
669 if (tmask & fmask)
670 return -1;
671 fmask |= tmask;
672 }
673
674 /* there is no year zero in AD/BC notation; i.e. "1 BC" == year 0 */
675 if (bc)
676 tm->tm_year = -(tm->tm_year - 1);
677
678 if ((mer != HR24) && (tm->tm_hour > 12))
679 return -1;
680 if ((mer == AM) && (tm->tm_hour == 12))
681 tm->tm_hour = 0;
682 else if ((mer == PM) && (tm->tm_hour != 12))
683 tm->tm_hour += 12;
684
685 /* If parsing a time string into a date, all date parts are unset.
686 Win2k defaults these to 30 dec, 1899 so: */
687 if (tm->tm_year == 0 && tm->tm_mon == 0 && tm->tm_mday == 0 && fmask == DTK_TIME_M) {
688 tm->tm_year = 1899;
689 tm->tm_mon = 11; /* December, as tm_mon is 0..11 */
690 tm->tm_mday = 30;
691 }
692
693
694 #ifdef DATEDEBUG
695 printf("DecodeDateTime- mask %08x (%08x)", fmask, DTK_DATE_M);
696 printf(" set y%04d m%02d d%02d", tm->tm_year, (tm->tm_mon+1), tm->tm_mday);
697 printf(" %02d:%02d:%02d\n", tm->tm_hour, tm->tm_min, tm->tm_sec);
698 #endif
699
700 if ((*dtype == DTK_DATE) && ((fmask & DTK_DATE_M) != DTK_DATE_M))
701 return ((fmask & DTK_TIME_M) == DTK_TIME_M) ? 1 : -1;
702
703 /* timezone not specified? then find local timezone if possible */
704 if ((*dtype == DTK_DATE) && ((fmask & DTK_DATE_M) == DTK_DATE_M)
705 && (tzp != NULL) && (!(fmask & DTK_M(TZ))))
706 {
707
708 /*
709 * daylight savings time modifier but no standard timezone? then
710 * error
711 */
712 if (fmask & DTK_M(DTZMOD))
713 return -1;
714
715 if (IS_VALID_UTIME(tm->tm_year, tm->tm_mon+1, tm->tm_mday))
716 {
717 /* FIXME: The code below is not correct */
718 #if 0 /* defined(USE_POSIX_TIME) */
719 tm->tm_year -= 1900;
720 tm->tm_mon -= 1;
721 tm->tm_isdst = -1;
722 mktime(tm);
723 tm->tm_year += 1900;
724 tm->tm_mon += 1;
725
726 #if 0 /* defined(HAVE_INT_TIMEZONE) */
727 *tzp = ((tm->tm_isdst > 0) ? (timezone - 3600) : timezone);
728
729 #else /* !HAVE_INT_TIMEZONE */
730 *tzp = -(tm->tm_gmtoff); /* tm_gmtoff is Sun/DEC-ism */
731 #endif
732
733 #else /* !USE_POSIX_TIME */
734 *tzp = CTimeZone;
735 #endif
736 }
737 else
738 {
739 tm->tm_isdst = 0;
740 *tzp = 0;
741 }
742 }
743
744 return 0;
745 } /* DecodeDateTime() */
746
747
748 /* DecodeTimeOnly()
749 * Interpret parsed string as time fields only.
750 */
751 int
752 DecodeTimeOnly(char **field, int *ftype, int nf, int *dtype, struct tm * tm, double *fsec)
753 {
754 int fmask,
755 tmask,
756 type;
757 int i;
758 int flen,
759 val;
760 int mer = HR24;
761
762 *dtype = DTK_TIME;
763 tm->tm_hour = 0;
764 tm->tm_min = 0;
765 tm->tm_sec = 0;
766 tm->tm_isdst = -1; /* don't know daylight savings time status
767 * apriori */
768 *fsec = 0;
769
770 fmask = DTK_DATE_M;
771
772 for (i = 0; i < nf; i++)
773 {
774 #ifdef DATEDEBUG
775 printf("DecodeTimeOnly- field[%d] is %s (type %d)\n", i, field[i], ftype[i]);
776 #endif
777 switch (ftype[i])
778 {
779 case DTK_TIME:
780 if (DecodeTime(field[i], fmask, &tmask, tm, fsec) != 0)
781 return -1;
782 break;
783
784 case DTK_NUMBER:
785 flen = strlen(field[i]);
786
787 if (DecodeNumberField(flen, field[i], fmask, &tmask, tm, fsec) != 0)
788 return -1;
789 break;
790
791 case DTK_STRING:
792 case DTK_SPECIAL:
793 type = DecodeSpecial(i, field[i], &val);
794 #ifdef DATEDEBUG
795 printf("DecodeTimeOnly- special field[%d] %s type=%d value=%d\n", i, field[i], type, val);
796 #endif
797 if (type == IGNOREFIELD)
798 continue;
799
800 tmask = DTK_M(type);
801 switch (type)
802 {
803 case RESERV:
804 #ifdef DATEDEBUG
805 printf("DecodeTimeOnly- RESERV field %s value is %d\n", field[i], val);
806 #endif
807 switch (val)
808 {
809
810 default:
811 return -1;
812 }
813
814 break;
815
816 case IGNOREFIELD:
817 break;
818
819 case AMPM:
820 mer = val;
821 break;
822
823 default:
824 return -1;
825 }
826 break;
827
828 default:
829 return -1;
830 }
831
832 if (tmask & fmask)
833 return -1;
834 fmask |= tmask;
835
836 #ifdef DATEDEBUG
837 printf("DecodeTimeOnly- field[%d] %s value is %d\n", i, field[i], val);
838 #endif
839 }
840
841 #ifdef DATEDEBUG
842 printf("DecodeTimeOnly- mask %08x (%08x)", fmask, DTK_TIME_M);
843 printf(" %02d:%02d:%02d (%f)\n", tm->tm_hour, tm->tm_min, tm->tm_sec, *fsec);
844 #endif
845
846 if ((mer != HR24) && (tm->tm_hour > 12))
847 return -1;
848 if ((mer == AM) && (tm->tm_hour == 12))
849 tm->tm_hour = 0;
850 else if ((mer == PM) && (tm->tm_hour != 12))
851 tm->tm_hour += 12;
852
853 if ((fmask & DTK_TIME_M) != DTK_TIME_M)
854 return -1;
855
856 return 0;
857 } /* DecodeTimeOnly() */
858
859
860 /* DecodeDate()
861 * Decode date string which includes delimiters.
862 * Insist on a complete set of fields.
863 */
864 static int
865 DecodeDate(char *str, int fmask, int *tmask, struct tm * tm)
866 {
867 double fsec;
868
869 int nf = 0;
870 int i,
871 len;
872 int type,
873 val,
874 dmask = 0;
875 char *field[MAXDATEFIELDS];
876
877 /* parse this string... */
878 while ((*str != '\0') && (nf < MAXDATEFIELDS))
879 {
880 /* skip field separators */
881 while (!isalnum(*str))
882 str++;
883
884 field[nf] = str;
885 if (isdigit(*str))
886 {
887 while (isdigit(*str))
888 str++;
889 }
890 else if (isalpha(*str))
891 {
892 while (isalpha(*str))
893 str++;
894 }
895
896 if (*str != '\0')
897 *str++ = '\0';
898 nf++;
899 }
900
901 /* don't allow too many fields */
902 if (nf > 3)
903 return -1;
904
905 *tmask = 0;
906
907 /* look first for text fields, since that will be unambiguous month */
908 for (i = 0; i < nf; i++)
909 {
910 if (isalpha(*field[i]))
911 {
912 type = DecodeSpecial(i, field[i], &val);
913 if (type == IGNOREFIELD)
914 continue;
915
916 dmask = DTK_M(type);
917 switch (type)
918 {
919 case MONTH:
920 #ifdef DATEDEBUG
921 printf("DecodeDate- month field %s value is %d\n", field[i], val);
922 #endif
923 /* tm_mon is 0->11, so need to subtract one from value in table */
924 tm->tm_mon = val-1;
925 break;
926
927 default:
928 #ifdef DATEDEBUG
929 printf("DecodeDate- illegal field %s value is %d\n", field[i], val);
930 #endif
931 return -1;
932 }
933 if (fmask & dmask)
934 return -1;
935
936 fmask |= dmask;
937 *tmask |= dmask;
938
939 /* mark this field as being completed */
940 field[i] = NULL;
941 }
942 }
943
944 /* now pick up remaining numeric fields */
945 for (i = 0; i < nf; i++)
946 {
947 if (field[i] == NULL)
948 continue;
949
950 if ((len = strlen(field[i])) <= 0)
951 return -1;
952
953 if (DecodeNumber(len, field[i], fmask, &dmask, tm, &fsec) != 0)
954 return -1;
955
956 if (fmask & dmask)
957 return -1;
958
959 fmask |= dmask;
960 *tmask |= dmask;
961 }
962
963 return 0;
964 } /* DecodeDate() */
965
966
967 /* DecodeTime()
968 * Decode time string which includes delimiters.
969 * Only check the lower limit on hours, since this same code
970 * can be used to represent time spans.
971 */
972 static int
973 DecodeTime(char *str, int fmask, int *tmask, struct tm * tm, double *fsec)
974 {
975 char *cp;
976
977 *tmask = DTK_TIME_M;
978
979 tm->tm_hour = strtol(str, &cp, 10);
980 if (*cp != ':')
981 return -1;
982 str = cp + 1;
983 tm->tm_min = strtol(str, &cp, 10);
984 if (*cp == '\0')
985 {
986 tm->tm_sec = 0;
987 *fsec = 0;
988
989 }
990 else if (*cp != ':')
991 {
992 return -1;
993
994 }
995 else
996 {
997 str = cp + 1;
998 tm->tm_sec = strtol(str, &cp, 10);
999 if (*cp == '\0')
1000 *fsec = 0;
1001 else if (*cp == '.')
1002 {
1003 str = cp;
1004 *fsec = strtod(str, &cp);
1005 if (cp == str)
1006 return -1;
1007 }
1008 else
1009 return -1;
1010 }
1011
1012 /* do a sanity check */
1013 if ((tm->tm_hour < 0)
1014 || (tm->tm_min < 0) || (tm->tm_min > 59)
1015 || (tm->tm_sec < 0) || (tm->tm_sec > 59))
1016 return -1;
1017
1018 return 0;
1019 } /* DecodeTime() */
1020
1021
1022 /* DecodeNumber()
1023 * Interpret numeric field as a date value in context.
1024 */
1025 static int
1026 DecodeNumber(int flen, char *str, int fmask, int *tmask, struct tm * tm, double *fsec)
1027 {
1028 int val;
1029 char *cp;
1030
1031 *tmask = 0;
1032
1033 val = strtol(str, &cp, 10);
1034 if (cp == str)
1035 return -1;
1036 if (*cp == '.')
1037 {
1038 *fsec = strtod(cp, &cp);
1039 if (*cp != '\0')
1040 return -1;
1041 }
1042
1043 #ifdef DATEDEBUG
1044 printf("DecodeNumber- %s is %d fmask=%08x tmask=%08x\n", str, val, fmask, *tmask);
1045 #endif
1046
1047 /* enough digits to be unequivocal year? */
1048 if (flen == 4)
1049 {
1050 #ifdef DATEDEBUG
1051 printf("DecodeNumber- match %d (%s) as year\n", val, str);
1052 #endif
1053 *tmask = DTK_M(YEAR);
1054
1055 /* already have a year? then see if we can substitute... */
1056 if (fmask & DTK_M(YEAR))
1057 {
1058 if ((!(fmask & DTK_M(DAY)))
1059 && ((tm->tm_year >= 1) && (tm->tm_year <= 31)))
1060 {
1061 #ifdef DATEDEBUG
1062 printf("DecodeNumber- misidentified year previously; swap with day %d\n", tm->tm_mday);
1063 #endif
1064 tm->tm_mday = tm->tm_year;
1065 *tmask = DTK_M(DAY);
1066 }
1067 }
1068
1069 tm->tm_year = val;
1070
1071 /* special case day of year? */
1072 }
1073 else if ((flen == 3) && (fmask & DTK_M(YEAR))
1074 && ((val >= 1) && (val <= 366)))
1075 {
1076 *tmask = (DTK_M(DOY) | DTK_M(MONTH) | DTK_M(DAY));
1077 tm->tm_yday = val;
1078 j2date((date2j(tm->tm_year, 1, 1) + tm->tm_yday - 1),
1079 &tm->tm_year, &tm->tm_mon, &tm->tm_mday);
1080
1081 /* already have year? then could be month */
1082 }
1083 else if ((fmask & DTK_M(YEAR)) && (!(fmask & DTK_M(MONTH)))
1084 && ((val >= 1) && (val <= 12)))
1085 {
1086 #ifdef DATEDEBUG
1087 printf("DecodeNumber- match %d (%s) as month\n", val, str);
1088 #endif
1089 *tmask = DTK_M(MONTH);
1090 /* tm_mon is 0..11 */
1091 tm->tm_mon = val-1;
1092
1093 /* no year and EuroDates enabled? then could be day */
1094 }
1095 else if ((EuroDates || (fmask & DTK_M(MONTH)))
1096 && (!(fmask & DTK_M(YEAR)) && !(fmask & DTK_M(DAY)))
1097 && ((val >= 1) && (val <= 31)))
1098 {
1099 #ifdef DATEDEBUG
1100 printf("DecodeNumber- match %d (%s) as day\n", val, str);
1101 #endif
1102 *tmask = DTK_M(DAY);
1103 tm->tm_mday = val;
1104
1105 }
1106 else if ((!(fmask & DTK_M(MONTH)))
1107 && ((val >= 1) && (val <= 12)))
1108 {
1109 #ifdef DATEDEBUG
1110 printf("DecodeNumber- (2) match %d (%s) as month\n", val, str);
1111 #endif
1112 *tmask = DTK_M(MONTH);
1113 /* tm_mon is 0..11 */
1114 tm->tm_mon = val-1;
1115
1116 }
1117 else if ((!(fmask & DTK_M(DAY)))
1118 && ((val >= 1) && (val <= 31)))
1119 {
1120 #ifdef DATEDEBUG
1121 printf("DecodeNumber- (2) match %d (%s) as day\n", val, str);
1122 #endif
1123 *tmask = DTK_M(DAY);
1124 tm->tm_mday = val;
1125
1126 }
1127 else if (!(fmask & DTK_M(YEAR)))
1128 {
1129 #ifdef DATEDEBUG
1130 printf("DecodeNumber- (2) match %d (%s) as year\n", val, str);
1131 #endif
1132 *tmask = DTK_M(YEAR);
1133 tm->tm_year = val;
1134 if (tm->tm_year < 70)
1135 tm->tm_year += 2000;
1136 else if (tm->tm_year < 100)
1137 tm->tm_year += 1900;
1138
1139 }
1140 else
1141 return -1;
1142
1143 return 0;
1144 } /* DecodeNumber() */
1145
1146
1147 /* DecodeNumberField()
1148 * Interpret numeric string as a concatenated date field.
1149 */
1150 static int
1151 DecodeNumberField(int len, char *str, int fmask, int *tmask, struct tm * tm, double *fsec)
1152 {
1153 char *cp;
1154
1155 /* yyyymmdd? */
1156 if (len == 8)
1157 {
1158 #ifdef DATEDEBUG
1159 printf("DecodeNumberField- %s is 8 character date fmask=%08x tmask=%08x\n", str, fmask, *tmask);
1160 #endif
1161
1162 *tmask = DTK_DATE_M;
1163
1164 tm->tm_mday = atoi(str + 6);
1165 *(str + 6) = '\0';
1166 tm->tm_mon = atoi(str + 4) - 1; /* tm_mon is 0..11 */
1167 *(str + 4) = '\0';
1168 tm->tm_year = atoi(str + 0);
1169
1170 /* yymmdd or hhmmss? */
1171 }
1172 else if (len == 6)
1173 {
1174 #ifdef DATEDEBUG
1175 printf("DecodeNumberField- %s is 6 characters fmask=%08x tmask=%08x\n", str, fmask, *tmask);
1176 #endif
1177 if (fmask & DTK_DATE_M)
1178 {
1179 #ifdef DATEDEBUG
1180 printf("DecodeNumberField- %s is time field fmask=%08x tmask=%08x\n", str, fmask, *tmask);
1181 #endif
1182 *tmask = DTK_TIME_M;
1183 tm->tm_sec = atoi(str + 4);
1184 *(str + 4) = '\0';
1185 tm->tm_min = atoi(str + 2);
1186 *(str + 2) = '\0';
1187 tm->tm_hour = atoi(str + 0);
1188
1189 }
1190 else
1191 {
1192 #ifdef DATEDEBUG
1193 printf("DecodeNumberField- %s is date field fmask=%08x tmask=%08x\n", str, fmask, *tmask);
1194 #endif
1195 *tmask = DTK_DATE_M;
1196 tm->tm_mday = atoi(str + 4);
1197 *(str + 4) = '\0';
1198 tm->tm_mon = atoi(str + 2) - 1; /* tm_mon is 0..11 */
1199 *(str + 2) = '\0';
1200 tm->tm_year = atoi(str + 0);
1201 }
1202
1203 }
1204 else if (strchr(str, '.') != NULL)
1205 {
1206 #ifdef DATEDEBUG
1207 printf("DecodeNumberField- %s is time field fmask=%08x tmask=%08x\n", str, fmask, *tmask);
1208 #endif
1209 *tmask = DTK_TIME_M;
1210 tm->tm_sec = strtod((str + 4), &cp);
1211 if (cp == (str + 4))
1212 return -1;
1213 if (*cp == '.')
1214 *fsec = strtod(cp, NULL);
1215 *(str + 4) = '\0';
1216 tm->tm_min = strtod((str + 2), &cp);
1217 *(str + 2) = '\0';
1218 tm->tm_hour = strtod((str + 0), &cp);
1219
1220 }
1221 else
1222 return -1;
1223
1224 return 0;
1225 } /* DecodeNumberField() */
1226
1227
1228 /* DecodeTimezone()
1229 * Interpret string as a numeric timezone.
1230 */
1231 static int
1232 DecodeTimezone(char *str, int *tzp)
1233 {
1234 int tz;
1235 int hr,
1236 min;
1237 char *cp;
1238 int len;
1239
1240 /* assume leading character is "+" or "-" */
1241 hr = strtol((str + 1), &cp, 10);
1242
1243 /* explicit delimiter? */
1244 if (*cp == ':')
1245 {
1246 min = strtol((cp + 1), &cp, 10);
1247
1248 /* otherwise, might have run things together... */
1249 }
1250 else if ((*cp == '\0') && ((len = strlen(str)) > 3))
1251 {
1252 min = strtol((str + len - 2), &cp, 10);
1253 *(str + len - 2) = '\0';
1254 hr = strtol((str + 1), &cp, 10);
1255
1256 }
1257 else
1258 min = 0;
1259
1260 tz = (hr * 60 + min) * 60;
1261 if (*str == '-')
1262 tz = -tz;
1263
1264 *tzp = -tz;
1265 return *cp != '\0';
1266 } /* DecodeTimezone() */
1267
1268
1269 /* DecodeSpecial()
1270 * Decode text string using lookup table.
1271 * Implement a cache lookup since it is likely that dates
1272 * will be related in format.
1273 */
1274 static int
1275 DecodeSpecial(int field, char *lowtoken, int *val)
1276 {
1277 int type;
1278 datetkn *tp;
1279
1280 #if USE_DATE_CACHE
1281 if ((datecache[field] != NULL)
1282 && (strncmp(lowtoken, datecache[field]->token, TOKMAXLEN) == 0))
1283 tp = datecache[field];
1284 else
1285 {
1286 #endif
1287 tp = datebsearch(lowtoken, datetktbl, szdatetktbl);
1288 #if USE_DATE_CACHE
1289 }
1290 datecache[field] = tp;
1291 #endif
1292 if (tp == NULL)
1293 {
1294 type = IGNOREFIELD;
1295 *val = 0;
1296 }
1297 else
1298 {
1299 type = tp->type;
1300 switch (type)
1301 {
1302 case TZ:
1303 case DTZ:
1304 case DTZMOD:
1305 *val = FROMVAL(tp);
1306 break;
1307
1308 default:
1309 *val = tp->value;
1310 break;
1311 }
1312 }
1313
1314 return type;
1315 } /* DecodeSpecial() */
1316
1317
1318
1319 /* datebsearch()
1320 * Binary search -- from Knuth (6.2.1) Algorithm B. Special case like this
1321 * is WAY faster than the generic bsearch().
1322 */
1323 static datetkn *
1324 datebsearch(char *key, datetkn *base, unsigned int nel)
1325 {
1326 datetkn *last = base + nel - 1,
1327 *position;
1328 int result;
1329
1330 while (last >= base)
1331 {
1332 position = base + ((last - base) >> 1);
1333 result = key[0] - position->token[0];
1334 if (result == 0)
1335 {
1336 result = strncmp(key, position->token, TOKMAXLEN);
1337 if (result == 0)
1338 return position;
1339 }
1340 if (result < 0)
1341 last = position - 1;
1342 else
1343 base = position + 1;
1344 }
1345 return NULL;
1346 }
1347
1348
1349
widl and rpcrt4 development