mirror of
https://github.com/postgres/postgres.git
synced 2025-05-02 11:44:50 +03:00
8e9840383c
Not sure why some were this way, and others were already correct, but it seems to have been like this for several years. This caused problems on a few damaged platforms like AIX and IRIX which do not support DST calculations for years before 1970. Thanks to Andreas Zeugswetter <ZeugswetterA@wien.spardat.at> for finding the problem.
2423 lines
56 KiB
C
2423 lines
56 KiB
C
/*-------------------------------------------------------------------------
|
|
*
|
|
* datetime.c
|
|
* Support functions for date/time types.
|
|
*
|
|
* Portions Copyright (c) 1996-2000, PostgreSQL, Inc
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
|
*
|
|
*
|
|
* IDENTIFICATION
|
|
* $Header: /cvsroot/pgsql/src/backend/utils/adt/datetime.c,v 1.58 2001/01/17 16:46:56 thomas Exp $
|
|
*
|
|
*-------------------------------------------------------------------------
|
|
*/
|
|
#include "postgres.h"
|
|
|
|
#include <ctype.h>
|
|
#include <math.h>
|
|
#include <sys/types.h>
|
|
#include <errno.h>
|
|
#include <float.h>
|
|
#include <limits.h>
|
|
|
|
#include "miscadmin.h"
|
|
#include "utils/datetime.h"
|
|
|
|
static int DecodeNumber(int flen, char *field,
|
|
int fmask, int *tmask,
|
|
struct tm * tm, double *fsec, int *is2digits);
|
|
static int DecodeNumberField(int len, char *str,
|
|
int fmask, int *tmask,
|
|
struct tm * tm, double *fsec, int *is2digits);
|
|
static int DecodeTime(char *str, int fmask, int *tmask,
|
|
struct tm * tm, double *fsec);
|
|
static int DecodeTimezone(char *str, int *tzp);
|
|
static datetkn *datebsearch(char *key, datetkn *base, unsigned int nel);
|
|
static int DecodeDate(char *str, int fmask, int *tmask, struct tm * tm);
|
|
|
|
#define USE_DATE_CACHE 1
|
|
#define ROUND_ALL 0
|
|
|
|
static int DecodePosixTimezone(char *str, int *val);
|
|
|
|
int day_tab[2][13] = {
|
|
{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 0},
|
|
{31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 0}};
|
|
|
|
|
|
char *months[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
|
|
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec", NULL};
|
|
|
|
char *days[] = {"Sunday", "Monday", "Tuesday", "Wednesday",
|
|
"Thursday", "Friday", "Saturday", NULL};
|
|
|
|
|
|
#define UTIME_MINYEAR (1901)
|
|
#define UTIME_MINMONTH (12)
|
|
#define UTIME_MINDAY (14)
|
|
#define UTIME_MAXYEAR (2038)
|
|
#define UTIME_MAXMONTH (01)
|
|
#define UTIME_MAXDAY (18)
|
|
|
|
#define IS_VALID_UTIME(y,m,d) (((y > UTIME_MINYEAR) \
|
|
|| ((y == UTIME_MINYEAR) && ((m > UTIME_MINMONTH) \
|
|
|| ((m == UTIME_MINMONTH) && (d >= UTIME_MINDAY))))) \
|
|
&& ((y < UTIME_MAXYEAR) \
|
|
|| ((y == UTIME_MAXYEAR) && ((m < UTIME_MAXMONTH) \
|
|
|| ((m == UTIME_MAXMONTH) && (d <= UTIME_MAXDAY))))))
|
|
|
|
|
|
/*****************************************************************************
|
|
* PRIVATE ROUTINES *
|
|
*****************************************************************************/
|
|
|
|
/* definitions for squeezing values into "value" */
|
|
#define ABS_SIGNBIT (char) 0200
|
|
#define VALMASK (char) 0177
|
|
#define NEG(n) ((n)|ABS_SIGNBIT)
|
|
#define SIGNEDCHAR(c) ((c)&ABS_SIGNBIT? -((c)&VALMASK): (c))
|
|
#define FROMVAL(tp) (-SIGNEDCHAR((tp)->value) * 10) /* uncompress */
|
|
#define TOVAL(tp, v) ((tp)->value = ((v) < 0? NEG((-(v))/10): (v)/10))
|
|
|
|
/*
|
|
* to keep this table reasonably small, we divide the lexval for TZ and DTZ
|
|
* entries by 10 and truncate the text field at MAXTOKLEN characters.
|
|
* the text field is not guaranteed to be NULL-terminated.
|
|
*/
|
|
static datetkn datetktbl[] = {
|
|
/* text token lexval */
|
|
{EARLY, RESERV, DTK_EARLY}, /* "-infinity" reserved for "early time" */
|
|
{"acsst", DTZ, 63}, /* Cent. Australia */
|
|
{"acst", TZ, 57}, /* Cent. Australia */
|
|
{DA_D, ADBC, AD}, /* "ad" for years >= 0 */
|
|
{"abstime", IGNORE, 0}, /* "abstime" for pre-v6.1 "Invalid
|
|
* Abstime" */
|
|
{"adt", DTZ, NEG(18)}, /* Atlantic Daylight Time */
|
|
{"aesst", DTZ, 66}, /* E. Australia */
|
|
{"aest", TZ, 60}, /* Australia Eastern Std Time */
|
|
{"ahst", TZ, NEG(60)}, /* Alaska-Hawaii Std Time */
|
|
{"allballs", RESERV, DTK_ZULU}, /* 00:00:00 */
|
|
{"am", AMPM, AM},
|
|
{"apr", MONTH, 4},
|
|
{"april", MONTH, 4},
|
|
{"ast", TZ, NEG(24)}, /* Atlantic Std Time (Canada) */
|
|
{"at", IGNORE, 0}, /* "at" (throwaway) */
|
|
{"aug", MONTH, 8},
|
|
{"august", MONTH, 8},
|
|
{"awsst", DTZ, 54}, /* W. Australia */
|
|
{"awst", TZ, 48}, /* W. Australia */
|
|
{DB_C, ADBC, BC}, /* "bc" for years < 0 */
|
|
{"bst", TZ, 6}, /* British Summer Time */
|
|
{"bt", TZ, 18}, /* Baghdad Time */
|
|
{"cadt", DTZ, 63}, /* Central Australian DST */
|
|
{"cast", TZ, 57}, /* Central Australian ST */
|
|
{"cat", TZ, NEG(60)}, /* Central Alaska Time */
|
|
{"cct", TZ, 48}, /* China Coast */
|
|
{"cdt", DTZ, NEG(30)}, /* Central Daylight Time */
|
|
{"cet", TZ, 6}, /* Central European Time */
|
|
{"cetdst", DTZ, 12}, /* Central European Dayl.Time */
|
|
#if USE_AUSTRALIAN_RULES
|
|
{"cst", TZ, 63}, /* Australia Eastern Std Time */
|
|
#else
|
|
{"cst", TZ, NEG(36)}, /* Central Standard Time */
|
|
#endif
|
|
{DCURRENT, RESERV, DTK_CURRENT}, /* "current" is always now */
|
|
{"dec", MONTH, 12},
|
|
{"december", MONTH, 12},
|
|
{"dnt", TZ, 6}, /* Dansk Normal Tid */
|
|
{"dow", RESERV, DTK_DOW}, /* day of week */
|
|
{"doy", RESERV, DTK_DOY}, /* day of year */
|
|
{"dst", DTZMOD, 6},
|
|
{"east", TZ, 60}, /* East Australian Std Time */
|
|
{"edt", DTZ, NEG(24)}, /* Eastern Daylight Time */
|
|
{"eet", TZ, 12}, /* East. Europe, USSR Zone 1 */
|
|
{"eetdst", DTZ, 18}, /* Eastern Europe */
|
|
{EPOCH, RESERV, DTK_EPOCH}, /* "epoch" reserved for system epoch time */
|
|
#if USE_AUSTRALIAN_RULES
|
|
{"est", TZ, 60}, /* Australia Eastern Std Time */
|
|
#else
|
|
{"est", TZ, NEG(30)}, /* Eastern Standard Time */
|
|
#endif
|
|
{"feb", MONTH, 2},
|
|
{"february", MONTH, 2},
|
|
{"fri", DOW, 5},
|
|
{"friday", DOW, 5},
|
|
{"fst", TZ, 6}, /* French Summer Time */
|
|
{"fwt", DTZ, 12}, /* French Winter Time */
|
|
{"gmt", TZ, 0}, /* Greenwish Mean Time */
|
|
{"gst", TZ, 60}, /* Guam Std Time, USSR Zone 9 */
|
|
{"hdt", DTZ, NEG(54)}, /* Hawaii/Alaska */
|
|
{"hmt", DTZ, 18}, /* Hellas ? ? */
|
|
{"hst", TZ, NEG(60)}, /* Hawaii Std Time */
|
|
{"idle", TZ, 72}, /* Intl. Date Line, East */
|
|
{"idlw", TZ, NEG(72)}, /* Intl. Date Line, West */
|
|
{LATE, RESERV, DTK_LATE}, /* "infinity" reserved for "late time" */
|
|
{INVALID, RESERV, DTK_INVALID},
|
|
/* "invalid" reserved for invalid time */
|
|
{"ist", TZ, 12}, /* Israel */
|
|
{"it", TZ, 21}, /* Iran Time */
|
|
{"jan", MONTH, 1},
|
|
{"january", MONTH, 1},
|
|
{"jst", TZ, 54}, /* Japan Std Time,USSR Zone 8 */
|
|
{"jt", TZ, 45}, /* Java Time */
|
|
{"jul", MONTH, 7},
|
|
{"july", MONTH, 7},
|
|
{"jun", MONTH, 6},
|
|
{"june", MONTH, 6},
|
|
{"kst", TZ, 54}, /* Korea Standard Time */
|
|
{"ligt", TZ, 60}, /* From Melbourne, Australia */
|
|
{"mar", MONTH, 3},
|
|
{"march", MONTH, 3},
|
|
{"may", MONTH, 5},
|
|
{"mdt", DTZ, NEG(36)}, /* Mountain Daylight Time */
|
|
{"mest", DTZ, 12}, /* Middle Europe Summer Time */
|
|
{"met", TZ, 6}, /* Middle Europe Time */
|
|
{"metdst", DTZ, 12}, /* Middle Europe Daylight Time */
|
|
{"mewt", TZ, 6}, /* Middle Europe Winter Time */
|
|
{"mez", TZ, 6}, /* Middle Europe Zone */
|
|
{"mon", DOW, 1},
|
|
{"monday", DOW, 1},
|
|
{"mst", TZ, NEG(42)}, /* Mountain Standard Time */
|
|
{"mt", TZ, 51}, /* Moluccas Time */
|
|
{"ndt", DTZ, NEG(15)}, /* Nfld. Daylight Time */
|
|
{"nft", TZ, NEG(21)}, /* Newfoundland Standard Time */
|
|
{"nor", TZ, 6}, /* Norway Standard Time */
|
|
{"nov", MONTH, 11},
|
|
{"november", MONTH, 11},
|
|
{NOW, RESERV, DTK_NOW}, /* current transaction time */
|
|
{"nst", TZ, NEG(21)}, /* Nfld. Standard Time */
|
|
{"nt", TZ, NEG(66)}, /* Nome Time */
|
|
{"nzdt", DTZ, 78}, /* New Zealand Daylight Time */
|
|
{"nzst", TZ, 72}, /* New Zealand Standard Time */
|
|
{"nzt", TZ, 72}, /* New Zealand Time */
|
|
{"oct", MONTH, 10},
|
|
{"october", MONTH, 10},
|
|
{"on", IGNORE, 0}, /* "on" (throwaway) */
|
|
{"pdt", DTZ, NEG(42)}, /* Pacific Daylight Time */
|
|
{"pm", AMPM, PM},
|
|
{"pst", TZ, NEG(48)}, /* Pacific Standard Time */
|
|
{"sadt", DTZ, 63}, /* S. Australian Dayl. Time */
|
|
{"sast", TZ, 57}, /* South Australian Std Time */
|
|
#if USE_AUSTRALIAN_RULES
|
|
{"sat", TZ, 57},
|
|
#else
|
|
{"sat", DOW, 6},
|
|
#endif
|
|
{"saturday", DOW, 6},
|
|
{"sep", MONTH, 9},
|
|
{"sept", MONTH, 9},
|
|
{"september", MONTH, 9},
|
|
{"set", TZ, NEG(6)}, /* Seychelles Time ?? */
|
|
{"sst", DTZ, 12}, /* Swedish Summer Time */
|
|
{"sun", DOW, 0},
|
|
{"sunday", DOW, 0},
|
|
{"swt", TZ, 6}, /* Swedish Winter Time */
|
|
{"thu", DOW, 4},
|
|
{"thur", DOW, 4},
|
|
{"thurs", DOW, 4},
|
|
{"thursday", DOW, 4},
|
|
{TODAY, RESERV, DTK_TODAY}, /* midnight */
|
|
{TOMORROW, RESERV, DTK_TOMORROW}, /* tomorrow midnight */
|
|
{"tue", DOW, 2},
|
|
{"tues", DOW, 2},
|
|
{"tuesday", DOW, 2},
|
|
{"undefined", RESERV, DTK_INVALID}, /* pre-v6.1 invalid time */
|
|
{"ut", TZ, 0},
|
|
{"utc", TZ, 0},
|
|
{"wadt", DTZ, 48}, /* West Australian DST */
|
|
{"wast", TZ, 42}, /* West Australian Std Time */
|
|
{"wat", TZ, NEG(6)}, /* West Africa Time */
|
|
{"wdt", DTZ, 54}, /* West Australian DST */
|
|
{"wed", DOW, 3},
|
|
{"wednesday", DOW, 3},
|
|
{"weds", DOW, 3},
|
|
{"wet", TZ, 0}, /* Western Europe */
|
|
{"wetdst", DTZ, 6}, /* Western Europe */
|
|
{"wst", TZ, 48}, /* West Australian Std Time */
|
|
{"ydt", DTZ, NEG(48)}, /* Yukon Daylight Time */
|
|
{YESTERDAY, RESERV, DTK_YESTERDAY}, /* yesterday midnight */
|
|
{"yst", TZ, NEG(54)}, /* Yukon Standard Time */
|
|
{"z", RESERV, DTK_ZULU}, /* 00:00:00 */
|
|
{"zp4", TZ, NEG(24)}, /* GMT +4 hours. */
|
|
{"zp5", TZ, NEG(30)}, /* GMT +5 hours. */
|
|
{"zp6", TZ, NEG(36)}, /* GMT +6 hours. */
|
|
{ZULU, RESERV, DTK_ZULU}, /* 00:00:00 */
|
|
};
|
|
|
|
static unsigned int szdatetktbl = sizeof datetktbl / sizeof datetktbl[0];
|
|
|
|
static datetkn deltatktbl[] = {
|
|
/* text token lexval */
|
|
{"@", IGNORE, 0}, /* postgres relative time prefix */
|
|
{DAGO, AGO, 0}, /* "ago" indicates negative time offset */
|
|
{"c", UNITS, DTK_CENTURY}, /* "century" relative time units */
|
|
{"cent", UNITS, DTK_CENTURY}, /* "century" relative time units */
|
|
{"centuries", UNITS, DTK_CENTURY}, /* "centuries" relative time units */
|
|
{DCENTURY, UNITS, DTK_CENTURY}, /* "century" relative time units */
|
|
{"d", UNITS, DTK_DAY}, /* "day" relative time units */
|
|
{DDAY, UNITS, DTK_DAY}, /* "day" relative time units */
|
|
{"days", UNITS, DTK_DAY}, /* "days" relative time units */
|
|
{"dec", UNITS, DTK_DECADE}, /* "decade" relative time units */
|
|
{"decs", UNITS, DTK_DECADE},/* "decades" relative time units */
|
|
{DDECADE, UNITS, DTK_DECADE}, /* "decade" relative time units */
|
|
{"decades", UNITS, DTK_DECADE}, /* "decades" relative time units */
|
|
{"h", UNITS, DTK_HOUR}, /* "hour" relative time units */
|
|
{DHOUR, UNITS, DTK_HOUR}, /* "hour" relative time units */
|
|
{"hours", UNITS, DTK_HOUR}, /* "hours" relative time units */
|
|
{"hr", UNITS, DTK_HOUR}, /* "hour" relative time units */
|
|
{"hrs", UNITS, DTK_HOUR}, /* "hours" relative time units */
|
|
{INVALID, RESERV, DTK_INVALID}, /* reserved for invalid time */
|
|
{"m", UNITS, DTK_MINUTE}, /* "minute" relative time units */
|
|
{"microsecon", UNITS, DTK_MICROSEC}, /* "microsecond" relative
|
|
* time units */
|
|
{"mil", UNITS, DTK_MILLENNIUM}, /* "millennium" relative time units */
|
|
{"mils", UNITS, DTK_MILLENNIUM}, /* "millennia" relative time units */
|
|
{"millennia", UNITS, DTK_MILLENNIUM}, /* "millennia" relative time units */
|
|
{DMILLENNIUM, UNITS, DTK_MILLENNIUM}, /* "millennium" relative time units */
|
|
{"millisecon", UNITS, DTK_MILLISEC}, /* relative time units */
|
|
{"min", UNITS, DTK_MINUTE}, /* "minute" relative time units */
|
|
{"mins", UNITS, DTK_MINUTE},/* "minutes" relative time units */
|
|
{"mins", UNITS, DTK_MINUTE},/* "minutes" relative time units */
|
|
{DMINUTE, UNITS, DTK_MINUTE}, /* "minute" relative time units */
|
|
{"minutes", UNITS, DTK_MINUTE}, /* "minutes" relative time units */
|
|
{"mon", UNITS, DTK_MONTH}, /* "months" relative time units */
|
|
{"mons", UNITS, DTK_MONTH}, /* "months" relative time units */
|
|
{DMONTH, UNITS, DTK_MONTH}, /* "month" relative time units */
|
|
{"months", UNITS, DTK_MONTH},
|
|
{"ms", UNITS, DTK_MILLISEC},
|
|
{"msec", UNITS, DTK_MILLISEC},
|
|
{DMILLISEC, UNITS, DTK_MILLISEC},
|
|
{"mseconds", UNITS, DTK_MILLISEC},
|
|
{"msecs", UNITS, DTK_MILLISEC},
|
|
{"qtr", UNITS, DTK_QUARTER},/* "quarter" relative time */
|
|
{DQUARTER, UNITS, DTK_QUARTER}, /* "quarter" relative time */
|
|
{"reltime", IGNORE, 0}, /* for pre-v6.1 "Undefined Reltime" */
|
|
{"s", UNITS, DTK_SECOND},
|
|
{"sec", UNITS, DTK_SECOND},
|
|
{DSECOND, UNITS, DTK_SECOND},
|
|
{"seconds", UNITS, DTK_SECOND},
|
|
{"secs", UNITS, DTK_SECOND},
|
|
{DTIMEZONE, UNITS, DTK_TZ}, /* "timezone" time offset */
|
|
{"tz", UNITS, DTK_TZ}, /* "timezone" time offset */
|
|
{"tz_hour", UNITS, DTK_TZ_HOUR}, /* timezone hour units */
|
|
{"tz_minute", UNITS, DTK_TZ_MINUTE}, /* timezone minutes units */
|
|
{"undefined", RESERV, DTK_INVALID}, /* pre-v6.1 invalid time */
|
|
{"us", UNITS, DTK_MICROSEC},/* "microsecond" relative time units */
|
|
{"usec", UNITS, DTK_MICROSEC}, /* "microsecond" relative time
|
|
* units */
|
|
{DMICROSEC, UNITS, DTK_MICROSEC}, /* "microsecond" relative time
|
|
* units */
|
|
{"useconds", UNITS, DTK_MICROSEC}, /* "microseconds" relative time
|
|
* units */
|
|
{"usecs", UNITS, DTK_MICROSEC}, /* "microseconds" relative time
|
|
* units */
|
|
{"w", UNITS, DTK_WEEK}, /* "week" relative time units */
|
|
{DWEEK, UNITS, DTK_WEEK}, /* "week" relative time units */
|
|
{"weeks", UNITS, DTK_WEEK}, /* "weeks" relative time units */
|
|
{"y", UNITS, DTK_YEAR}, /* "year" relative time units */
|
|
{DYEAR, UNITS, DTK_YEAR}, /* "year" relative time units */
|
|
{"years", UNITS, DTK_YEAR}, /* "years" relative time units */
|
|
{"yr", UNITS, DTK_YEAR}, /* "year" relative time units */
|
|
{"yrs", UNITS, DTK_YEAR}, /* "years" relative time units */
|
|
};
|
|
|
|
static unsigned int szdeltatktbl = sizeof deltatktbl / sizeof deltatktbl[0];
|
|
|
|
#if USE_DATE_CACHE
|
|
datetkn *datecache[MAXDATEFIELDS] = {NULL};
|
|
|
|
datetkn *deltacache[MAXDATEFIELDS] = {NULL};
|
|
|
|
#endif
|
|
|
|
|
|
/*
|
|
* Calendar time to Julian date conversions.
|
|
* Julian date is commonly used in astronomical applications,
|
|
* since it is numerically accurate and computationally simple.
|
|
* The algorithms here will accurately convert between Julian day
|
|
* and calendar date for all non-negative Julian days
|
|
* (i.e. from Nov 23, -4713 on).
|
|
*
|
|
* Ref: Explanatory Supplement to the Astronomical Almanac, 1992.
|
|
* University Science Books, 20 Edgehill Rd. Mill Valley CA 94941.
|
|
*
|
|
* Use the algorithm by Henry Fliegel, a former NASA/JPL colleague
|
|
* now at Aerospace Corp. (hi, Henry!)
|
|
*
|
|
* These routines will be used by other date/time packages - tgl 97/02/25
|
|
*/
|
|
|
|
int
|
|
date2j(int y, int m, int d)
|
|
{
|
|
int m12 = (m - 14) / 12;
|
|
|
|
return ((1461 * (y + 4800 + m12)) / 4 + (367 * (m - 2 - 12 * (m12))) / 12
|
|
- (3 * ((y + 4900 + m12) / 100)) / 4 + d - 32075);
|
|
} /* date2j() */
|
|
|
|
void
|
|
j2date(int jd, int *year, int *month, int *day)
|
|
{
|
|
int j,
|
|
y,
|
|
m,
|
|
d;
|
|
|
|
int i,
|
|
l,
|
|
n;
|
|
|
|
l = jd + 68569;
|
|
n = (4 * l) / 146097;
|
|
l -= (146097 * n + 3) / 4;
|
|
i = (4000 * (l + 1)) / 1461001;
|
|
l += 31 - (1461 * i) / 4;
|
|
j = (80 * l) / 2447;
|
|
d = l - (2447 * j) / 80;
|
|
l = j / 11;
|
|
m = (j + 2) - (12 * l);
|
|
y = 100 * (n - 49) + i + l;
|
|
|
|
*year = y;
|
|
*month = m;
|
|
*day = d;
|
|
return;
|
|
} /* j2date() */
|
|
|
|
int
|
|
j2day(int date)
|
|
{
|
|
int day;
|
|
|
|
day = (date + 1) % 7;
|
|
|
|
return day;
|
|
} /* j2day() */
|
|
|
|
|
|
/*
|
|
* parse and convert date in timestr (the normal interface)
|
|
*
|
|
* Returns the number of seconds since epoch (J2000)
|
|
*/
|
|
|
|
/* ParseDateTime()
|
|
* Break string into tokens based on a date/time context.
|
|
*/
|
|
int
|
|
ParseDateTime(char *timestr, char *lowstr,
|
|
char **field, int *ftype, int maxfields, int *numfields)
|
|
{
|
|
int nf = 0;
|
|
char *cp = timestr;
|
|
char *lp = lowstr;
|
|
|
|
/* outer loop through fields */
|
|
while (*cp != '\0')
|
|
{
|
|
field[nf] = lp;
|
|
|
|
/* leading digit? then date or time */
|
|
if (isdigit((unsigned char) *cp) || (*cp == '.'))
|
|
{
|
|
*lp++ = *cp++;
|
|
while (isdigit((unsigned char) *cp))
|
|
*lp++ = *cp++;
|
|
/* time field? */
|
|
if (*cp == ':')
|
|
{
|
|
ftype[nf] = DTK_TIME;
|
|
while (isdigit((unsigned char) *cp) ||
|
|
(*cp == ':') || (*cp == '.'))
|
|
*lp++ = *cp++;
|
|
|
|
}
|
|
/* date field? allow embedded text month */
|
|
else if ((*cp == '-') || (*cp == '/') || (*cp == '.'))
|
|
{
|
|
ftype[nf] = DTK_DATE;
|
|
while (isalnum((unsigned char) *cp) || (*cp == '-') ||
|
|
(*cp == '/') || (*cp == '.'))
|
|
*lp++ = tolower((unsigned char) *cp++);
|
|
|
|
}
|
|
|
|
/*
|
|
* otherwise, number only and will determine year, month, or
|
|
* day later
|
|
*/
|
|
else
|
|
ftype[nf] = DTK_NUMBER;
|
|
|
|
}
|
|
|
|
/*
|
|
* text? then date string, month, day of week, special, or
|
|
* timezone
|
|
*/
|
|
else if (isalpha((unsigned char) *cp))
|
|
{
|
|
ftype[nf] = DTK_STRING;
|
|
*lp++ = tolower((unsigned char) *cp++);
|
|
while (isalpha((unsigned char) *cp))
|
|
*lp++ = tolower((unsigned char) *cp++);
|
|
|
|
/*
|
|
* Full date string with leading text month? Could also be a
|
|
* POSIX time zone...
|
|
*/
|
|
if ((*cp == '-') || (*cp == '/') || (*cp == '.'))
|
|
{
|
|
ftype[nf] = DTK_DATE;
|
|
while (isdigit((unsigned char) *cp) ||
|
|
(*cp == '-') || (*cp == '/') || (*cp == '.'))
|
|
*lp++ = tolower((unsigned char) *cp++);
|
|
}
|
|
|
|
/* skip leading spaces */
|
|
}
|
|
else if (isspace((unsigned char) *cp))
|
|
{
|
|
cp++;
|
|
continue;
|
|
|
|
/* sign? then special or numeric timezone */
|
|
}
|
|
else if ((*cp == '+') || (*cp == '-'))
|
|
{
|
|
*lp++ = *cp++;
|
|
/* soak up leading whitespace */
|
|
while (isspace((unsigned char) *cp))
|
|
cp++;
|
|
/* numeric timezone? */
|
|
if (isdigit((unsigned char) *cp))
|
|
{
|
|
ftype[nf] = DTK_TZ;
|
|
*lp++ = *cp++;
|
|
while (isdigit((unsigned char) *cp) ||
|
|
(*cp == ':') || (*cp == '.'))
|
|
*lp++ = *cp++;
|
|
|
|
/* special? */
|
|
}
|
|
else if (isalpha((unsigned char) *cp))
|
|
{
|
|
ftype[nf] = DTK_SPECIAL;
|
|
*lp++ = tolower((unsigned char) *cp++);
|
|
while (isalpha((unsigned char) *cp))
|
|
*lp++ = tolower((unsigned char) *cp++);
|
|
|
|
/* otherwise something wrong... */
|
|
}
|
|
else
|
|
return -1;
|
|
|
|
/* ignore punctuation but use as delimiter */
|
|
}
|
|
else if (ispunct((unsigned char) *cp))
|
|
{
|
|
cp++;
|
|
continue;
|
|
|
|
}
|
|
else
|
|
return -1;
|
|
|
|
/* force in a delimiter */
|
|
*lp++ = '\0';
|
|
nf++;
|
|
if (nf > MAXDATEFIELDS)
|
|
return -1;
|
|
}
|
|
|
|
*numfields = nf;
|
|
|
|
return 0;
|
|
} /* ParseDateTime() */
|
|
|
|
|
|
/* DecodeDateTime()
|
|
* Interpret previously parsed fields for general date and time.
|
|
* Return 0 if full date, 1 if only time, and -1 if problems.
|
|
* External format(s):
|
|
* "<weekday> <month>-<day>-<year> <hour>:<minute>:<second>"
|
|
* "Fri Feb-7-1997 15:23:27"
|
|
* "Feb-7-1997 15:23:27"
|
|
* "2-7-1997 15:23:27"
|
|
* "1997-2-7 15:23:27"
|
|
* "1997.038 15:23:27" (day of year 1-366)
|
|
* Also supports input in compact time:
|
|
* "970207 152327"
|
|
* "97038 152327"
|
|
*
|
|
* Use the system-provided functions to get the current time zone
|
|
* if not specified in the input string.
|
|
* If the date is outside the time_t system-supported time range,
|
|
* then assume GMT time zone. - tgl 97/05/27
|
|
*/
|
|
int
|
|
DecodeDateTime(char **field, int *ftype, int nf,
|
|
int *dtype, struct tm * tm, double *fsec, int *tzp)
|
|
{
|
|
int fmask = 0,
|
|
tmask,
|
|
type;
|
|
int i;
|
|
int flen,
|
|
val;
|
|
int mer = HR24;
|
|
int haveTextMonth = FALSE;
|
|
int is2digits = FALSE;
|
|
int bc = FALSE;
|
|
|
|
*dtype = DTK_DATE;
|
|
tm->tm_hour = 0;
|
|
tm->tm_min = 0;
|
|
tm->tm_sec = 0;
|
|
*fsec = 0;
|
|
tm->tm_isdst = -1; /* don't know daylight savings time status
|
|
* apriori */
|
|
if (tzp != NULL)
|
|
*tzp = 0;
|
|
|
|
for (i = 0; i < nf; i++)
|
|
{
|
|
switch (ftype[i])
|
|
{
|
|
case DTK_DATE:
|
|
|
|
/*
|
|
* Already have a date? Then this might be a POSIX time
|
|
* zone with an embedded dash (e.g. "PST-3" == "EST") -
|
|
* thomas 2000-03-15
|
|
*/
|
|
if ((fmask & DTK_DATE_M) == DTK_DATE_M)
|
|
{
|
|
if ((tzp == NULL)
|
|
|| (DecodePosixTimezone(field[i], tzp) != 0))
|
|
return -1;
|
|
|
|
ftype[i] = DTK_TZ;
|
|
tmask = DTK_M(TZ);
|
|
}
|
|
else if (DecodeDate(field[i], fmask, &tmask, tm) != 0)
|
|
return -1;
|
|
break;
|
|
|
|
case DTK_TIME:
|
|
if (DecodeTime(field[i], fmask, &tmask, tm, fsec) != 0)
|
|
return -1;
|
|
|
|
/*
|
|
* check upper limit on hours; other limits checked in
|
|
* DecodeTime()
|
|
*/
|
|
if (tm->tm_hour > 23)
|
|
return -1;
|
|
break;
|
|
|
|
case DTK_TZ:
|
|
if (tzp == NULL)
|
|
return -1;
|
|
|
|
{
|
|
int tz;
|
|
|
|
if (DecodeTimezone(field[i], &tz) != 0)
|
|
return -1;
|
|
|
|
/*
|
|
* Already have a time zone? Then maybe this is the
|
|
* second field of a POSIX time: EST+3 (equivalent to
|
|
* PST)
|
|
*/
|
|
if ((i > 0) && ((fmask & DTK_M(TZ)) != 0)
|
|
&& (ftype[i - 1] == DTK_TZ) && (isalpha((unsigned char) *field[i - 1])))
|
|
{
|
|
*tzp -= tz;
|
|
tmask = 0;
|
|
}
|
|
else
|
|
{
|
|
*tzp = tz;
|
|
tmask = DTK_M(TZ);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case DTK_NUMBER:
|
|
flen = strlen(field[i]);
|
|
|
|
/*
|
|
* long numeric string and either no date or no time read
|
|
* yet? then interpret as a concatenated date or time...
|
|
*/
|
|
if ((flen > 4) && !((fmask & DTK_DATE_M) && (fmask & DTK_TIME_M)))
|
|
{
|
|
if (DecodeNumberField(flen, field[i], fmask, &tmask, tm, fsec, &is2digits) != 0)
|
|
return -1;
|
|
|
|
}
|
|
/* otherwise it is a single date/time field... */
|
|
else
|
|
{
|
|
if (DecodeNumber(flen, field[i], fmask, &tmask, tm, fsec, &is2digits) != 0)
|
|
return -1;
|
|
}
|
|
break;
|
|
|
|
case DTK_STRING:
|
|
case DTK_SPECIAL:
|
|
type = DecodeSpecial(i, field[i], &val);
|
|
if (type == IGNORE)
|
|
continue;
|
|
|
|
tmask = DTK_M(type);
|
|
switch (type)
|
|
{
|
|
case RESERV:
|
|
switch (val)
|
|
{
|
|
case DTK_NOW:
|
|
tmask = (DTK_DATE_M | DTK_TIME_M | DTK_M(TZ));
|
|
*dtype = DTK_DATE;
|
|
GetCurrentTime(tm);
|
|
if (tzp != NULL)
|
|
*tzp = CTimeZone;
|
|
break;
|
|
|
|
case DTK_YESTERDAY:
|
|
tmask = DTK_DATE_M;
|
|
*dtype = DTK_DATE;
|
|
GetCurrentTime(tm);
|
|
j2date((date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - 1),
|
|
&tm->tm_year, &tm->tm_mon, &tm->tm_mday);
|
|
tm->tm_hour = 0;
|
|
tm->tm_min = 0;
|
|
tm->tm_sec = 0;
|
|
break;
|
|
|
|
case DTK_TODAY:
|
|
tmask = DTK_DATE_M;
|
|
*dtype = DTK_DATE;
|
|
GetCurrentTime(tm);
|
|
tm->tm_hour = 0;
|
|
tm->tm_min = 0;
|
|
tm->tm_sec = 0;
|
|
break;
|
|
|
|
case DTK_TOMORROW:
|
|
tmask = DTK_DATE_M;
|
|
*dtype = DTK_DATE;
|
|
GetCurrentTime(tm);
|
|
j2date((date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) + 1),
|
|
&tm->tm_year, &tm->tm_mon, &tm->tm_mday);
|
|
tm->tm_hour = 0;
|
|
tm->tm_min = 0;
|
|
tm->tm_sec = 0;
|
|
break;
|
|
|
|
case DTK_ZULU:
|
|
tmask = (DTK_TIME_M | DTK_M(TZ));
|
|
*dtype = DTK_DATE;
|
|
tm->tm_hour = 0;
|
|
tm->tm_min = 0;
|
|
tm->tm_sec = 0;
|
|
if (tzp != NULL)
|
|
*tzp = 0;
|
|
break;
|
|
|
|
default:
|
|
*dtype = val;
|
|
}
|
|
|
|
break;
|
|
|
|
case MONTH:
|
|
|
|
/*
|
|
* already have a (numeric) month? then see if we
|
|
* can substitute...
|
|
*/
|
|
if ((fmask & DTK_M(MONTH)) && (!haveTextMonth)
|
|
&& (!(fmask & DTK_M(DAY)))
|
|
&& ((tm->tm_mon >= 1) && (tm->tm_mon <= 31)))
|
|
{
|
|
tm->tm_mday = tm->tm_mon;
|
|
tmask = DTK_M(DAY);
|
|
}
|
|
haveTextMonth = TRUE;
|
|
tm->tm_mon = val;
|
|
break;
|
|
|
|
case DTZMOD:
|
|
|
|
/*
|
|
* daylight savings time modifier (solves "MET
|
|
* DST" syntax)
|
|
*/
|
|
tmask |= DTK_M(DTZ);
|
|
tm->tm_isdst = 1;
|
|
if (tzp == NULL)
|
|
return -1;
|
|
*tzp += val * 60;
|
|
break;
|
|
|
|
case DTZ:
|
|
|
|
/*
|
|
* set mask for TZ here _or_ check for DTZ later
|
|
* when getting default timezone
|
|
*/
|
|
tmask |= DTK_M(TZ);
|
|
tm->tm_isdst = 1;
|
|
if (tzp == NULL)
|
|
return -1;
|
|
*tzp = val * 60;
|
|
ftype[i] = DTK_TZ;
|
|
break;
|
|
|
|
case TZ:
|
|
tm->tm_isdst = 0;
|
|
if (tzp == NULL)
|
|
return -1;
|
|
*tzp = val * 60;
|
|
ftype[i] = DTK_TZ;
|
|
break;
|
|
|
|
case IGNORE:
|
|
break;
|
|
|
|
case AMPM:
|
|
mer = val;
|
|
break;
|
|
|
|
case ADBC:
|
|
bc = (val == BC);
|
|
break;
|
|
|
|
case DOW:
|
|
tm->tm_wday = val;
|
|
break;
|
|
|
|
default:
|
|
return -1;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return -1;
|
|
}
|
|
|
|
if (tmask & fmask)
|
|
return -1;
|
|
fmask |= tmask;
|
|
}
|
|
|
|
/* there is no year zero in AD/BC notation; i.e. "1 BC" == year 0 */
|
|
if (bc)
|
|
{
|
|
if (tm->tm_year > 0)
|
|
tm->tm_year = -(tm->tm_year - 1);
|
|
else
|
|
elog(ERROR, "Inconsistant use of year %04d and 'BC'", tm->tm_year);
|
|
}
|
|
else if (is2digits)
|
|
{
|
|
if (tm->tm_year < 70)
|
|
tm->tm_year += 2000;
|
|
else if (tm->tm_year < 100)
|
|
tm->tm_year += 1900;
|
|
}
|
|
|
|
if ((mer != HR24) && (tm->tm_hour > 12))
|
|
return -1;
|
|
if ((mer == AM) && (tm->tm_hour == 12))
|
|
tm->tm_hour = 0;
|
|
else if ((mer == PM) && (tm->tm_hour != 12))
|
|
tm->tm_hour += 12;
|
|
|
|
/* do additional checking for full date specs... */
|
|
if (*dtype == DTK_DATE)
|
|
{
|
|
if ((fmask & DTK_DATE_M) != DTK_DATE_M)
|
|
return ((fmask & DTK_TIME_M) == DTK_TIME_M) ? 1 : -1;
|
|
|
|
/*
|
|
* check for valid day of month, now that we know for sure the
|
|
* month and year...
|
|
*/
|
|
if ((tm->tm_mday < 1)
|
|
|| (tm->tm_mday > day_tab[isleap(tm->tm_year)][tm->tm_mon - 1]))
|
|
return -1;
|
|
|
|
/* timezone not specified? then find local timezone if possible */
|
|
if (((fmask & DTK_DATE_M) == DTK_DATE_M)
|
|
&& (tzp != NULL) && (!(fmask & DTK_M(TZ))))
|
|
{
|
|
|
|
/*
|
|
* daylight savings time modifier but no standard timezone?
|
|
* then error
|
|
*/
|
|
if (fmask & DTK_M(DTZMOD))
|
|
return -1;
|
|
|
|
if (IS_VALID_UTIME(tm->tm_year, tm->tm_mon, tm->tm_mday))
|
|
{
|
|
#if defined(HAVE_TM_ZONE) || defined(HAVE_INT_TIMEZONE)
|
|
tm->tm_year -= 1900;
|
|
tm->tm_mon -= 1;
|
|
tm->tm_isdst = -1;
|
|
mktime(tm);
|
|
tm->tm_year += 1900;
|
|
tm->tm_mon += 1;
|
|
|
|
# if defined(HAVE_TM_ZONE)
|
|
*tzp = -(tm->tm_gmtoff); /* tm_gmtoff is
|
|
* Sun/DEC-ism */
|
|
# elif defined(HAVE_INT_TIMEZONE)
|
|
# ifdef __CYGWIN__
|
|
*tzp = ((tm->tm_isdst > 0) ? (_timezone - 3600) : _timezone);
|
|
# else
|
|
*tzp = ((tm->tm_isdst > 0) ? (timezone - 3600) : timezone);
|
|
# endif /* __CYGWIN__ */
|
|
# endif /* HAVE_INT_TIMEZONE */
|
|
|
|
#else /* not (HAVE_TM_ZONE || HAVE_INT_TIMEZONE) */
|
|
*tzp = CTimeZone;
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
tm->tm_isdst = 0;
|
|
*tzp = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
} /* DecodeDateTime() */
|
|
|
|
|
|
/* DecodeTimeOnly()
|
|
* Interpret parsed string as time fields only.
|
|
* Note that support for time zone is here for
|
|
* SQL92 TIME WITH TIME ZONE, but it reveals
|
|
* bogosity with SQL92 date/time standards, since
|
|
* we must infer a time zone from current time.
|
|
* XXX Later, we should probably support
|
|
* SET TIME ZONE <integer>
|
|
* which of course is a screwed up convention.
|
|
* - thomas 2000-03-10
|
|
*/
|
|
int
|
|
DecodeTimeOnly(char **field, int *ftype, int nf,
|
|
int *dtype, struct tm * tm, double *fsec, int *tzp)
|
|
{
|
|
int fmask,
|
|
tmask,
|
|
type;
|
|
int i;
|
|
int flen,
|
|
val;
|
|
int is2digits = FALSE;
|
|
int mer = HR24;
|
|
|
|
*dtype = DTK_TIME;
|
|
tm->tm_hour = 0;
|
|
tm->tm_min = 0;
|
|
tm->tm_sec = 0;
|
|
*fsec = 0;
|
|
tm->tm_isdst = -1; /* don't know daylight savings time status
|
|
* apriori */
|
|
if (tzp != NULL)
|
|
*tzp = 0;
|
|
|
|
fmask = DTK_DATE_M;
|
|
|
|
for (i = 0; i < nf; i++)
|
|
{
|
|
switch (ftype[i])
|
|
{
|
|
case DTK_DATE:
|
|
|
|
/*
|
|
* This might be a POSIX time zone with an embedded dash
|
|
* (e.g. "PST-3" == "EST") - thomas 2000-03-15
|
|
*/
|
|
if ((tzp == NULL)
|
|
|| (DecodePosixTimezone(field[i], tzp) != 0))
|
|
return -1;
|
|
|
|
ftype[i] = DTK_TZ;
|
|
tmask = DTK_M(TZ);
|
|
break;
|
|
|
|
case DTK_TIME:
|
|
if (DecodeTime(field[i], fmask, &tmask, tm, fsec) != 0)
|
|
return -1;
|
|
break;
|
|
|
|
case DTK_TZ:
|
|
if (tzp == NULL)
|
|
return -1;
|
|
|
|
{
|
|
int tz;
|
|
|
|
if (DecodeTimezone(field[i], &tz) != 0)
|
|
return -1;
|
|
|
|
/*
|
|
* Already have a time zone? Then maybe this is the
|
|
* second field of a POSIX time: EST+3 (equivalent to
|
|
* PST)
|
|
*/
|
|
if ((i > 0) && ((fmask & DTK_M(TZ)) != 0)
|
|
&& (ftype[i - 1] == DTK_TZ) && (isalpha((unsigned char) *field[i - 1])))
|
|
{
|
|
*tzp -= tz;
|
|
tmask = 0;
|
|
}
|
|
else
|
|
{
|
|
*tzp = tz;
|
|
tmask = DTK_M(TZ);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case DTK_NUMBER:
|
|
flen = strlen(field[i]);
|
|
|
|
if (DecodeNumberField(flen, field[i], fmask, &tmask, tm, fsec, &is2digits) != 0)
|
|
return -1;
|
|
break;
|
|
|
|
case DTK_STRING:
|
|
case DTK_SPECIAL:
|
|
type = DecodeSpecial(i, field[i], &val);
|
|
if (type == IGNORE)
|
|
continue;
|
|
|
|
tmask = DTK_M(type);
|
|
switch (type)
|
|
{
|
|
case RESERV:
|
|
switch (val)
|
|
{
|
|
case DTK_NOW:
|
|
tmask = DTK_TIME_M;
|
|
*dtype = DTK_TIME;
|
|
GetCurrentTime(tm);
|
|
break;
|
|
|
|
case DTK_ZULU:
|
|
tmask = (DTK_TIME_M | DTK_M(TZ));
|
|
*dtype = DTK_TIME;
|
|
tm->tm_hour = 0;
|
|
tm->tm_min = 0;
|
|
tm->tm_sec = 0;
|
|
tm->tm_isdst = 0;
|
|
break;
|
|
|
|
default:
|
|
return -1;
|
|
}
|
|
|
|
break;
|
|
|
|
case DTZMOD:
|
|
|
|
/*
|
|
* daylight savings time modifier (solves "MET
|
|
* DST" syntax)
|
|
*/
|
|
tmask |= DTK_M(DTZ);
|
|
tm->tm_isdst = 1;
|
|
if (tzp == NULL)
|
|
return -1;
|
|
*tzp += val * 60;
|
|
break;
|
|
|
|
case DTZ:
|
|
|
|
/*
|
|
* set mask for TZ here _or_ check for DTZ later
|
|
* when getting default timezone
|
|
*/
|
|
tmask |= DTK_M(TZ);
|
|
tm->tm_isdst = 1;
|
|
if (tzp == NULL)
|
|
return -1;
|
|
*tzp = val * 60;
|
|
ftype[i] = DTK_TZ;
|
|
break;
|
|
|
|
case TZ:
|
|
tm->tm_isdst = 0;
|
|
if (tzp == NULL)
|
|
return -1;
|
|
*tzp = val * 60;
|
|
ftype[i] = DTK_TZ;
|
|
break;
|
|
|
|
case IGNORE:
|
|
break;
|
|
|
|
case AMPM:
|
|
mer = val;
|
|
break;
|
|
|
|
default:
|
|
return -1;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return -1;
|
|
}
|
|
|
|
if (tmask & fmask)
|
|
return -1;
|
|
fmask |= tmask;
|
|
}
|
|
|
|
if ((mer != HR24) && (tm->tm_hour > 12))
|
|
return -1;
|
|
if ((mer == AM) && (tm->tm_hour == 12))
|
|
tm->tm_hour = 0;
|
|
else if ((mer == PM) && (tm->tm_hour != 12))
|
|
tm->tm_hour += 12;
|
|
|
|
if (((tm->tm_hour < 0) || (tm->tm_hour > 23))
|
|
|| ((tm->tm_min < 0) || (tm->tm_min > 59))
|
|
|| ((tm->tm_sec < 0) || ((tm->tm_sec + *fsec) >= 60)))
|
|
return -1;
|
|
|
|
if ((fmask & DTK_TIME_M) != DTK_TIME_M)
|
|
return -1;
|
|
|
|
/* timezone not specified? then find local timezone if possible */
|
|
if ((tzp != NULL) && (!(fmask & DTK_M(TZ))))
|
|
{
|
|
struct tm tt,
|
|
*tmp = &tt;
|
|
|
|
/*
|
|
* daylight savings time modifier but no standard timezone? then
|
|
* error
|
|
*/
|
|
if (fmask & DTK_M(DTZMOD))
|
|
return -1;
|
|
|
|
GetCurrentTime(tmp);
|
|
tmp->tm_hour = tm->tm_hour;
|
|
tmp->tm_min = tm->tm_min;
|
|
tmp->tm_sec = tm->tm_sec;
|
|
|
|
#if defined(HAVE_TM_ZONE) || defined(HAVE_INT_TIMEZONE)
|
|
tmp->tm_isdst = -1;
|
|
mktime(tmp);
|
|
tm->tm_isdst = tmp->tm_isdst;
|
|
|
|
# if defined(HAVE_TM_ZONE)
|
|
*tzp = -(tmp->tm_gmtoff); /* tm_gmtoff is Sun/DEC-ism */
|
|
# elif defined(HAVE_INT_TIMEZONE)
|
|
# ifdef __CYGWIN__
|
|
*tzp = ((tmp->tm_isdst > 0) ? (_timezone - 3600) : _timezone);
|
|
# else
|
|
*tzp = ((tmp->tm_isdst > 0) ? (timezone - 3600) : timezone);
|
|
# endif
|
|
# endif
|
|
|
|
#else /* not (HAVE_TM_ZONE || HAVE_INT_TIMEZONE) */
|
|
*tzp = CTimeZone;
|
|
#endif
|
|
}
|
|
|
|
return 0;
|
|
} /* DecodeTimeOnly() */
|
|
|
|
/* DecodeDate()
|
|
* Decode date string which includes delimiters.
|
|
* Insist on a complete set of fields.
|
|
*/
|
|
static int
|
|
DecodeDate(char *str, int fmask, int *tmask, struct tm * tm)
|
|
{
|
|
double fsec;
|
|
|
|
int nf = 0;
|
|
int i,
|
|
len;
|
|
int bc = FALSE;
|
|
int is2digits = FALSE;
|
|
int type,
|
|
val,
|
|
dmask = 0;
|
|
char *field[MAXDATEFIELDS];
|
|
|
|
/* parse this string... */
|
|
while ((*str != '\0') && (nf < MAXDATEFIELDS))
|
|
{
|
|
/* skip field separators */
|
|
while (!isalnum((unsigned char) *str))
|
|
str++;
|
|
|
|
field[nf] = str;
|
|
if (isdigit((unsigned char) *str))
|
|
{
|
|
while (isdigit((unsigned char) *str))
|
|
str++;
|
|
}
|
|
else if (isalpha((unsigned char) *str))
|
|
{
|
|
while (isalpha((unsigned char) *str))
|
|
str++;
|
|
}
|
|
|
|
if (*str != '\0')
|
|
*str++ = '\0';
|
|
nf++;
|
|
}
|
|
|
|
#if 0
|
|
/* don't allow too many fields */
|
|
if (nf > 3)
|
|
return -1;
|
|
#endif
|
|
|
|
*tmask = 0;
|
|
|
|
/* look first for text fields, since that will be unambiguous month */
|
|
for (i = 0; i < nf; i++)
|
|
{
|
|
if (isalpha((unsigned char) *field[i]))
|
|
{
|
|
type = DecodeSpecial(i, field[i], &val);
|
|
if (type == IGNORE)
|
|
continue;
|
|
|
|
dmask = DTK_M(type);
|
|
switch (type)
|
|
{
|
|
case MONTH:
|
|
tm->tm_mon = val;
|
|
break;
|
|
|
|
case ADBC:
|
|
bc = (val == BC);
|
|
break;
|
|
|
|
default:
|
|
return -1;
|
|
}
|
|
if (fmask & dmask)
|
|
return -1;
|
|
|
|
fmask |= dmask;
|
|
*tmask |= dmask;
|
|
|
|
/* mark this field as being completed */
|
|
field[i] = NULL;
|
|
}
|
|
}
|
|
|
|
/* now pick up remaining numeric fields */
|
|
for (i = 0; i < nf; i++)
|
|
{
|
|
if (field[i] == NULL)
|
|
continue;
|
|
|
|
if ((len = strlen(field[i])) <= 0)
|
|
return -1;
|
|
|
|
if (DecodeNumber(len, field[i], fmask, &dmask, tm, &fsec, &is2digits) != 0)
|
|
return -1;
|
|
|
|
if (fmask & dmask)
|
|
return -1;
|
|
|
|
fmask |= dmask;
|
|
*tmask |= dmask;
|
|
}
|
|
|
|
if ((fmask & ~(DTK_M(DOY) | DTK_M(TZ))) != DTK_DATE_M)
|
|
return -1;
|
|
|
|
/* there is no year zero in AD/BC notation; i.e. "1 BC" == year 0 */
|
|
if (bc)
|
|
{
|
|
if (tm->tm_year > 0)
|
|
tm->tm_year = -(tm->tm_year - 1);
|
|
else
|
|
elog(ERROR, "Inconsistant use of year %04d and 'BC'", tm->tm_year);
|
|
}
|
|
else if (is2digits)
|
|
{
|
|
if (tm->tm_year < 70)
|
|
tm->tm_year += 2000;
|
|
else if (tm->tm_year < 100)
|
|
tm->tm_year += 1900;
|
|
}
|
|
|
|
return 0;
|
|
} /* DecodeDate() */
|
|
|
|
|
|
/* DecodeTime()
|
|
* Decode time string which includes delimiters.
|
|
* Only check the lower limit on hours, since this same code
|
|
* can be used to represent time spans.
|
|
*/
|
|
static int
|
|
DecodeTime(char *str, int fmask, int *tmask, struct tm * tm, double *fsec)
|
|
{
|
|
char *cp;
|
|
|
|
*tmask = DTK_TIME_M;
|
|
|
|
tm->tm_hour = strtol(str, &cp, 10);
|
|
if (*cp != ':')
|
|
return -1;
|
|
str = cp + 1;
|
|
tm->tm_min = strtol(str, &cp, 10);
|
|
if (*cp == '\0')
|
|
{
|
|
tm->tm_sec = 0;
|
|
*fsec = 0;
|
|
|
|
}
|
|
else if (*cp != ':')
|
|
{
|
|
return -1;
|
|
|
|
}
|
|
else
|
|
{
|
|
str = cp + 1;
|
|
tm->tm_sec = strtol(str, &cp, 10);
|
|
if (*cp == '\0')
|
|
*fsec = 0;
|
|
else if (*cp == '.')
|
|
{
|
|
str = cp;
|
|
*fsec = strtod(str, &cp);
|
|
if (cp == str)
|
|
return -1;
|
|
}
|
|
else
|
|
return -1;
|
|
}
|
|
|
|
/* do a sanity check */
|
|
if ((tm->tm_hour < 0)
|
|
|| (tm->tm_min < 0) || (tm->tm_min > 59)
|
|
|| (tm->tm_sec < 0) || (tm->tm_sec > 59))
|
|
return -1;
|
|
|
|
return 0;
|
|
} /* DecodeTime() */
|
|
|
|
|
|
/* DecodeNumber()
|
|
* Interpret numeric field as a date value in context.
|
|
*/
|
|
static int
|
|
DecodeNumber(int flen, char *str, int fmask,
|
|
int *tmask, struct tm * tm, double *fsec, int *is2digits)
|
|
{
|
|
int val;
|
|
char *cp;
|
|
|
|
*tmask = 0;
|
|
|
|
val = strtol(str, &cp, 10);
|
|
if (cp == str)
|
|
return -1;
|
|
if (*cp == '.')
|
|
{
|
|
*fsec = strtod(cp, &cp);
|
|
if (*cp != '\0')
|
|
return -1;
|
|
}
|
|
|
|
/* Special case day of year? */
|
|
if ((flen == 3) && (fmask & DTK_M(YEAR))
|
|
&& ((val >= 1) && (val <= 366)))
|
|
{
|
|
*tmask = (DTK_M(DOY) | DTK_M(MONTH) | DTK_M(DAY));
|
|
tm->tm_yday = val;
|
|
j2date((date2j(tm->tm_year, 1, 1) + tm->tm_yday - 1),
|
|
&tm->tm_year, &tm->tm_mon, &tm->tm_mday);
|
|
|
|
}
|
|
|
|
/*
|
|
* Enough digits to be unequivocal year? Used to test for 4 digits or
|
|
* more, but we now test first for a three-digit doy so anything
|
|
* bigger than two digits had better be an explicit year. - thomas
|
|
* 1999-01-09 Back to requiring a 4 digit year. We accept a two digit
|
|
* year farther down. - thomas 2000-03-28
|
|
*/
|
|
else if (flen >= 4)
|
|
{
|
|
*tmask = DTK_M(YEAR);
|
|
|
|
/* already have a year? then see if we can substitute... */
|
|
if ((fmask & DTK_M(YEAR)) && (!(fmask & DTK_M(DAY)))
|
|
&& ((tm->tm_year >= 1) && (tm->tm_year <= 31)))
|
|
{
|
|
tm->tm_mday = tm->tm_year;
|
|
*tmask = DTK_M(DAY);
|
|
}
|
|
|
|
tm->tm_year = val;
|
|
}
|
|
|
|
/* already have year? then could be month */
|
|
else if ((fmask & DTK_M(YEAR)) && (!(fmask & DTK_M(MONTH)))
|
|
&& ((val >= 1) && (val <= 12)))
|
|
{
|
|
*tmask = DTK_M(MONTH);
|
|
tm->tm_mon = val;
|
|
|
|
}
|
|
/* no year and EuroDates enabled? then could be day */
|
|
else if ((EuroDates || (fmask & DTK_M(MONTH)))
|
|
&& (!(fmask & DTK_M(YEAR)) && !(fmask & DTK_M(DAY)))
|
|
&& ((val >= 1) && (val <= 31)))
|
|
{
|
|
*tmask = DTK_M(DAY);
|
|
tm->tm_mday = val;
|
|
}
|
|
else if ((!(fmask & DTK_M(MONTH)))
|
|
&& ((val >= 1) && (val <= 12)))
|
|
{
|
|
*tmask = DTK_M(MONTH);
|
|
tm->tm_mon = val;
|
|
}
|
|
else if ((!(fmask & DTK_M(DAY)))
|
|
&& ((val >= 1) && (val <= 31)))
|
|
{
|
|
*tmask = DTK_M(DAY);
|
|
tm->tm_mday = val;
|
|
}
|
|
|
|
/*
|
|
* Check for 2 or 4 or more digits, but currently we reach here only
|
|
* if two digits. - thomas 2000-03-28
|
|
*/
|
|
else if (!(fmask & DTK_M(YEAR))
|
|
&& ((flen >= 4) || (flen == 2)))
|
|
{
|
|
*tmask = DTK_M(YEAR);
|
|
tm->tm_year = val;
|
|
|
|
/* adjust ONLY if exactly two digits... */
|
|
*is2digits = (flen == 2);
|
|
}
|
|
else
|
|
return -1;
|
|
|
|
return 0;
|
|
} /* DecodeNumber() */
|
|
|
|
|
|
/* DecodeNumberField()
|
|
* Interpret numeric string as a concatenated date field.
|
|
*/
|
|
static int
|
|
DecodeNumberField(int len, char *str, int fmask,
|
|
int *tmask, struct tm * tm, double *fsec, int *is2digits)
|
|
{
|
|
char *cp;
|
|
|
|
/* yyyymmdd? */
|
|
if (len == 8)
|
|
{
|
|
*tmask = DTK_DATE_M;
|
|
|
|
tm->tm_mday = atoi(str + 6);
|
|
*(str + 6) = '\0';
|
|
tm->tm_mon = atoi(str + 4);
|
|
*(str + 4) = '\0';
|
|
tm->tm_year = atoi(str + 0);
|
|
/* yymmdd or hhmmss? */
|
|
}
|
|
else if (len == 6)
|
|
{
|
|
if (fmask & DTK_DATE_M)
|
|
{
|
|
*tmask = DTK_TIME_M;
|
|
tm->tm_sec = atoi(str + 4);
|
|
*(str + 4) = '\0';
|
|
tm->tm_min = atoi(str + 2);
|
|
*(str + 2) = '\0';
|
|
tm->tm_hour = atoi(str + 0);
|
|
}
|
|
else
|
|
{
|
|
*tmask = DTK_DATE_M;
|
|
tm->tm_mday = atoi(str + 4);
|
|
*(str + 4) = '\0';
|
|
tm->tm_mon = atoi(str + 2);
|
|
*(str + 2) = '\0';
|
|
tm->tm_year = atoi(str + 0);
|
|
*is2digits = TRUE;
|
|
}
|
|
|
|
}
|
|
else if ((len == 5) && !(fmask & DTK_DATE_M))
|
|
{
|
|
*tmask = DTK_DATE_M;
|
|
tm->tm_mday = atoi(str + 2);
|
|
*(str + 2) = '\0';
|
|
tm->tm_mon = 1;
|
|
tm->tm_year = atoi(str + 0);
|
|
*is2digits = TRUE;
|
|
}
|
|
else if (strchr(str, '.') != NULL)
|
|
{
|
|
*tmask = DTK_TIME_M;
|
|
tm->tm_sec = strtod((str + 4), &cp);
|
|
if (cp == (str + 4))
|
|
return -1;
|
|
if (*cp == '.')
|
|
*fsec = strtod(cp, NULL);
|
|
*(str + 4) = '\0';
|
|
tm->tm_min = strtod((str + 2), &cp);
|
|
*(str + 2) = '\0';
|
|
tm->tm_hour = strtod((str + 0), &cp);
|
|
|
|
}
|
|
else
|
|
return -1;
|
|
|
|
return 0;
|
|
} /* DecodeNumberField() */
|
|
|
|
|
|
/* DecodeTimezone()
|
|
* Interpret string as a numeric timezone.
|
|
*/
|
|
static int
|
|
DecodeTimezone(char *str, int *tzp)
|
|
{
|
|
int tz;
|
|
int hr,
|
|
min;
|
|
char *cp;
|
|
int len;
|
|
|
|
/* assume leading character is "+" or "-" */
|
|
hr = strtol((str + 1), &cp, 10);
|
|
|
|
/* explicit delimiter? */
|
|
if (*cp == ':')
|
|
{
|
|
min = strtol((cp + 1), &cp, 10);
|
|
|
|
/* otherwise, might have run things together... */
|
|
}
|
|
else if ((*cp == '\0') && ((len = strlen(str)) > 3))
|
|
{
|
|
min = strtol((str + len - 2), &cp, 10);
|
|
*(str + len - 2) = '\0';
|
|
hr = strtol((str + 1), &cp, 10);
|
|
|
|
}
|
|
else
|
|
min = 0;
|
|
|
|
tz = (hr * 60 + min) * 60;
|
|
if (*str == '-')
|
|
tz = -tz;
|
|
|
|
*tzp = -tz;
|
|
return *cp != '\0';
|
|
} /* DecodeTimezone() */
|
|
|
|
|
|
/* DecodePosixTimezone()
|
|
* Interpret string as a POSIX-compatible timezone:
|
|
* PST-hh:mm
|
|
* PST+h
|
|
* - thomas 2000-03-15
|
|
*/
|
|
static int
|
|
DecodePosixTimezone(char *str, int *tzp)
|
|
{
|
|
int val,
|
|
tz;
|
|
int type;
|
|
char *cp;
|
|
char delim;
|
|
|
|
cp = str;
|
|
while ((*cp != '\0') && isalpha((unsigned char) *cp))
|
|
cp++;
|
|
|
|
if (DecodeTimezone(cp, &tz) != 0)
|
|
return -1;
|
|
|
|
delim = *cp;
|
|
*cp = '\0';
|
|
type = DecodeSpecial(MAXDATEFIELDS - 1, str, &val);
|
|
*cp = delim;
|
|
|
|
switch (type)
|
|
{
|
|
case DTZ:
|
|
case TZ:
|
|
*tzp = (val * 60) - tz;
|
|
break;
|
|
|
|
default:
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
} /* DecodePosixTimezone() */
|
|
|
|
|
|
/* DecodeSpecial()
|
|
* Decode text string using lookup table.
|
|
* Implement a cache lookup since it is likely that dates
|
|
* will be related in format.
|
|
*/
|
|
int
|
|
DecodeSpecial(int field, char *lowtoken, int *val)
|
|
{
|
|
int type;
|
|
datetkn *tp;
|
|
|
|
#if USE_DATE_CACHE
|
|
if ((datecache[field] != NULL)
|
|
&& (strncmp(lowtoken, datecache[field]->token, TOKMAXLEN) == 0))
|
|
tp = datecache[field];
|
|
else
|
|
{
|
|
#endif
|
|
tp = datebsearch(lowtoken, datetktbl, szdatetktbl);
|
|
#if USE_DATE_CACHE
|
|
}
|
|
datecache[field] = tp;
|
|
#endif
|
|
if (tp == NULL)
|
|
{
|
|
type = IGNORE;
|
|
*val = 0;
|
|
}
|
|
else
|
|
{
|
|
type = tp->type;
|
|
switch (type)
|
|
{
|
|
case TZ:
|
|
case DTZ:
|
|
case DTZMOD:
|
|
*val = FROMVAL(tp);
|
|
break;
|
|
|
|
default:
|
|
*val = tp->value;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return type;
|
|
} /* DecodeSpecial() */
|
|
|
|
|
|
/* DecodeDateDelta()
|
|
* Interpret previously parsed fields for general time interval.
|
|
* Return 0 if decoded and -1 if problems.
|
|
*
|
|
* Allow "date" field DTK_DATE since this could be just
|
|
* an unsigned floating point number. - thomas 1997-11-16
|
|
*
|
|
* Allow ISO-style time span, with implicit units on number of days
|
|
* preceeding an hh:mm:ss field. - thomas 1998-04-30
|
|
*/
|
|
int
|
|
DecodeDateDelta(char **field, int *ftype, int nf, int *dtype, struct tm * tm, double *fsec)
|
|
{
|
|
int is_before = FALSE;
|
|
|
|
char *cp;
|
|
int fmask = 0,
|
|
tmask,
|
|
type;
|
|
int i;
|
|
int val;
|
|
double fval;
|
|
double sec;
|
|
|
|
*dtype = DTK_DELTA;
|
|
|
|
type = IGNORE;
|
|
tm->tm_year = 0;
|
|
tm->tm_mon = 0;
|
|
tm->tm_mday = 0;
|
|
tm->tm_hour = 0;
|
|
tm->tm_min = 0;
|
|
tm->tm_sec = 0;
|
|
*fsec = 0;
|
|
|
|
/* read through list backwards to pick up units before values */
|
|
for (i = nf - 1; i >= 0; i--)
|
|
{
|
|
switch (ftype[i])
|
|
{
|
|
case DTK_TIME:
|
|
if (DecodeTime(field[i], fmask, &tmask, tm, fsec) != 0)
|
|
return -1;
|
|
type = DTK_DAY;
|
|
break;
|
|
|
|
case DTK_TZ:
|
|
/*
|
|
* Timezone is a token with a leading sign character and
|
|
* otherwise the same as a non-signed time field
|
|
*/
|
|
Assert((*field[i] == '-') || (*field[i] == '+'));
|
|
/* A single signed number ends up here, but will be rejected by DecodeTime().
|
|
* So, work this out to drop through to DTK_NUMBER, which *can* tolerate this.
|
|
*/
|
|
cp = field[i]+1;
|
|
while ((*cp != '\0') && (*cp != ':') && (*cp != '.'))
|
|
cp++;
|
|
if ((*cp == ':')
|
|
&& (DecodeTime((field[i]+1), fmask, &tmask, tm, fsec) == 0)) {
|
|
if (*field[i] == '-') {
|
|
/* flip the sign on all fields */
|
|
tm->tm_hour = -tm->tm_hour;
|
|
tm->tm_min = -tm->tm_min;
|
|
tm->tm_sec = -tm->tm_sec;
|
|
*fsec = -(*fsec);
|
|
}
|
|
|
|
/* Set the next type to be a day, if units are not specified.
|
|
* This handles the case of '1 +02:03' since we are reading right to left.
|
|
*/
|
|
type = DTK_DAY;
|
|
tmask = DTK_M(TZ);
|
|
break;
|
|
} else if (type == IGNORE) {
|
|
if (*cp == '.') {
|
|
/* Got a decimal point? Then assume some sort of seconds specification */
|
|
type = DTK_SECOND;
|
|
} else if (*cp == '\0') {
|
|
/* Only a signed integer? Then must assume a timezone-like usage */
|
|
type = DTK_HOUR;
|
|
}
|
|
}
|
|
/* DROP THROUGH */
|
|
|
|
case DTK_DATE:
|
|
case DTK_NUMBER:
|
|
val = strtol(field[i], &cp, 10);
|
|
|
|
if (*cp == '.')
|
|
{
|
|
if (type == IGNORE)
|
|
type = DTK_SECOND;
|
|
fval = strtod(cp, &cp);
|
|
if (*cp != '\0')
|
|
return -1;
|
|
|
|
if (val < 0)
|
|
fval = -(fval);
|
|
}
|
|
else if (*cp == '\0')
|
|
fval = 0;
|
|
else
|
|
return -1;
|
|
|
|
tmask = 0; /* DTK_M(type); */
|
|
|
|
switch (type)
|
|
{
|
|
case DTK_MICROSEC:
|
|
*fsec += ((val + fval) * 1e-6);
|
|
break;
|
|
|
|
case DTK_MILLISEC:
|
|
*fsec += ((val + fval) * 1e-3);
|
|
break;
|
|
|
|
case DTK_SECOND:
|
|
tm->tm_sec += val;
|
|
*fsec += fval;
|
|
tmask = DTK_M(SECOND);
|
|
break;
|
|
|
|
case DTK_MINUTE:
|
|
tm->tm_min += val;
|
|
if (fval != 0)
|
|
tm->tm_sec += (fval * 60);
|
|
tmask = DTK_M(MINUTE);
|
|
break;
|
|
|
|
case DTK_HOUR:
|
|
tm->tm_hour += val;
|
|
if (fval != 0)
|
|
tm->tm_sec += (fval * 3600);
|
|
tmask = DTK_M(HOUR);
|
|
break;
|
|
|
|
case DTK_DAY:
|
|
tm->tm_mday += val;
|
|
if (fval != 0)
|
|
tm->tm_sec += (fval * 86400);
|
|
tmask = ((fmask & DTK_M(DAY)) ? 0 : DTK_M(DAY));
|
|
break;
|
|
|
|
case DTK_WEEK:
|
|
tm->tm_mday += val * 7;
|
|
if (fval != 0)
|
|
tm->tm_sec += (fval * (7 * 86400));
|
|
tmask = ((fmask & DTK_M(DAY)) ? 0 : DTK_M(DAY));
|
|
break;
|
|
|
|
case DTK_MONTH:
|
|
tm->tm_mon += val;
|
|
if (fval != 0)
|
|
tm->tm_sec += (fval * (30 * 86400));
|
|
tmask = DTK_M(MONTH);
|
|
break;
|
|
|
|
case DTK_YEAR:
|
|
tm->tm_year += val;
|
|
if (fval != 0)
|
|
tm->tm_mon += (fval * 12);
|
|
tmask = ((fmask & DTK_M(YEAR)) ? 0 : DTK_M(YEAR));
|
|
break;
|
|
|
|
case DTK_DECADE:
|
|
tm->tm_year += val * 10;
|
|
if (fval != 0)
|
|
tm->tm_mon += (fval * 120);
|
|
tmask = ((fmask & DTK_M(YEAR)) ? 0 : DTK_M(YEAR));
|
|
break;
|
|
|
|
case DTK_CENTURY:
|
|
tm->tm_year += val * 100;
|
|
if (fval != 0)
|
|
tm->tm_mon += (fval * 1200);
|
|
tmask = ((fmask & DTK_M(YEAR)) ? 0 : DTK_M(YEAR));
|
|
break;
|
|
|
|
case DTK_MILLENNIUM:
|
|
tm->tm_year += val * 1000;
|
|
if (fval != 0)
|
|
tm->tm_mon += (fval * 12000);
|
|
tmask = ((fmask & DTK_M(YEAR)) ? 0 : DTK_M(YEAR));
|
|
break;
|
|
|
|
default:
|
|
return -1;
|
|
}
|
|
break;
|
|
|
|
case DTK_STRING:
|
|
case DTK_SPECIAL:
|
|
type = DecodeUnits(i, field[i], &val);
|
|
if (type == IGNORE)
|
|
continue;
|
|
|
|
tmask = 0; /* DTK_M(type); */
|
|
switch (type)
|
|
{
|
|
case UNITS:
|
|
type = val;
|
|
break;
|
|
|
|
case AGO:
|
|
is_before = TRUE;
|
|
type = val;
|
|
break;
|
|
|
|
case RESERV:
|
|
tmask = (DTK_DATE_M || DTK_TIME_M);
|
|
*dtype = val;
|
|
break;
|
|
|
|
default:
|
|
return -1;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return -1;
|
|
}
|
|
|
|
if (tmask & fmask)
|
|
return -1;
|
|
fmask |= tmask;
|
|
}
|
|
|
|
if (*fsec != 0)
|
|
{
|
|
TMODULO(*fsec, sec, 1e0);
|
|
tm->tm_sec += sec;
|
|
}
|
|
|
|
if (is_before)
|
|
{
|
|
*fsec = -(*fsec);
|
|
tm->tm_sec = -(tm->tm_sec);
|
|
tm->tm_min = -(tm->tm_min);
|
|
tm->tm_hour = -(tm->tm_hour);
|
|
tm->tm_mday = -(tm->tm_mday);
|
|
tm->tm_mon = -(tm->tm_mon);
|
|
tm->tm_year = -(tm->tm_year);
|
|
}
|
|
|
|
/* ensure that at least one time field has been found */
|
|
return (fmask != 0) ? 0 : -1;
|
|
} /* DecodeDateDelta() */
|
|
|
|
|
|
/* DecodeUnits()
|
|
* Decode text string using lookup table.
|
|
* This routine supports time interval decoding.
|
|
*/
|
|
int
|
|
DecodeUnits(int field, char *lowtoken, int *val)
|
|
{
|
|
int type;
|
|
datetkn *tp;
|
|
|
|
#if USE_DATE_CACHE
|
|
if ((deltacache[field] != NULL)
|
|
&& (strncmp(lowtoken, deltacache[field]->token, TOKMAXLEN) == 0))
|
|
tp = deltacache[field];
|
|
else
|
|
{
|
|
#endif
|
|
tp = datebsearch(lowtoken, deltatktbl, szdeltatktbl);
|
|
#if USE_DATE_CACHE
|
|
}
|
|
deltacache[field] = tp;
|
|
#endif
|
|
if (tp == NULL)
|
|
{
|
|
type = IGNORE;
|
|
*val = 0;
|
|
}
|
|
else
|
|
{
|
|
type = tp->type;
|
|
if ((type == TZ) || (type == DTZ))
|
|
*val = FROMVAL(tp);
|
|
else
|
|
*val = tp->value;
|
|
}
|
|
|
|
return type;
|
|
} /* DecodeUnits() */
|
|
|
|
|
|
/* datebsearch()
|
|
* Binary search -- from Knuth (6.2.1) Algorithm B. Special case like this
|
|
* is WAY faster than the generic bsearch().
|
|
*/
|
|
static datetkn *
|
|
datebsearch(char *key, datetkn *base, unsigned int nel)
|
|
{
|
|
datetkn *last = base + nel - 1,
|
|
*position;
|
|
int result;
|
|
|
|
while (last >= base)
|
|
{
|
|
position = base + ((last - base) >> 1);
|
|
result = key[0] - position->token[0];
|
|
if (result == 0)
|
|
{
|
|
result = strncmp(key, position->token, TOKMAXLEN);
|
|
if (result == 0)
|
|
return position;
|
|
}
|
|
if (result < 0)
|
|
last = position - 1;
|
|
else
|
|
base = position + 1;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
/* EncodeDateOnly()
|
|
* Encode date as local time.
|
|
*/
|
|
int
|
|
EncodeDateOnly(struct tm * tm, int style, char *str)
|
|
{
|
|
if ((tm->tm_mon < 1) || (tm->tm_mon > 12))
|
|
return -1;
|
|
|
|
switch (style)
|
|
{
|
|
/* compatible with ISO date formats */
|
|
case USE_ISO_DATES:
|
|
if (tm->tm_year > 0)
|
|
sprintf(str, "%04d-%02d-%02d",
|
|
tm->tm_year, tm->tm_mon, tm->tm_mday);
|
|
else
|
|
sprintf(str, "%04d-%02d-%02d %s",
|
|
-(tm->tm_year - 1), tm->tm_mon, tm->tm_mday, "BC");
|
|
break;
|
|
|
|
/* compatible with Oracle/Ingres date formats */
|
|
case USE_SQL_DATES:
|
|
if (EuroDates)
|
|
sprintf(str, "%02d/%02d", tm->tm_mday, tm->tm_mon);
|
|
else
|
|
sprintf(str, "%02d/%02d", tm->tm_mon, tm->tm_mday);
|
|
if (tm->tm_year > 0)
|
|
sprintf((str + 5), "/%04d", tm->tm_year);
|
|
else
|
|
sprintf((str + 5), "/%04d %s", -(tm->tm_year - 1), "BC");
|
|
break;
|
|
|
|
/* German-style date format */
|
|
case USE_GERMAN_DATES:
|
|
sprintf(str, "%02d.%02d", tm->tm_mday, tm->tm_mon);
|
|
if (tm->tm_year > 0)
|
|
sprintf((str + 5), ".%04d", tm->tm_year);
|
|
else
|
|
sprintf((str + 5), ".%04d %s", -(tm->tm_year - 1), "BC");
|
|
break;
|
|
|
|
/* traditional date-only style for Postgres */
|
|
case USE_POSTGRES_DATES:
|
|
default:
|
|
if (EuroDates)
|
|
sprintf(str, "%02d-%02d", tm->tm_mday, tm->tm_mon);
|
|
else
|
|
sprintf(str, "%02d-%02d", tm->tm_mon, tm->tm_mday);
|
|
if (tm->tm_year > 0)
|
|
sprintf((str + 5), "-%04d", tm->tm_year);
|
|
else
|
|
sprintf((str + 5), "-%04d %s", -(tm->tm_year - 1), "BC");
|
|
break;
|
|
}
|
|
|
|
return TRUE;
|
|
} /* EncodeDateOnly() */
|
|
|
|
|
|
/* EncodeTimeOnly()
|
|
* Encode time fields only.
|
|
*/
|
|
int
|
|
EncodeTimeOnly(struct tm * tm, double fsec, int *tzp, int style, char *str)
|
|
{
|
|
double sec;
|
|
|
|
if ((tm->tm_hour < 0) || (tm->tm_hour > 24))
|
|
return -1;
|
|
|
|
sec = (tm->tm_sec + fsec);
|
|
|
|
sprintf(str, "%02d:%02d:", tm->tm_hour, tm->tm_min);
|
|
sprintf((str + 6), ((fsec != 0) ? "%05.2f" : "%02.0f"), sec);
|
|
|
|
if (tzp != NULL)
|
|
{
|
|
int hour,
|
|
min;
|
|
|
|
hour = -(*tzp / 3600);
|
|
min = ((abs(*tzp) / 60) % 60);
|
|
sprintf((str + strlen(str)), ((min != 0) ? "%+03d:%02d" : "%+03d"), hour, min);
|
|
}
|
|
|
|
return TRUE;
|
|
} /* EncodeTimeOnly() */
|
|
|
|
|
|
/* EncodeDateTime()
|
|
* Encode date and time interpreted as local time.
|
|
* Support several date styles:
|
|
* Postgres - day mon hh:mm:ss yyyy tz
|
|
* SQL - mm/dd/yyyy hh:mm:ss.ss tz
|
|
* ISO - yyyy-mm-dd hh:mm:ss+/-tz
|
|
* German - dd.mm/yyyy hh:mm:ss tz
|
|
* Variants (affects order of month and day for Postgres and SQL styles):
|
|
* US - mm/dd/yyyy
|
|
* European - dd/mm/yyyy
|
|
*/
|
|
int
|
|
EncodeDateTime(struct tm * tm, double fsec, int *tzp, char **tzn, int style, char *str)
|
|
{
|
|
int day,
|
|
hour,
|
|
min;
|
|
double sec;
|
|
|
|
if ((tm->tm_mon < 1) || (tm->tm_mon > 12))
|
|
return -1;
|
|
|
|
sec = (tm->tm_sec + fsec);
|
|
|
|
switch (style)
|
|
{
|
|
/* compatible with ISO date formats */
|
|
|
|
case USE_ISO_DATES:
|
|
if (tm->tm_year > 0)
|
|
{
|
|
sprintf(str, "%04d-%02d-%02d %02d:%02d:",
|
|
tm->tm_year, tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min);
|
|
sprintf((str + 17), ((fsec != 0) ? "%05.2f" : "%02.0f"), sec);
|
|
|
|
if ((*tzn != NULL) && (tm->tm_isdst >= 0))
|
|
{
|
|
if (tzp != NULL)
|
|
{
|
|
hour = -(*tzp / 3600);
|
|
min = ((abs(*tzp) / 60) % 60);
|
|
}
|
|
else
|
|
{
|
|
hour = 0;
|
|
min = 0;
|
|
}
|
|
sprintf((str + strlen(str)), ((min != 0) ? "%+03d:%02d" : "%+03d"), hour, min);
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
if (tm->tm_hour || tm->tm_min)
|
|
sprintf(str, "%04d-%02d-%02d %02d:%02d %s",
|
|
-(tm->tm_year - 1), tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min, "BC");
|
|
else
|
|
sprintf(str, "%04d-%02d-%02d %s",
|
|
-(tm->tm_year - 1), tm->tm_mon, tm->tm_mday, "BC");
|
|
}
|
|
break;
|
|
|
|
/* compatible with Oracle/Ingres date formats */
|
|
case USE_SQL_DATES:
|
|
if (EuroDates)
|
|
sprintf(str, "%02d/%02d", tm->tm_mday, tm->tm_mon);
|
|
else
|
|
sprintf(str, "%02d/%02d", tm->tm_mon, tm->tm_mday);
|
|
|
|
if (tm->tm_year > 0)
|
|
{
|
|
sprintf((str + 5), "/%04d %02d:%02d:%05.2f",
|
|
tm->tm_year, tm->tm_hour, tm->tm_min, sec);
|
|
|
|
if ((*tzn != NULL) && (tm->tm_isdst >= 0))
|
|
{
|
|
strcpy((str + 22), " ");
|
|
strcpy((str + 23), *tzn);
|
|
}
|
|
|
|
}
|
|
else
|
|
sprintf((str + 5), "/%04d %02d:%02d %s",
|
|
-(tm->tm_year - 1), tm->tm_hour, tm->tm_min, "BC");
|
|
break;
|
|
|
|
/* German variant on European style */
|
|
case USE_GERMAN_DATES:
|
|
sprintf(str, "%02d.%02d", tm->tm_mday, tm->tm_mon);
|
|
if (tm->tm_year > 0)
|
|
{
|
|
sprintf((str + 5), ".%04d %02d:%02d:%05.2f",
|
|
tm->tm_year, tm->tm_hour, tm->tm_min, sec);
|
|
|
|
if ((*tzn != NULL) && (tm->tm_isdst >= 0))
|
|
{
|
|
strcpy((str + 22), " ");
|
|
strcpy((str + 23), *tzn);
|
|
}
|
|
|
|
}
|
|
else
|
|
sprintf((str + 5), ".%04d %02d:%02d %s",
|
|
-(tm->tm_year - 1), tm->tm_hour, tm->tm_min, "BC");
|
|
break;
|
|
|
|
/* backward-compatible with traditional Postgres abstime dates */
|
|
case USE_POSTGRES_DATES:
|
|
default:
|
|
day = date2j(tm->tm_year, tm->tm_mon, tm->tm_mday);
|
|
tm->tm_wday = j2day(day);
|
|
|
|
strncpy(str, days[tm->tm_wday], 3);
|
|
strcpy((str + 3), " ");
|
|
|
|
if (EuroDates)
|
|
sprintf((str + 4), "%02d %3s", tm->tm_mday, months[tm->tm_mon - 1]);
|
|
else
|
|
sprintf((str + 4), "%3s %02d", months[tm->tm_mon - 1], tm->tm_mday);
|
|
|
|
if (tm->tm_year > 0)
|
|
{
|
|
sprintf((str + 10), " %02d:%02d", tm->tm_hour, tm->tm_min);
|
|
if (fsec != 0)
|
|
{
|
|
sprintf((str + 16), ":%05.2f %04d", sec, tm->tm_year);
|
|
if ((*tzn != NULL) && (tm->tm_isdst >= 0))
|
|
{
|
|
strcpy((str + 27), " ");
|
|
StrNCpy((str + 28), *tzn, MAXTZLEN+1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sprintf((str + 16), ":%02.0f %04d", sec, tm->tm_year);
|
|
if ((*tzn != NULL) && (tm->tm_isdst >= 0))
|
|
{
|
|
strcpy((str + 24), " ");
|
|
StrNCpy((str + 25), *tzn, MAXTZLEN+1);
|
|
}
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
sprintf((str + 10), " %02d:%02d %04d %s",
|
|
tm->tm_hour, tm->tm_min, -(tm->tm_year - 1), "BC");
|
|
}
|
|
break;
|
|
}
|
|
|
|
return TRUE;
|
|
} /* EncodeDateTime() */
|
|
|
|
|
|
/* EncodeTimeSpan()
|
|
* Interpret time structure as a delta time and convert to string.
|
|
*
|
|
* Support "traditional Postgres" and ISO-8601 styles.
|
|
* Actually, afaik ISO does not address time interval formatting,
|
|
* but this looks similar to the spec for absolute date/time.
|
|
* - thomas 1998-04-30
|
|
*/
|
|
int
|
|
EncodeTimeSpan(struct tm * tm, double fsec, int style, char *str)
|
|
{
|
|
int is_before = FALSE;
|
|
int is_nonzero = FALSE;
|
|
char *cp = str;
|
|
|
|
/* The sign of year and month are guaranteed to match,
|
|
* since they are stored internally as "month".
|
|
* But we'll need to check for is_before and is_nonzero
|
|
* when determining the signs of hour/minute/seconds fields.
|
|
*/
|
|
switch (style)
|
|
{
|
|
/* compatible with ISO date formats */
|
|
case USE_ISO_DATES:
|
|
if (tm->tm_year != 0)
|
|
{
|
|
sprintf(cp, "%d year%s",
|
|
tm->tm_year, ((tm->tm_year != 1) ? "s" : ""));
|
|
cp += strlen(cp);
|
|
is_before = (tm->tm_year < 0);
|
|
is_nonzero = TRUE;
|
|
}
|
|
|
|
if (tm->tm_mon != 0)
|
|
{
|
|
sprintf(cp, "%s%s%d mon%s", (is_nonzero ? " " : ""),
|
|
((is_before && (tm->tm_mon > 0)) ? "+" : ""),
|
|
tm->tm_mon, ((tm->tm_mon != 1) ? "s" : ""));
|
|
cp += strlen(cp);
|
|
is_before = (tm->tm_mon < 0);
|
|
is_nonzero = TRUE;
|
|
}
|
|
|
|
if (tm->tm_mday != 0)
|
|
{
|
|
sprintf(cp, "%s%s%d day%s", (is_nonzero ? " " : ""),
|
|
((is_before && (tm->tm_mday > 0)) ? "+" : ""),
|
|
tm->tm_mday, ((tm->tm_mday != 1) ? "s" : ""));
|
|
cp += strlen(cp);
|
|
is_before = (tm->tm_mday < 0);
|
|
is_nonzero = TRUE;
|
|
}
|
|
{
|
|
int minus = ((tm->tm_hour < 0) || (tm->tm_min < 0)
|
|
|| (tm->tm_sec < 0) || (fsec < 0));
|
|
|
|
sprintf(cp, "%s%s%02d:%02d", (is_nonzero ? " " : ""),
|
|
(minus ? "-" : (is_nonzero ? "+" : "")),
|
|
abs(tm->tm_hour), abs(tm->tm_min));
|
|
cp += strlen(cp);
|
|
/* Mark as "non-zero" since the fields are now filled in */
|
|
is_nonzero = TRUE;
|
|
|
|
/* fractional seconds? */
|
|
if (fsec != 0)
|
|
{
|
|
fsec += tm->tm_sec;
|
|
sprintf(cp, ":%05.2f", fabs(fsec));
|
|
cp += strlen(cp);
|
|
is_nonzero = TRUE;
|
|
|
|
/* otherwise, integer seconds only? */
|
|
}
|
|
else if (tm->tm_sec != 0)
|
|
{
|
|
sprintf(cp, ":%02d", abs(tm->tm_sec));
|
|
cp += strlen(cp);
|
|
is_nonzero = TRUE;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case USE_POSTGRES_DATES:
|
|
default:
|
|
strcpy(cp, "@ ");
|
|
cp += strlen(cp);
|
|
|
|
if (tm->tm_year != 0)
|
|
{
|
|
int year = ((tm->tm_year < 0) ? -(tm->tm_year) : tm->tm_year);
|
|
|
|
sprintf(cp, "%d year%s", year,
|
|
((year != 1) ? "s" : ""));
|
|
cp += strlen(cp);
|
|
is_before = (tm->tm_year < 0);
|
|
is_nonzero = TRUE;
|
|
}
|
|
|
|
if (tm->tm_mon != 0)
|
|
{
|
|
int mon = ((is_before && (tm->tm_mon > 0)) ? -(tm->tm_mon) : tm->tm_mon);
|
|
|
|
sprintf(cp, "%s%d mon%s", (is_nonzero ? " " : ""), mon,
|
|
((mon != 1) ? "s" : ""));
|
|
cp += strlen(cp);
|
|
if (! is_nonzero)
|
|
is_before = (tm->tm_mon < 0);
|
|
is_nonzero = TRUE;
|
|
}
|
|
|
|
if (tm->tm_mday != 0)
|
|
{
|
|
int day = ((is_before && (tm->tm_mday > 0)) ? -(tm->tm_mday) : tm->tm_mday);
|
|
|
|
sprintf(cp, "%s%d day%s", (is_nonzero ? " " : ""), day,
|
|
((day != 1) ? "s" : ""));
|
|
cp += strlen(cp);
|
|
if (! is_nonzero)
|
|
is_before = (tm->tm_mday < 0);
|
|
is_nonzero = TRUE;
|
|
}
|
|
if (tm->tm_hour != 0)
|
|
{
|
|
int hour = ((is_before && (tm->tm_hour > 0)) ? -(tm->tm_hour) : tm->tm_hour);
|
|
|
|
sprintf(cp, "%s%d hour%s", (is_nonzero ? " " : ""), hour,
|
|
((hour != 1) ? "s" : ""));
|
|
cp += strlen(cp);
|
|
if (! is_nonzero)
|
|
is_before = (tm->tm_hour < 0);
|
|
is_nonzero = TRUE;
|
|
}
|
|
|
|
if (tm->tm_min != 0)
|
|
{
|
|
int min = ((is_before && (tm->tm_min > 0)) ? -(tm->tm_min) : tm->tm_min);
|
|
|
|
sprintf(cp, "%s%d min%s", (is_nonzero ? " " : ""), min,
|
|
((min != 1) ? "s" : ""));
|
|
cp += strlen(cp);
|
|
if (! is_nonzero)
|
|
is_before = (tm->tm_min < 0);
|
|
is_nonzero = TRUE;
|
|
}
|
|
|
|
/* fractional seconds? */
|
|
if (fsec != 0)
|
|
{
|
|
fsec += tm->tm_sec;
|
|
sprintf(cp, "%s%.2f secs", (is_nonzero ? " " : ""),
|
|
((is_before && (fsec > 0)) ? -(fsec) : fsec));
|
|
cp += strlen(cp);
|
|
if (! is_nonzero)
|
|
is_before = (fsec < 0);
|
|
is_nonzero = TRUE;
|
|
|
|
/* otherwise, integer seconds only? */
|
|
}
|
|
else if (tm->tm_sec != 0)
|
|
{
|
|
int sec = ((is_before && (tm->tm_sec > 0)) ? -(tm->tm_sec) : tm->tm_sec);
|
|
|
|
sprintf(cp, "%s%d sec%s", (is_nonzero ? " " : ""), sec,
|
|
((sec != 1) ? "s" : ""));
|
|
cp += strlen(cp);
|
|
if (! is_nonzero)
|
|
is_before = (tm->tm_sec < 0);
|
|
is_nonzero = TRUE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
/* identically zero? then put in a unitless zero... */
|
|
if (! is_nonzero)
|
|
{
|
|
strcat(cp, "0");
|
|
cp += strlen(cp);
|
|
}
|
|
|
|
if (is_before && (style == USE_POSTGRES_DATES))
|
|
{
|
|
strcat(cp, " ago");
|
|
cp += strlen(cp);
|
|
}
|
|
|
|
return 0;
|
|
} /* EncodeTimeSpan() */
|
|
|
|
|
|
#if defined(linux) && defined(__powerpc__)
|
|
|
|
int
|
|
timestamp_is_epoch(double j)
|
|
{
|
|
static union
|
|
{
|
|
double epoch;
|
|
unsigned char c[8];
|
|
} u;
|
|
|
|
u.c[0] = 0x80; /* sign bit */
|
|
u.c[1] = 0x10; /* DBL_MIN */
|
|
|
|
return j == u.epoch;
|
|
}
|
|
int
|
|
timestamp_is_current(double j)
|
|
{
|
|
static union
|
|
{
|
|
double current;
|
|
unsigned char c[8];
|
|
} u;
|
|
|
|
u.c[1] = 0x10; /* DBL_MIN */
|
|
|
|
return j == u.current;
|
|
}
|
|
|
|
#endif
|