Add guard code to protect from buffer overruns on long date/time input

 strings. Should go back in and look at doing this a bit more elegantly
 and (hopefully) cheaper. Probably not too bad anyway, but it seems a
 shame to scan the strings twice: once for length for this buffer overrun
 protection, and once to parse the line.
Remove use of pow() in date/time handling; was already gone from everything
 *but* the time data types.
Define macros for handling typmod manipulation for date/time types.
 Should be more robust than all of that brute-force inline code.
Rename macros for masking and typmod manipulation to put TIMESTAMP_
 or INTERVAL_ in front of the macro name, to reduce the possibility
 of name space collisions.

diff --git a/src/backend/utils/adt/date.c b/src/backend/utils/adt/date.c
index 06d0e3abe95cb56942d78c4cea234b16286cb474..4b9d0f15e6dd5b7a291c10e3d9e5b32b6bd15f8a 100644 (file)
--- a/src/backend/utils/adt/date.c
+++ b/src/backend/utils/adt/date.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *   $Header: /cvsroot/pgsql/src/backend/utils/adt/date.c,v 1.69 2002/06/20 20:29:36 momjian Exp $
+ *   $Header: /cvsroot/pgsql/src/backend/utils/adt/date.c,v 1.70 2002/08/04 06:44:47 thomas Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -57,6 +57,9 @@ date_in(PG_FUNCTION_ARGS)
    int         ftype[MAXDATEFIELDS];
    char        lowstr[MAXDATELEN + 1];
 
+   if (strlen(str) >= sizeof(lowstr))
+       elog(ERROR, "Bad date external representation (too long) '%s'", str);
+
    if ((ParseDateTime(str, lowstr, field, ftype, MAXDATEFIELDS, &nf) != 0)
     || (DecodeDateTime(field, ftype, nf, &dtype, tm, &fsec, &tzp) != 0))
        elog(ERROR, "Bad date external representation '%s'", str);
@@ -518,6 +521,9 @@ time_in(PG_FUNCTION_ARGS)
    int         dtype;
    int         ftype[MAXDATEFIELDS];
 
+   if (strlen(str) >= sizeof(lowstr))
+       elog(ERROR, "Bad time external representation (too long) '%s'", str);
+
    if ((ParseDateTime(str, lowstr, field, ftype, MAXDATEFIELDS, &nf) != 0)
     || (DecodeTimeOnly(field, ftype, nf, &dtype, tm, &fsec, NULL) != 0))
        elog(ERROR, "Bad time external representation '%s'", str);
@@ -606,37 +612,85 @@ time_scale(PG_FUNCTION_ARGS)
    PG_RETURN_TIMEADT(result);
 }
 
+/* AdjustTimeForTypmod()
+ * Force the precision of the time value to a specified value.
+ * Uses *exactly* the same code as in AdjustTimestampForTypemod()
+ * but we make a separate copy because those types do not
+ * have a fundamental tie together but rather a coincidence of
+ * implementation. - thomas
+ */
 static void
 AdjustTimeForTypmod(TimeADT *time, int32 typmod)
 {
-   if ((typmod >= 0) && (typmod <= MAX_TIME_PRECISION))
-   {
 #ifdef HAVE_INT64_TIMESTAMP
-       static int64 TimeScale = INT64CONST(1000000);
+   static const int64 TimeScales[MAX_TIMESTAMP_PRECISION+1] = {
+       INT64CONST(1000000),
+       INT64CONST(100000),
+       INT64CONST(10000),
+       INT64CONST(1000),
+       INT64CONST(100),
+       INT64CONST(10),
+       INT64CONST(1)
+   };
+
+   static const int64 TimeOffsets[MAX_TIMESTAMP_PRECISION+1] = {
+       INT64CONST(-500000),
+       INT64CONST(-50000),
+       INT64CONST(-5000),
+       INT64CONST(-500),
+       INT64CONST(-50),
+       INT64CONST(-5),
+       INT64CONST(0)
+   };
 #else
-       static double TimeScale = 1;
+   static const double TimeScales[MAX_TIMESTAMP_PRECISION+1] = {
+       1,
+       10,
+       100,
+       1000,
+       10000,
+       100000,
+       1000000
+   };
+
+   static const double TimeOffsets[MAX_TIMESTAMP_PRECISION+1] = {
+       0.5,
+       0.05,
+       0.005,
+       0.0005,
+       0.00005,
+       0.000005,
+       0.0000005
+   };
 #endif
-       static int32 TimeTypmod = 0;
 
-       if (typmod != TimeTypmod)
-       {
+   if ((typmod >= 0) && (typmod <= MAX_TIME_PRECISION))
+   {
 #ifdef HAVE_INT64_TIMESTAMP
-           TimeScale = pow(10.0, (MAX_TIME_PRECISION-typmod));
-#else
-           TimeScale = pow(10.0, typmod);
-#endif
-           TimeTypmod = typmod;
+       /* we have different truncation behavior depending on sign */
+       if (*time >= INT64CONST(0))
+       {
+           *time = ((*time / TimeScales[typmod])
+                    * TimeScales[typmod]);
+       }
+       else
+       {
+           *time = (((*time + TimeOffsets[typmod]) / TimeScales[typmod])
+                    * TimeScales[typmod]);
        }
-
-#ifdef HAVE_INT64_TIMESTAMP
-       *time = ((*time / TimeScale) * TimeScale);
-       if (*time >= INT64CONST(86400000000))
-           *time -= INT64CONST(86400000000);
 #else
-       *time = (rint(((double) *time) * TimeScale) / TimeScale);
-
-       if (*time >= 86400)
-           *time -= 86400;
+       /* we have different truncation behavior depending on sign */
+       if (*time >= 0)
+       {
+           *time = (rint(((double) *time) * TimeScales[typmod])
+                    / TimeScales[typmod]);
+       }
+       else
+       {
+           /* Scale and truncate first, then add to help the rounding behavior */
+           *time = (rint((((double) *time) * TimeScales[typmod]) + TimeOffsets[typmod])
+                    / TimeScales[typmod]);
+       }
 #endif
    }
 
@@ -1269,6 +1323,10 @@ timetz_in(PG_FUNCTION_ARGS)
    int         dtype;
    int         ftype[MAXDATEFIELDS];
 
+   if (strlen(str) >= sizeof(lowstr))
+       elog(ERROR, "Bad time with time zone"
+            " external representation (too long) '%s'", str);
+
    if ((ParseDateTime(str, lowstr, field, ftype, MAXDATEFIELDS, &nf) != 0)
      || (DecodeTimeOnly(field, ftype, nf, &dtype, tm, &fsec, &tz) != 0))
        elog(ERROR, "Bad time external representation '%s'", str);

diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 184ad15ff38370476a91eef052c98bc5fc45bea4..2457421a62aa6a9a9894a3b0f0753d0556aba2bf 100644 (file)
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *   $Header: /cvsroot/pgsql/src/backend/utils/adt/datetime.c,v 1.92 2002/06/20 20:29:37 momjian Exp $
+ *   $Header: /cvsroot/pgsql/src/backend/utils/adt/datetime.c,v 1.93 2002/08/04 06:44:47 thomas Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -56,21 +56,31 @@ char       *days[] = {"Sunday", "Monday", "Tuesday", "Wednesday",
  *  PRIVATE ROUTINES                                                        *
  *****************************************************************************/
 
-/* definitions for squeezing values into "value" */
+/*
+ * Definitions for squeezing values into "value"
+ * We set aside a high bit for a sign, and scale the timezone offsets
+ * in minutes by a factor of 15 (so can represent quarter-hour increments).
+ */
 #define ABS_SIGNBIT        ((char) 0200)
 #define VALMASK            ((char) 0177)
+#define POS(n)         (n)
 #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))
+#define FROMVAL(tp)        (-SIGNEDCHAR((tp)->value) * 15) /* uncompress */
+#define TOVAL(tp, v)   ((tp)->value = ((v) < 0? NEG((-(v))/15): POS(v)/15))
 
 /*
  * datetktbl holds date/time keywords. Note that this table must be strictly
  * ordered to allow an O(ln(N)) search algorithm.
  *
+ * The text field is not guaranteed to be NULL-terminated.
+ *
  * 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.
+ * entries by 15 (so they are on 15 minute boundaries) and truncate the text
+ * field at MAXTOKLEN characters.
+ * Formerly, we divided by 10 rather than 15 but there are a few time zones
+ * which are 30 or 45 minutes away from an even hour, most are on an hour
+ * boundary, and none on other boundaries.
  *
  * Let's include all strings from my current zinc time zone database.
  * Not all of them are unique, or even very understandable, so we will
@@ -79,414 +89,415 @@ char     *days[] = {"Sunday", "Monday", "Tuesday", "Wednesday",
 static datetkn datetktbl[] = {
 /* text, token, lexval */
    {EARLY, RESERV, DTK_EARLY}, /* "-infinity" reserved for "early time" */
-   {"acsst", DTZ, 63},         /* Cent. Australia */
-   {"acst", DTZ, NEG(24)},     /* Atlantic/Porto Acre */
-   {"act", TZ, NEG(30)},       /* Atlantic/Porto Acre */
+   {"acsst", DTZ, POS(42)},    /* Cent. Australia */
+   {"acst", DTZ, NEG(16)},     /* Atlantic/Porto Acre */
+   {"act", TZ, NEG(20)},       /* Atlantic/Porto Acre */
    {DA_D, ADBC, AD},           /* "ad" for years >= 0 */
-   {"abstime", IGNORE_DTF, 0},     /* 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 */
-   {"aft", TZ, 27},            /* Kabul */
-   {"ahst", TZ, NEG(60)},      /* Alaska-Hawaii Std Time */
-   {"akdt", DTZ, NEG(48)},     /* Alaska Daylight Time */
-   {"akst", DTZ, NEG(54)},     /* Alaska Standard Time */
-   {"allballs", RESERV, DTK_ZULU},     /* 00:00:00 */
-   {"almt", TZ, 36},           /* Almaty Time */
-   {"almst", TZ, 42},          /* Almaty Savings Time */
+   {"abstime", IGNORE_DTF, 0}, /* for pre-v6.1 "Invalid Abstime" */
+   {"adt", DTZ, NEG(12)},      /* Atlantic Daylight Time */
+   {"aesst", DTZ, POS(44)},    /* E. Australia */
+   {"aest", TZ, POS(40)},      /* Australia Eastern Std Time */
+   {"aft", TZ, POS(18)},       /* Kabul */
+   {"ahst", TZ, NEG(40)},      /* Alaska-Hawaii Std Time */
+   {"akdt", DTZ, NEG(32)},     /* Alaska Daylight Time */
+   {"akst", DTZ, NEG(36)},     /* Alaska Standard Time */
+   {"allballs", RESERV, DTK_ZULU}, /* 00:00:00 */
+   {"almt", TZ, POS(24)},      /* Almaty Time */
+   {"almst", TZ, POS(28)},     /* Almaty Savings Time */
    {"am", AMPM, AM},
-   {"amst", DTZ, 30},          /* Armenia Summer Time (Yerevan) */
-   {"amt", TZ, 24},            /* Armenia Time (Yerevan) */
+   {"amst", DTZ, POS(20)},     /* Armenia Summer Time (Yerevan) */
+   {"amt", TZ, POS(16)},       /* Armenia Time (Yerevan) */
 #if 0
-   {"amst", DTZ, NEG(18)},     /* Porto Velho */
+   {"amst", DTZ, NEG(12)},     /* Porto Velho */
 #endif
-   {"anast", DTZ, 78},         /* Anadyr Summer Time (Russia) */
-   {"anat", TZ, 72},           /* Anadyr Time (Russia) */
+   {"anast", DTZ, POS(52)},    /* Anadyr Summer Time (Russia) */
+   {"anat", TZ, POS(48)},      /* Anadyr Time (Russia) */
 #if 0
 aqtst
 aqtt
 arst
 #endif
-   {"art", TZ, NEG(18)},       /* Argentina Time */
+   {"art", TZ, NEG(12)},       /* Argentina Time */
 #if 0
 ashst
 ast /* Atlantic Standard Time, Arabia Standard Time, Acre Standard Time */
 #endif
    {"apr", MONTH, 4},
    {"april", MONTH, 4},
-   {"ast", TZ, NEG(24)},       /* Atlantic Std Time (Canada) */
-   {"at", IGNORE_DTF, 0},          /* "at" (throwaway) */
+   {"ast", TZ, NEG(16)},       /* Atlantic Std Time (Canada) */
+   {"at", IGNORE_DTF, 0},      /* "at" (throwaway) */
    {"aug", MONTH, 8},
    {"august", MONTH, 8},
-   {"awsst", DTZ, 54},         /* W. Australia */
-   {"awst", TZ, 48},           /* W. Australia */
-   {"awt", DTZ, NEG(18)},
-   {"azost", DTZ, 0},          /* Azores Summer Time */
-   {"azot", TZ, NEG(6)},       /* Azores Time */
-   {"azst", DTZ, 30},          /* Azerbaijan Summer Time */
-   {"azt", TZ, 24},            /* Azerbaijan Time */
+   {"awsst", DTZ, POS(36)},    /* W. Australia */
+   {"awst", TZ, POS(32)},      /* W. Australia */
+   {"awt", DTZ, NEG(12)},
+   {"azost", DTZ, POS(0)},     /* Azores Summer Time */
+   {"azot", TZ, NEG(4)},       /* Azores Time */
+   {"azst", DTZ, POS(20)},     /* Azerbaijan Summer Time */
+   {"azt", TZ, POS(16)},       /* Azerbaijan Time */
    {DB_C, ADBC, BC},           /* "bc" for years < 0 */
-   {"bdst", TZ, 12},           /* British Double Summer Time */
-   {"bdt", TZ, 36},            /* Dacca */
-   {"bnt", TZ, 48},            /* Brunei Darussalam Time */
-   {"bort", TZ, 48},           /* Borneo Time (Indonesia) */
+   {"bdst", TZ, POS(8)},       /* British Double Summer Time */
+   {"bdt", TZ, POS(24)},       /* Dacca */
+   {"bnt", TZ, POS(32)},       /* Brunei Darussalam Time */
+   {"bort", TZ, POS(32)},      /* Borneo Time (Indonesia) */
 #if 0
 bortst
 bost
 #endif
-   {"bot", TZ, NEG(24)},       /* Bolivia Time */
-   {"bra", TZ, NEG(18)},       /* Brazil Time */
+   {"bot", TZ, NEG(16)},       /* Bolivia Time */
+   {"bra", TZ, NEG(12)},       /* Brazil Time */
 #if 0
 brst
 brt
 #endif
-   {"bst", DTZ, 6},            /* British Summer Time */
+   {"bst", DTZ, POS(4)},       /* British Summer Time */
 #if 0
-   {"bst", TZ, NEG(18)},       /* Brazil Standard Time */
-   {"bst", DTZ, NEG(66)},      /* Bering Summer Time */
-#endif
-   {"bt", TZ, 18},             /* Baghdad Time */
-   {"btt", TZ, 36},            /* Bhutan 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 Time */
+   {"bst", TZ, NEG(12)},       /* Brazil Standard Time */
+   {"bst", DTZ, NEG(44)},      /* Bering Summer Time */
+#endif
+   {"bt", TZ, POS(12)},        /* Baghdad Time */
+   {"btt", TZ, POS(24)},       /* Bhutan Time */
+   {"cadt", DTZ, POS(42)},     /* Central Australian DST */
+   {"cast", TZ, POS(38)},      /* Central Australian ST */
+   {"cat", TZ, NEG(40)},       /* Central Alaska Time */
+   {"cct", TZ, POS(32)},       /* China Coast Time */
 #if 0
-   {"cct", TZ, 39},            /* Indian Cocos (Island) Time */
-#endif
-   {"cdt", DTZ, NEG(30)},      /* Central Daylight Time */
-   {"cest", DTZ, 12},          /* Central European Dayl.Time */
-   {"cet", TZ, 6},             /* Central European Time */
-   {"cetdst", DTZ, 12},        /* Central European Dayl.Time */
+   {"cct", TZ, POS(26)},       /* Indian Cocos (Island) Time */
+#endif
+   {"cdt", DTZ, NEG(20)},      /* Central Daylight Time */
+   {"cest", DTZ, POS(8)},      /* Central European Dayl.Time */
+   {"cet", TZ, POS(4)},            /* Central European Time */
+   {"cetdst", DTZ, POS(8)},    /* Central European Dayl.Time */
+   {"chadt", DTZ, POS(55)},        /* Chatham Island Daylight Time (13:45) */
+   {"chast", TZ, POS(51)},     /* Chatham Island Time (12:45) */
 #if 0
-   {"chadt", DTZ, 82},         /* Chatham Island Daylight Time (13:45? set to 13:40) */
-   {"chast", TZ, 76},          /* Chatham Island Time (12:45? set to 12:40) */
 ckhst
 #endif
-   {"ckt", TZ, 72},            /* Cook Islands Time */
-   {"clst", DTZ, NEG(18)},     /* Chile Summer Time */
-   {"clt", TZ, NEG(24)},       /* Chile Time */
+   {"ckt", TZ, POS(48)},       /* Cook Islands Time */
+   {"clst", DTZ, NEG(12)},     /* Chile Summer Time */
+   {"clt", TZ, NEG(16)},       /* Chile Time */
 #if 0
 cost
 #endif
-   {"cot", TZ, NEG(30)},       /* Columbia Time */
-   {"cst", TZ, NEG(36)},       /* Central Standard Time */
+   {"cot", TZ, NEG(20)},       /* Columbia Time */
+   {"cst", TZ, NEG(24)},       /* Central Standard Time */
 #if 0
 cvst
 #endif
-   {"cvt", TZ, 42},            /* Christmas Island Time (Indian Ocean) */
-   {"cxt", TZ, 42},            /* Christmas Island Time (Indian Ocean) */
+   {"cvt", TZ, POS(28)},       /* Christmas Island Time (Indian Ocean) */
+   {"cxt", TZ, POS(28)},       /* Christmas Island Time (Indian Ocean) */
    {DCURRENT, RESERV, DTK_CURRENT},    /* "current" is always now */
    {"d", UNITS, DTK_DAY},      /* "day of month" for ISO input */
-   {"davt", TZ, 42},           /* Davis Time (Antarctica) */
-   {"ddut", TZ, 60},           /* Dumont-d'Urville Time (Antarctica) */
+   {"davt", TZ, POS(28)},      /* Davis Time (Antarctica) */
+   {"ddut", TZ, POS(40)},      /* Dumont-d'Urville Time (Antarctica) */
    {"dec", MONTH, 12},
    {"december", MONTH, 12},
-   {"dnt", TZ, 6},             /* Dansk Normal Tid */
+   {"dnt", TZ, POS(4)},        /* Dansk Normal Tid */
    {"dow", RESERV, DTK_DOW},   /* day of week */
    {"doy", RESERV, DTK_DOY},   /* day of year */
    {"dst", DTZMOD, 6},
 #if 0
-   {"dusst", DTZ, 36},         /* Dushanbe Summer Time */
+   {"dusst", DTZ, POS(24)},    /* Dushanbe Summer Time */
 #endif
-   {"easst", DTZ, NEG(30)},    /* Easter Island Summer Time */
-   {"east", TZ, NEG(36)},      /* Easter Island Time */
-   {"eat", TZ, 18},            /* East Africa Time */
+   {"easst", DTZ, NEG(20)},    /* Easter Island Summer Time */
+   {"east", TZ, NEG(24)},      /* Easter Island Time */
+   {"eat", TZ, POS(12)},       /* East Africa Time */
 #if 0
-   {"east", DTZ, 24},          /* Indian Antananarivo Savings Time */
-   {"eat", TZ, 18},            /* Indian Antananarivo Time */
-   {"ect", TZ, NEG(24)},       /* Eastern Caribbean Time */
-   {"ect", TZ, NEG(30)},       /* Ecuador Time */
-#endif
-   {"edt", DTZ, NEG(24)},      /* Eastern Daylight Time */
-   {"eest", DTZ, 18},          /* Eastern Europe Summer Time */
-   {"eet", TZ, 12},            /* East. Europe, USSR Zone 1 */
-   {"eetdst", DTZ, 18},        /* Eastern Europe Daylight Time */
-   {"egst", DTZ, 0},           /* East Greenland Summer Time */
-   {"egt", TZ, NEG(6)},        /* East Greenland Time */
+   {"east", DTZ, POS(16)},     /* Indian Antananarivo Savings Time */
+   {"eat", TZ, POS(12)},       /* Indian Antananarivo Time */
+   {"ect", TZ, NEG(16)},       /* Eastern Caribbean Time */
+   {"ect", TZ, NEG(20)},       /* Ecuador Time */
+#endif
+   {"edt", DTZ, NEG(16)},      /* Eastern Daylight Time */
+   {"eest", DTZ, POS(12)},     /* Eastern Europe Summer Time */
+   {"eet", TZ, POS(8)},        /* East. Europe, USSR Zone 1 */
+   {"eetdst", DTZ, POS(12)},   /* Eastern Europe Daylight Time */
+   {"egst", DTZ, POS(0)},      /* East Greenland Summer Time */
+   {"egt", TZ, NEG(4)},        /* East Greenland Time */
 #if 0
 ehdt
 #endif
    {EPOCH, RESERV, DTK_EPOCH}, /* "epoch" reserved for system epoch time */
-   {"est", TZ, NEG(30)},       /* Eastern Standard Time */
+   {"est", TZ, NEG(20)},       /* Eastern Standard Time */
    {"feb", MONTH, 2},
    {"february", MONTH, 2},
-   {"fjst", DTZ, NEG(78)},     /* Fiji Summer Time (13 hour offset!) */
-   {"fjt", TZ, NEG(72)},       /* Fiji Time */
-   {"fkst", DTZ, NEG(18)},     /* Falkland Islands Summer Time */
-   {"fkt", TZ, NEG(12)},       /* Falkland Islands Time */
+   {"fjst", DTZ, NEG(52)},     /* Fiji Summer Time (13 hour offset!) */
+   {"fjt", TZ, NEG(48)},       /* Fiji Time */
+   {"fkst", DTZ, NEG(12)},     /* Falkland Islands Summer Time */
+   {"fkt", TZ, NEG(8)},        /* Falkland Islands Time */
 #if 0
 fnst
 fnt
 #endif
    {"fri", DOW, 5},
    {"friday", DOW, 5},
-   {"fst", TZ, 6},             /* French Summer Time */
-   {"fwt", DTZ, 12},           /* French Winter Time  */
-   {"galt", TZ, NEG(36)},      /* Galapagos Time */
-   {"gamt", TZ, NEG(54)},      /* Gambier Time */
-   {"gest", DTZ, 30},          /* Georgia Summer Time */
-   {"get", TZ, 24},            /* Georgia Time */
-   {"gft", TZ, NEG(18)},       /* French Guiana Time */
+   {"fst", TZ, POS(4)},        /* French Summer Time */
+   {"fwt", DTZ, POS(8)},       /* French Winter Time  */
+   {"galt", TZ, NEG(24)},      /* Galapagos Time */
+   {"gamt", TZ, NEG(36)},      /* Gambier Time */
+   {"gest", DTZ, POS(20)},     /* Georgia Summer Time */
+   {"get", TZ, POS(16)},       /* Georgia Time */
+   {"gft", TZ, NEG(12)},       /* French Guiana Time */
 #if 0
 ghst
 #endif
-   {"gilt", TZ, 72},           /* Gilbert Islands Time */
-   {"gmt", TZ, 0},             /* Greenwish Mean Time */
-   {"gst", TZ, 60},            /* Guam Std Time, USSR Zone 9 */
-   {"gyt", TZ, NEG(24)},       /* Guyana Time */
+   {"gilt", TZ, POS(48)},      /* Gilbert Islands Time */
+   {"gmt", TZ, POS(0)},        /* Greenwish Mean Time */
+   {"gst", TZ, POS(40)},       /* Guam Std Time, USSR Zone 9 */
+   {"gyt", TZ, NEG(16)},       /* Guyana Time */
    {"h", UNITS, DTK_HOUR},     /* "hour" */
 #if 0
 hadt
 hast
 #endif
-   {"hdt", DTZ, NEG(54)},      /* Hawaii/Alaska Daylight Time */
+   {"hdt", DTZ, NEG(36)},      /* Hawaii/Alaska Daylight Time */
 #if 0
 hkst
 #endif
-   {"hkt", TZ, 48},            /* Hong Kong Time */
+   {"hkt", TZ, POS(32)},       /* Hong Kong Time */
 #if 0
-   {"hmt", TZ, 18},            /* Hellas ? ? */
+   {"hmt", TZ, POS(12)},       /* Hellas ? ? */
 hovst
 hovt
 #endif
-   {"hst", TZ, NEG(60)},       /* Hawaii Std Time */
+   {"hst", TZ, NEG(40)},       /* Hawaii Std Time */
 #if 0
 hwt
 #endif
-   {"ict", TZ, 42},            /* Indochina Time */
-   {"idle", TZ, 72},           /* Intl. Date Line, East */
-   {"idlw", TZ, NEG(72)},      /* Intl. Date Line, West */
+   {"ict", TZ, POS(28)},       /* Indochina Time */
+   {"idle", TZ, POS(48)},      /* Intl. Date Line, East */
+   {"idlw", TZ, NEG(48)},      /* Intl. Date Line, West */
 #if 0
 idt /* Israeli, Iran, Indian Daylight Time */
 #endif
    {LATE, RESERV, DTK_LATE},   /* "infinity" reserved for "late time" */
    {INVALID, RESERV, DTK_INVALID}, /* "invalid" reserved for bad time */
-   {"iot", TZ, 30},            /* Indian Chagos Time */
-   {"irkst", DTZ, 54},         /* Irkutsk Summer Time */
-   {"irkt", TZ, 48},           /* Irkutsk Time */
-   {"irt", TZ, 21},            /* Iran Time */
+   {"iot", TZ, POS(20)},       /* Indian Chagos Time */
+   {"irkst", DTZ, POS(36)},    /* Irkutsk Summer Time */
+   {"irkt", TZ, POS(32)},      /* Irkutsk Time */
+   {"irt", TZ, POS(14)},       /* Iran Time */
 #if 0
 isst
 #endif
-   {"ist", TZ, 12},            /* Israel */
-   {"it", TZ, 21},             /* Iran Time */
+   {"ist", TZ, POS(8)},        /* Israel */
+   {"it", TZ, POS(14)},        /* Iran Time */
    {"j", UNITS, DTK_JULIAN},
    {"jan", MONTH, 1},
    {"january", MONTH, 1},
-   {"javt", TZ, 42},           /* Java Time (07:00? see JT) */
-   {"jayt", TZ, 54},           /* Jayapura Time (Indonesia) */
+   {"javt", TZ, POS(28)},      /* Java Time (07:00? see JT) */
+   {"jayt", TZ, POS(36)},      /* Jayapura Time (Indonesia) */
    {"jd", UNITS, DTK_JULIAN},
-   {"jst", TZ, 54},            /* Japan Std Time,USSR Zone 8 */
-   {"jt", TZ, 45},             /* Java Time (07:30? see JAVT) */
+   {"jst", TZ, POS(36)},       /* Japan Std Time,USSR Zone 8 */
+   {"jt", TZ, POS(30)},        /* Java Time (07:30? see JAVT) */
    {"jul", MONTH, 7},
    {"julian", UNITS, DTK_JULIAN},
    {"july", MONTH, 7},
    {"jun", MONTH, 6},
    {"june", MONTH, 6},
-   {"kdt", DTZ, 60},           /* Korea Daylight Time */
-   {"kgst", DTZ, 36},          /* Kyrgyzstan Summer Time */
-   {"kgt", TZ, 30},            /* Kyrgyzstan Time */
-   {"kost", TZ, 72},           /* Kosrae Time */
-   {"krast", DTZ, 42},         /* Krasnoyarsk Summer Time */
-   {"krat", TZ, 48},           /* Krasnoyarsk Standard Time */
-   {"kst", TZ, 54},            /* Korea Standard Time */
-   {"lhdt", DTZ, 66},          /* Lord Howe Daylight Time, Australia */
-   {"lhst", TZ, 63},           /* Lord Howe Standard Time, Australia */
-   {"ligt", TZ, 60},           /* From Melbourne, Australia */
-   {"lint", TZ, 84},           /* Line Islands Time (Kiribati; +14 hours!) */
-   {"lkt", TZ, 36},            /* Lanka Time */
+   {"kdt", DTZ, POS(40)},      /* Korea Daylight Time */
+   {"kgst", DTZ, POS(24)},     /* Kyrgyzstan Summer Time */
+   {"kgt", TZ, POS(20)},       /* Kyrgyzstan Time */
+   {"kost", TZ, POS(48)},      /* Kosrae Time */
+   {"krast", DTZ, POS(28)},    /* Krasnoyarsk Summer Time */
+   {"krat", TZ, POS(32)},      /* Krasnoyarsk Standard Time */
+   {"kst", TZ, POS(36)},       /* Korea Standard Time */
+   {"lhdt", DTZ, POS(44)},     /* Lord Howe Daylight Time, Australia */
+   {"lhst", TZ, POS(42)},      /* Lord Howe Standard Time, Australia */
+   {"ligt", TZ, POS(40)},      /* From Melbourne, Australia */
+   {"lint", TZ, POS(56)},      /* Line Islands Time (Kiribati; +14 hours!) */
+   {"lkt", TZ, POS(24)},       /* Lanka Time */
    {"m", UNITS, DTK_MONTH},    /* "month" for ISO input */
-   {"magst", DTZ, 72},         /* Magadan Summer Time */
-   {"magt", TZ, 66},           /* Magadan Time */
+   {"magst", DTZ, POS(48)},    /* Magadan Summer Time */
+   {"magt", TZ, POS(44)},      /* Magadan Time */
    {"mar", MONTH, 3},
    {"march", MONTH, 3},
-   {"mart", TZ, NEG(57)},      /* Marquesas Time */
-   {"mawt", TZ, 36},           /* Mawson, Antarctica */
+   {"mart", TZ, NEG(38)},      /* Marquesas Time */
+   {"mawt", TZ, POS(24)},      /* Mawson, Antarctica */
    {"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 */
-   {"mht", TZ, 72},            /* Kwajalein */
+   {"mdt", DTZ, NEG(24)},      /* Mountain Daylight Time */
+   {"mest", DTZ, POS(8)},      /* Middle Europe Summer Time */
+   {"met", TZ, POS(4)},        /* Middle Europe Time */
+   {"metdst", DTZ, POS(8)},    /* Middle Europe Daylight Time */
+   {"mewt", TZ, POS(4)},       /* Middle Europe Winter Time */
+   {"mez", TZ, POS(4)},        /* Middle Europe Zone */
+   {"mht", TZ, POS(48)},       /* Kwajalein */
    {"mm", UNITS, DTK_MINUTE},  /* "minute" for ISO input */
-   {"mmt", TZ, 39},            /* Myannar Time */
+   {"mmt", TZ, POS(26)},       /* Myannar Time */
    {"mon", DOW, 1},
    {"monday", DOW, 1},
 #if 0
 most
 #endif
-   {"mpt", TZ, 60},            /* North Mariana Islands Time */
-   {"msd", DTZ, 24},           /* Moscow Summer Time */
-   {"msk", TZ, 18},            /* Moscow Time */
-   {"mst", TZ, NEG(42)},       /* Mountain Standard Time */
-   {"mt", TZ, 51},             /* Moluccas Time */
-   {"mut", TZ, 24},            /* Mauritius Island Time */
-   {"mvt", TZ, 30},            /* Maldives Island Time */
-   {"myt", TZ, 48},            /* Malaysia Time */
+   {"mpt", TZ, POS(40)},       /* North Mariana Islands Time */
+   {"msd", DTZ, POS(16)},      /* Moscow Summer Time */
+   {"msk", TZ, POS(12)},       /* Moscow Time */
+   {"mst", TZ, NEG(28)},       /* Mountain Standard Time */
+   {"mt", TZ, POS(34)},        /* Moluccas Time */
+   {"mut", TZ, POS(16)},       /* Mauritius Island Time */
+   {"mvt", TZ, POS(20)},       /* Maldives Island Time */
+   {"myt", TZ, POS(32)},       /* Malaysia Time */
 #if 0
 ncst
 #endif
-   {"nct", TZ, 66},            /* New Caledonia Time */
-   {"ndt", DTZ, NEG(15)},      /* Nfld. Daylight Time */
-   {"nft", TZ, NEG(21)},       /* Newfoundland Standard Time */
-   {"nor", TZ, 6},             /* Norway Standard Time */
+   {"nct", TZ, POS(44)},       /* New Caledonia Time */
+   {"ndt", DTZ, NEG(10)},      /* Nfld. Daylight Time */
+   {"nft", TZ, NEG(14)},       /* Newfoundland Standard Time */
+   {"nor", TZ, POS(4)},        /* Norway Standard Time */
    {"nov", MONTH, 11},
    {"november", MONTH, 11},
-   {"novst", DTZ, 42},         /* Novosibirsk Summer Time */
-   {"novt", TZ, 36},           /* Novosibirsk Standard Time */
+   {"novst", DTZ, POS(28)},    /* Novosibirsk Summer Time */
+   {"novt", TZ, POS(24)},      /* Novosibirsk Standard Time */
    {NOW, RESERV, DTK_NOW},     /* current transaction time */
-   {"nst", TZ, NEG(21)},       /* Nfld. Standard Time */
-   {"nt", TZ, NEG(66)},        /* Nome Time */
-   {"nut", TZ, NEG(66)},       /* Niue Time */
-   {"nzdt", DTZ, 78},          /* New Zealand Daylight Time */
-   {"nzst", TZ, 72},           /* New Zealand Standard Time */
-   {"nzt", TZ, 72},            /* New Zealand Time */
+   {"npt", TZ, POS(23)},       /* Nepal Standard Time (GMT-5:45) */
+   {"nst", TZ, NEG(14)},       /* Nfld. Standard Time */
+   {"nt", TZ, NEG(44)},        /* Nome Time */
+   {"nut", TZ, NEG(44)},       /* Niue Time */
+   {"nzdt", DTZ, POS(52)},     /* New Zealand Daylight Time */
+   {"nzst", TZ, POS(48)},      /* New Zealand Standard Time */
+   {"nzt", TZ, POS(48)},       /* New Zealand Time */
    {"oct", MONTH, 10},
    {"october", MONTH, 10},
-   {"omsst", DTZ, 42},         /* Omsk Summer Time */
-   {"omst", TZ, 36},           /* Omsk Time */
-   {"on", IGNORE_DTF, 0},          /* "on" (throwaway) */
-   {"pdt", DTZ, NEG(42)},      /* Pacific Daylight Time */
+   {"omsst", DTZ, POS(28)},    /* Omsk Summer Time */
+   {"omst", TZ, POS(24)},      /* Omsk Time */
+   {"on", IGNORE_DTF, 0},      /* "on" (throwaway) */
+   {"pdt", DTZ, NEG(28)},      /* Pacific Daylight Time */
 #if 0
 pest
 #endif
-   {"pet", TZ, NEG(30)},       /* Peru Time */
-   {"petst", DTZ, 78},         /* Petropavlovsk-Kamchatski Summer Time */
-   {"pett", TZ, 72},           /* Petropavlovsk-Kamchatski Time */
-   {"pgt", TZ, 60},            /* Papua New Guinea Time */
-   {"phot", TZ, 78},           /* Phoenix Islands (Kiribati) Time */
+   {"pet", TZ, NEG(20)},       /* Peru Time */
+   {"petst", DTZ, POS(52)},    /* Petropavlovsk-Kamchatski Summer Time */
+   {"pett", TZ, POS(48)},      /* Petropavlovsk-Kamchatski Time */
+   {"pgt", TZ, POS(40)},       /* Papua New Guinea Time */
+   {"phot", TZ, POS(52)},      /* Phoenix Islands (Kiribati) Time */
 #if 0
 phst
 #endif
-   {"pht", TZ, 48},            /* Phillipine Time */
-   {"pkt", TZ, 30},            /* Pakistan Time */
+   {"pht", TZ, POS(32)},       /* Phillipine Time */
+   {"pkt", TZ, POS(20)},       /* Pakistan Time */
    {"pm", AMPM, PM},
-   {"pmdt", DTZ, NEG(12)},     /* Pierre & Miquelon Daylight Time */
+   {"pmdt", DTZ, NEG(8)},      /* Pierre & Miquelon Daylight Time */
 #if 0
 pmst
 #endif
-   {"pont", TZ, 66},           /* Ponape Time (Micronesia) */
-   {"pst", TZ, NEG(48)},       /* Pacific Standard Time */
-   {"pwt", TZ, 54},            /* Palau Time */
-   {"pyst", DTZ, NEG(18)},     /* Paraguay Summer Time */
-   {"pyt", TZ, NEG(24)},       /* Paraguay Time */
-   {"ret", DTZ, 24},           /* Reunion Island Time */
+   {"pont", TZ, POS(44)},      /* Ponape Time (Micronesia) */
+   {"pst", TZ, NEG(32)},       /* Pacific Standard Time */
+   {"pwt", TZ, POS(36)},       /* Palau Time */
+   {"pyst", DTZ, NEG(12)},     /* Paraguay Summer Time */
+   {"pyt", TZ, NEG(16)},       /* Paraguay Time */
+   {"ret", DTZ, POS(16)},      /* Reunion Island Time */
    {"s", UNITS, DTK_SECOND},   /* "seconds" for ISO input */
-   {"sadt", DTZ, 63},          /* S. Australian Dayl. Time */
+   {"sadt", DTZ, POS(42)},     /* S. Australian Dayl. Time */
 #if 0
 samst
 samt
 #endif
-   {"sast", TZ, 57},           /* South Australian Std Time */
+   {"sast", TZ, POS(38)},      /* South Australian Std Time */
    {"sat", DOW, 6},
    {"saturday", DOW, 6},
 #if 0
 sbt
 #endif
-   {"sct", DTZ, 24},           /* Mahe Island Time */
+   {"sct", DTZ, POS(16)},      /* Mahe Island Time */
    {"sep", MONTH, 9},
    {"sept", MONTH, 9},
    {"september", MONTH, 9},
-   {"set", TZ, NEG(6)},        /* Seychelles Time ?? */
+   {"set", TZ, NEG(4)},        /* Seychelles Time ?? */
 #if 0
 sgt
 #endif
-   {"sst", DTZ, 12},           /* Swedish Summer Time */
+   {"sst", DTZ, POS(8)},       /* Swedish Summer Time */
    {"sun", DOW, 0},
    {"sunday", DOW, 0},
-   {"swt", TZ, 6},             /* Swedish Winter Time  */
+   {"swt", TZ, POS(4)},        /* Swedish Winter Time */
 #if 0
 syot
 #endif
    {"t", ISOTIME, DTK_TIME},   /* Filler for ISO time fields */
-   {"that", TZ, NEG(60)},      /* Tahiti Time */
-   {"tft", TZ, 30},            /* Kerguelen Time */
+   {"that", TZ, NEG(40)},      /* Tahiti Time */
+   {"tft", TZ, POS(20)},       /* Kerguelen Time */
    {"thu", DOW, 4},
    {"thur", DOW, 4},
    {"thurs", DOW, 4},
    {"thursday", DOW, 4},
-   {"tjt", TZ, 30},            /* Tajikistan Time */
-   {"tkt", TZ, NEG(60)},       /* Tokelau Time */
-   {"tmt", TZ, 30},            /* Turkmenistan Time */
+   {"tjt", TZ, POS(20)},       /* Tajikistan Time */
+   {"tkt", TZ, NEG(40)},       /* Tokelau Time */
+   {"tmt", TZ, POS(20)},       /* Turkmenistan Time */
    {TODAY, RESERV, DTK_TODAY}, /* midnight */
    {TOMORROW, RESERV, DTK_TOMORROW},   /* tomorrow midnight */
 #if 0
 tost
 #endif
-   {"tot", TZ, 78},            /* Tonga Time */
+   {"tot", TZ, POS(52)},       /* Tonga Time */
 #if 0
 tpt
 #endif
-   {"truk", TZ, 60},           /* Truk Time */
+   {"truk", TZ, POS(40)},      /* Truk Time */
    {"tue", DOW, 2},
    {"tues", DOW, 2},
    {"tuesday", DOW, 2},
-   {"tvt", TZ, 72},            /* Tuvalu Time */
+   {"tvt", TZ, POS(48)},       /* Tuvalu Time */
 #if 0
 uct
 #endif
-   {"ulast", DTZ, 54},         /* Ulan Bator Summer Time */
-   {"ulat", TZ, 48},           /* Ulan Bator Time */
+   {"ulast", DTZ, POS(36)},    /* Ulan Bator Summer Time */
+   {"ulat", TZ, POS(32)},      /* Ulan Bator Time */
    {"undefined", RESERV, DTK_INVALID}, /* pre-v6.1 invalid time */
-   {"ut", TZ, 0},
-   {"utc", TZ, 0},
-   {"uyst", DTZ, NEG(12)},     /* Uruguay Summer Time */
-   {"uyt", TZ, NEG(18)},       /* Uruguay Time */
-   {"uzst", DTZ, 36},          /* Uzbekistan Summer Time */
-   {"uzt", TZ, 30},            /* Uzbekistan Time */
-   {"vet", TZ, NEG(24)},       /* Venezuela Time */
-   {"vlast", DTZ, 66},         /* Vladivostok Summer Time */
-   {"vlat", TZ, 60},           /* Vladivostok Time */
+   {"ut", TZ, POS(0)},
+   {"utc", TZ, POS(0)},
+   {"uyst", DTZ, NEG(8)},      /* Uruguay Summer Time */
+   {"uyt", TZ, NEG(12)},       /* Uruguay Time */
+   {"uzst", DTZ, POS(24)},     /* Uzbekistan Summer Time */
+   {"uzt", TZ, POS(20)},       /* Uzbekistan Time */
+   {"vet", TZ, NEG(16)},       /* Venezuela Time */
+   {"vlast", DTZ, POS(44)},    /* Vladivostok Summer Time */
+   {"vlat", TZ, POS(40)},      /* Vladivostok Time */
 #if 0
 vust
 #endif
-   {"vut", TZ, 66},            /* Vanuata Time */
-   {"wadt", DTZ, 48},          /* West Australian DST */
-   {"wakt", TZ, 72},           /* Wake Time */
+   {"vut", TZ, POS(44)},       /* Vanuata Time */
+   {"wadt", DTZ, POS(32)},     /* West Australian DST */
+   {"wakt", TZ, POS(48)},      /* Wake Time */
 #if 0
 warst
 #endif
-   {"wast", TZ, 42},           /* West Australian Std Time */
-   {"wat", TZ, NEG(6)},        /* West Africa Time */
-   {"wdt", DTZ, 54},           /* West Australian DST */
+   {"wast", TZ, POS(28)},      /* West Australian Std Time */
+   {"wat", TZ, NEG(4)},        /* West Africa Time */
+   {"wdt", DTZ, POS(36)},      /* West Australian DST */
    {"wed", DOW, 3},
    {"wednesday", DOW, 3},
    {"weds", DOW, 3},
-   {"west", DTZ, 6},           /* Western Europe Summer Time */
-   {"wet", TZ, 0},             /* Western Europe */
-   {"wetdst", DTZ, 6},         /* Western Europe Daylight Savings Time */
-   {"wft", TZ, 72},            /* Wallis and Futuna Time */
-   {"wgst", DTZ, NEG(12)},     /* West Greenland Summer Time */
-   {"wgt", TZ, NEG(18)},       /* West Greenland Time */
-   {"wst", TZ, 48},            /* West Australian Standard Time */
+   {"west", DTZ, POS(4)},      /* Western Europe Summer Time */
+   {"wet", TZ, POS(0)},        /* Western Europe */
+   {"wetdst", DTZ, POS(4)},    /* Western Europe Daylight Savings Time */
+   {"wft", TZ, POS(48)},       /* Wallis and Futuna Time */
+   {"wgst", DTZ, NEG(8)},      /* West Greenland Summer Time */
+   {"wgt", TZ, NEG(12)},       /* West Greenland Time */
+   {"wst", TZ, POS(32)},       /* West Australian Standard Time */
    {"y", UNITS, DTK_YEAR},     /* "year" for ISO input */
-   {"yakst", DTZ, 60},         /* Yakutsk Summer Time */
-   {"yakt", TZ, 54},           /* Yakutsk Time */
-   {"yapt", TZ, 60},           /* Yap Time (Micronesia) */
-   {"ydt", DTZ, NEG(48)},      /* Yukon Daylight Time */
-   {"yekst", DTZ, 36},         /* Yekaterinburg Summer Time */
-   {"yekt", TZ, 30},           /* Yekaterinburg Time */
+   {"yakst", DTZ, POS(40)},    /* Yakutsk Summer Time */
+   {"yakt", TZ, POS(36)},      /* Yakutsk Time */
+   {"yapt", TZ, POS(40)},      /* Yap Time (Micronesia) */
+   {"ydt", DTZ, NEG(32)},      /* Yukon Daylight Time */
+   {"yekst", DTZ, POS(24)},    /* Yekaterinburg Summer Time */
+   {"yekt", TZ, POS(20)},      /* Yekaterinburg Time */
    {YESTERDAY, RESERV, DTK_YESTERDAY}, /* yesterday midnight */
-   {"yst", TZ, NEG(54)},       /* Yukon Standard Time */
-   {"z", TZ, 0},               /* time zone tag per ISO-8601 */
-   {"zp4", TZ, NEG(24)},       /* UTC +4  hours. */
-   {"zp5", TZ, NEG(30)},       /* UTC +5  hours. */
-   {"zp6", TZ, NEG(36)},       /* UTC +6  hours. */
-   {ZULU, TZ, 0},              /* UTC */
+   {"yst", TZ, NEG(36)},       /* Yukon Standard Time */
+   {"z", TZ, POS(0)},          /* time zone tag per ISO-8601 */
+   {"zp4", TZ, NEG(16)},       /* UTC +4  hours. */
+   {"zp5", TZ, NEG(20)},       /* UTC +5  hours. */
+   {"zp6", TZ, NEG(24)},       /* UTC +6  hours. */
+   {ZULU, TZ, POS(0)},         /* UTC */
 };
 
 static unsigned int szdatetktbl = sizeof datetktbl / sizeof datetktbl[0];
 
 /* Used for SET australian_timezones to override North American ones */
 static datetkn australian_datetktbl[] = {
-   {"acst", TZ, 57},           /* Cent. Australia */
-   {"cst", TZ, 63},            /* Australia Central Std Time */
-   {"east", TZ, 60},           /* East Australian Std Time */
-   {"est", TZ, 60},            /* Australia Eastern Std Time */
-   {"sat", TZ, 57},
+   {"acst", TZ, POS(38)},      /* Cent. Australia */
+   {"cst", TZ, POS(42)},       /* Australia Central Std Time */
+   {"east", TZ, POS(40)},      /* East Australian Std Time */
+   {"est", TZ, POS(40)},       /* Australia Eastern Std Time */
+   {"sat", TZ, POS(38)},
 };
 
 static unsigned int australian_szdatetktbl = sizeof australian_datetktbl /
@@ -494,7 +505,7 @@ sizeof australian_datetktbl[0];
 
 static datetkn deltatktbl[] = {
    /* text, token, lexval */
-   {"@", IGNORE_DTF, 0},           /* postgres relative prefix */
+   {"@", IGNORE_DTF, 0},       /* postgres relative prefix */
    {DAGO, AGO, 0},             /* "ago" indicates negative time offset */
    {"c", UNITS, DTK_CENTURY},  /* "century" relative */
    {"cent", UNITS, DTK_CENTURY},       /* "century" relative */
@@ -505,22 +516,22 @@ static datetkn deltatktbl[] = {
    {"days", UNITS, DTK_DAY},   /* "days" relative */
    {"dec", UNITS, DTK_DECADE}, /* "decade" relative */
    {"decs", UNITS, DTK_DECADE},    /* "decades" relative */
-   {DDECADE, UNITS, DTK_DECADE},       /* "decade" relative */
-   {"decades", UNITS, DTK_DECADE},     /* "decades" relative */
+   {DDECADE, UNITS, DTK_DECADE},   /* "decade" relative */
+   {"decades", UNITS, DTK_DECADE}, /* "decades" relative */
    {"h", UNITS, DTK_HOUR},     /* "hour" relative */
    {DHOUR, UNITS, DTK_HOUR},   /* "hour" relative */
    {"hours", UNITS, DTK_HOUR}, /* "hours" relative */
    {"hr", UNITS, DTK_HOUR},    /* "hour" relative */
    {"hrs", UNITS, DTK_HOUR},   /* "hours" relative */
-   {INVALID, RESERV, DTK_INVALID},     /* reserved for invalid time */
+   {INVALID, RESERV, DTK_INVALID}, /* reserved for invalid time */
    {"m", UNITS, DTK_MINUTE},   /* "minute" relative */
-   {"microsecon", UNITS, DTK_MICROSEC},        /* "microsecond" relative */
-   {"mil", UNITS, DTK_MILLENNIUM},     /* "millennium" relative */
-   {"millennia", UNITS, DTK_MILLENNIUM},       /* "millennia" relative */
-   {DMILLENNIUM, UNITS, DTK_MILLENNIUM},       /* "millennium" relative */
-   {"millisecon", UNITS, DTK_MILLISEC},        /* relative */
-   {"mils", UNITS, DTK_MILLENNIUM},    /* "millennia" relative */
-   {"min", UNITS, DTK_MINUTE}, /* "minute" relative */
+   {"microsecon", UNITS, DTK_MICROSEC},    /* "microsecond" relative */
+   {"mil", UNITS, DTK_MILLENNIUM},         /* "millennium" relative */
+   {"millennia", UNITS, DTK_MILLENNIUM},   /* "millennia" relative */
+   {DMILLENNIUM, UNITS, DTK_MILLENNIUM},   /* "millennium" relative */
+   {"millisecon", UNITS, DTK_MILLISEC},    /* relative */
+   {"mils", UNITS, DTK_MILLENNIUM},        /* "millennia" relative */
+   {"min", UNITS, DTK_MINUTE},     /* "minute" relative */
    {"mins", UNITS, DTK_MINUTE},    /* "minutes" relative */
    {"mins", UNITS, DTK_MINUTE},    /* "minutes" relative */
    {DMINUTE, UNITS, DTK_MINUTE},       /* "minute" relative */
@@ -535,19 +546,19 @@ static datetkn deltatktbl[] = {
    {"mseconds", UNITS, DTK_MILLISEC},
    {"msecs", UNITS, DTK_MILLISEC},
    {"qtr", UNITS, DTK_QUARTER},    /* "quarter" relative */
-   {DQUARTER, UNITS, DTK_QUARTER},     /* "quarter" relative */
+   {DQUARTER, UNITS, DTK_QUARTER}, /* "quarter" relative */
    {"reltime", IGNORE_DTF, 0},     /* 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 */
+   {DTIMEZONE, UNITS, DTK_TZ},     /* "timezone" time offset */
    {"timezone", UNITS, DTK_TZ},    /* "timezone" time offset */
    {"timezone_h", UNITS, DTK_TZ_HOUR}, /* timezone hour units */
-   {"timezone_m", UNITS, DTK_TZ_MINUTE},       /* timezone minutes units */
+   {"timezone_m", UNITS, DTK_TZ_MINUTE},   /* timezone minutes units */
    {"undefined", RESERV, DTK_INVALID}, /* pre-v6.1 invalid time */
-   {"us", UNITS, DTK_MICROSEC},    /* "microsecond" relative */
+   {"us", UNITS, DTK_MICROSEC},        /* "microsecond" relative */
    {"usec", UNITS, DTK_MICROSEC},      /* "microsecond" relative */
    {DMICROSEC, UNITS, DTK_MICROSEC},   /* "microsecond" relative */
    {"useconds", UNITS, DTK_MICROSEC},  /* "microseconds" relative */

diff --git a/src/backend/utils/adt/format_type.c b/src/backend/utils/adt/format_type.c
index 5a5b7b491ae89cf7e6b0dbcc3805761b4fc15bb6..e3d78f1f90818890c444b9315dc23699c88fa491 100644 (file)
--- a/src/backend/utils/adt/format_type.c
+++ b/src/backend/utils/adt/format_type.c
@@ -8,7 +8,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *   $Header: /cvsroot/pgsql/src/backend/utils/adt/format_type.c,v 1.30 2002/06/20 20:29:37 momjian Exp $
+ *   $Header: /cvsroot/pgsql/src/backend/utils/adt/format_type.c,v 1.31 2002/08/04 06:44:47 thomas Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -29,9 +29,6 @@
 #include "mb/pg_wchar.h"
 #endif
 
-
-#define MASK(b) (1 << (b))
-
 #define MAX_INT32_LEN 11
 #define _textin(str) DirectFunctionCall1(textin, CStringGetDatum(str))
 
@@ -258,52 +255,63 @@ format_type_internal(Oid type_oid, int32 typemod,
        case INTERVALOID:
            if (with_typemod)
            {
-               int         fields = typemod >> 16;
-               int         precision = typemod & 0xFFFF;
+               int         fields = INTERVAL_RANGE(typemod);
+               int         precision = INTERVAL_PRECISION(typemod);
                const char *fieldstr;
 
                switch (fields)
                {
-                   case MASK(YEAR):
+                   case INTERVAL_MASK(YEAR):
                        fieldstr = " year";
                        break;
-                   case MASK(MONTH):
+                   case INTERVAL_MASK(MONTH):
                        fieldstr = " month";
                        break;
-                   case MASK(DAY):
+                   case INTERVAL_MASK(DAY):
                        fieldstr = " day";
                        break;
-                   case MASK(HOUR):
+                   case INTERVAL_MASK(HOUR):
                        fieldstr = " hour";
                        break;
-                   case MASK(MINUTE):
+                   case INTERVAL_MASK(MINUTE):
                        fieldstr = " minute";
                        break;
-                   case MASK(SECOND):
+                   case INTERVAL_MASK(SECOND):
                        fieldstr = " second";
                        break;
-                   case MASK(YEAR) | MASK(MONTH):
+                   case INTERVAL_MASK(YEAR)
+                     | INTERVAL_MASK(MONTH):
                        fieldstr = " year to month";
                        break;
-                   case MASK(DAY) | MASK(HOUR):
+                   case INTERVAL_MASK(DAY)
+                     | INTERVAL_MASK(HOUR):
                        fieldstr = " day to hour";
                        break;
-                   case MASK(DAY) | MASK(HOUR) | MASK(MINUTE):
+                   case INTERVAL_MASK(DAY)
+                     | INTERVAL_MASK(HOUR)
+                     | INTERVAL_MASK(MINUTE):
                        fieldstr = " day to minute";
                        break;
-                   case MASK(DAY) | MASK(HOUR) | MASK(MINUTE) | MASK(SECOND):
+                   case INTERVAL_MASK(DAY)
+                     | INTERVAL_MASK(HOUR)
+                     | INTERVAL_MASK(MINUTE)
+                     | INTERVAL_MASK(SECOND):
                        fieldstr = " day to second";
                        break;
-                   case MASK(HOUR) | MASK(MINUTE):
+                   case INTERVAL_MASK(HOUR)
+                     | INTERVAL_MASK(MINUTE):
                        fieldstr = " hour to minute";
                        break;
-                   case MASK(HOUR) | MASK(MINUTE) | MASK(SECOND):
+                   case INTERVAL_MASK(HOUR)
+                     | INTERVAL_MASK(MINUTE)
+                     | INTERVAL_MASK(SECOND):
                        fieldstr = " hour to second";
                        break;
-                   case MASK(MINUTE) | MASK(SECOND):
+                   case INTERVAL_MASK(MINUTE)
+                     | INTERVAL_MASK(SECOND):
                        fieldstr = " minute to second";
                        break;
-                   case 0x7FFF:
+                   case INTERVAL_FULL_RANGE:
                        fieldstr = "";
                        break;
                    default:
@@ -311,7 +319,7 @@ format_type_internal(Oid type_oid, int32 typemod,
                        fieldstr = "";
                        break;
                }
-               if (precision != 0xFFFF)
+               if (precision != INTERVAL_FULL_PRECISION)
                    buf = psnprintf(100, "interval(%d)%s",
                                    precision, fieldstr);
                else

diff --git a/src/backend/utils/adt/nabstime.c b/src/backend/utils/adt/nabstime.c
index fdb144f0e940bec313c86eb5820cb78d4ae80b14..d2e73d1d5e516a4fb16925abd02d6528ff7df031 100644 (file)
--- a/src/backend/utils/adt/nabstime.c
+++ b/src/backend/utils/adt/nabstime.c
@@ -9,7 +9,7 @@
  *
  *
  * IDENTIFICATION
- *   $Header: /cvsroot/pgsql/src/backend/utils/adt/nabstime.c,v 1.95 2002/06/20 20:29:37 momjian Exp $
+ *   $Header: /cvsroot/pgsql/src/backend/utils/adt/nabstime.c,v 1.96 2002/08/04 06:44:47 thomas Exp $
  *
  * NOTES
  *
@@ -486,8 +486,8 @@ nabstimein(PG_FUNCTION_ARGS)
    int         nf,
                ftype[MAXDATEFIELDS];
 
-   if (strlen(str) > MAXDATELEN)
-       elog(ERROR, "Bad (length) abstime external representation '%s'", str);
+   if (strlen(str) >= sizeof(lowstr))
+       elog(ERROR, "Bad abstime external representation (too long) '%s'", str);
 
    if ((ParseDateTime(str, lowstr, field, ftype, MAXDATEFIELDS, &nf) != 0)
      || (DecodeDateTime(field, ftype, nf, &dtype, tm, &fsec, &tz) != 0))
@@ -849,8 +849,8 @@ reltimein(PG_FUNCTION_ARGS)
                ftype[MAXDATEFIELDS];
    char        lowstr[MAXDATELEN + 1];
 
-   if (strlen(str) > MAXDATELEN)
-       elog(ERROR, "Bad (length) reltime external representation '%s'", str);
+   if (strlen(str) >= sizeof(lowstr))
+       elog(ERROR, "Bad reltime external representation (too long) '%s'", str);
 
    if ((ParseDateTime(str, lowstr, field, ftype, MAXDATEFIELDS, &nf) != 0)
        || (DecodeInterval(field, ftype, nf, &dtype, tm, &fsec) != 0))

diff --git a/src/backend/utils/adt/timestamp.c b/src/backend/utils/adt/timestamp.c
index 79420310bdf843490834627e02ac533ac5660663..5be34e6199c1c08dfd05de58dc797517ce3d4f37 100644 (file)
--- a/src/backend/utils/adt/timestamp.c
+++ b/src/backend/utils/adt/timestamp.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *   $Header: /cvsroot/pgsql/src/backend/utils/adt/timestamp.c,v 1.68 2002/06/20 20:29:38 momjian Exp $
+ *   $Header: /cvsroot/pgsql/src/backend/utils/adt/timestamp.c,v 1.69 2002/08/04 06:44:47 thomas Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -65,7 +65,10 @@ timestamp_in(PG_FUNCTION_ARGS)
    int         nf;
    char       *field[MAXDATEFIELDS];
    int         ftype[MAXDATEFIELDS];
-   char        lowstr[MAXDATELEN + 1];
+   char        lowstr[MAXDATELEN + MAXDATEFIELDS];
+
+   if (strlen(str) >= sizeof(lowstr))
+       elog(ERROR, "Bad timestamp external representation (too long) '%s'", str);
 
    if ((ParseDateTime(str, lowstr, field, ftype, MAXDATEFIELDS, &nf) != 0)
      || (DecodeDateTime(field, ftype, nf, &dtype, tm, &fsec, &tz) != 0))
@@ -251,7 +254,11 @@ timestamptz_in(PG_FUNCTION_ARGS)
    int         nf;
    char       *field[MAXDATEFIELDS];
    int         ftype[MAXDATEFIELDS];
-   char        lowstr[MAXDATELEN + 1];
+   char        lowstr[MAXDATELEN + MAXDATEFIELDS];
+
+   if (strlen(str) >= sizeof(lowstr))
+       elog(ERROR, "Bad timestamp with time zone"
+            " external representation (too long) '%s'", str);
 
    if ((ParseDateTime(str, lowstr, field, ftype, MAXDATEFIELDS, &nf) != 0)
      || (DecodeDateTime(field, ftype, nf, &dtype, tm, &fsec, &tz) != 0))
@@ -359,7 +366,7 @@ interval_in(PG_FUNCTION_ARGS)
    int         nf;
    char       *field[MAXDATEFIELDS];
    int         ftype[MAXDATEFIELDS];
-   char        lowstr[MAXDATELEN + 1];
+   char        lowstr[MAXDATELEN + MAXDATEFIELDS];
 
    tm->tm_year = 0;
    tm->tm_mon = 0;
@@ -369,6 +376,9 @@ interval_in(PG_FUNCTION_ARGS)
    tm->tm_sec = 0;
    fsec = 0;
 
+   if (strlen(str) >= sizeof(lowstr))
+       elog(ERROR, "Bad interval external representation (too long) '%s'", str);
+
    if ((ParseDateTime(str, lowstr, field, ftype, MAXDATEFIELDS, &nf) != 0)
        || (DecodeInterval(field, ftype, nf, &dtype, tm, &fsec) != 0))
        elog(ERROR, "Bad interval external representation '%s'", str);
@@ -436,8 +446,6 @@ interval_scale(PG_FUNCTION_ARGS)
    PG_RETURN_INTERVAL_P(result);
 }
 
-#define MASK(b) (1 << (b))
-
 static void
 AdjustIntervalForTypmod(Interval *interval, int32 typmod)
 {
@@ -483,31 +491,34 @@ AdjustIntervalForTypmod(Interval *interval, int32 typmod)
    };
 #endif
 
+   /* Unspecified range and precision? Then not necessary to adjust.
+    * Setting typmod to -1 is the convention for all types.
+    */
    if (typmod != -1)
    {
-       int         range = ((typmod >> 16) & 0x7FFF);
-       int         precision = (typmod & 0xFFFF);
+       int         range = INTERVAL_RANGE(typmod);
+       int         precision = INTERVAL_PRECISION(typmod);
 
-       if (range == 0x7FFF)
+       if (range == INTERVAL_FULL_RANGE)
        {
            /* Do nothing... */
        }
-       else if (range == MASK(YEAR))
+       else if (range == INTERVAL_MASK(YEAR))
        {
            interval->month = ((interval->month / 12) * 12);
            interval->time = 0;
        }
-       else if (range == MASK(MONTH))
+       else if (range == INTERVAL_MASK(MONTH))
        {
            interval->month %= 12;
            interval->time = 0;
        }
        /* YEAR TO MONTH */
-       else if (range == (MASK(YEAR) | MASK(MONTH)))
+       else if (range == (INTERVAL_MASK(YEAR) | INTERVAL_MASK(MONTH)))
        {
            interval->time = 0;
        }
-       else if (range == MASK(DAY))
+       else if (range == INTERVAL_MASK(DAY))
        {
            interval->month = 0;
 #ifdef HAVE_INT64_TIMESTAMP
@@ -517,7 +528,7 @@ AdjustIntervalForTypmod(Interval *interval, int32 typmod)
            interval->time = (((int) (interval->time / 86400)) * 86400);
 #endif
        }
-       else if (range == MASK(HOUR))
+       else if (range == INTERVAL_MASK(HOUR))
        {
 #ifdef HAVE_INT64_TIMESTAMP
            int64       day;
@@ -536,7 +547,7 @@ AdjustIntervalForTypmod(Interval *interval, int32 typmod)
            interval->time = (((int) (interval->time / 3600)) * 3600.0);
 #endif
        }
-       else if (range == MASK(MINUTE))
+       else if (range == INTERVAL_MASK(MINUTE))
        {
 #ifdef HAVE_INT64_TIMESTAMP
            int64       hour;
@@ -555,7 +566,7 @@ AdjustIntervalForTypmod(Interval *interval, int32 typmod)
            interval->time = (((int) (interval->time / 60)) * 60);
 #endif
        }
-       else if (range == MASK(SECOND))
+       else if (range == INTERVAL_MASK(SECOND))
        {
 #ifdef HAVE_INT64_TIMESTAMP
            int64       minute;
@@ -573,7 +584,8 @@ AdjustIntervalForTypmod(Interval *interval, int32 typmod)
 #endif
        }
        /* DAY TO HOUR */
-       else if (range == (MASK(DAY) | MASK(HOUR)))
+       else if (range == (INTERVAL_MASK(DAY) |
+                          INTERVAL_MASK(HOUR)))
        {
            interval->month = 0;
 #ifdef HAVE_INT64_TIMESTAMP
@@ -584,7 +596,9 @@ AdjustIntervalForTypmod(Interval *interval, int32 typmod)
 #endif
        }
        /* DAY TO MINUTE */
-       else if (range == (MASK(DAY) | MASK(HOUR) | MASK(MINUTE)))
+       else if (range == (INTERVAL_MASK(DAY) |
+                          INTERVAL_MASK(HOUR) |
+                          INTERVAL_MASK(MINUTE)))
        {
            interval->month = 0;
 #ifdef HAVE_INT64_TIMESTAMP
@@ -595,12 +609,16 @@ AdjustIntervalForTypmod(Interval *interval, int32 typmod)
 #endif
        }
        /* DAY TO SECOND */
-       else if (range == (MASK(DAY) | MASK(HOUR) | MASK(MINUTE) | MASK(SECOND)))
+       else if (range == (INTERVAL_MASK(DAY) |
+                          INTERVAL_MASK(HOUR) |
+                          INTERVAL_MASK(MINUTE) |
+                          INTERVAL_MASK(SECOND)))
        {
            interval->month = 0;
        }
        /* HOUR TO MINUTE */
-       else if (range == (MASK(HOUR) | MASK(MINUTE)))
+       else if (range == (INTERVAL_MASK(HOUR) |
+                          INTERVAL_MASK(MINUTE)))
        {
 #ifdef HAVE_INT64_TIMESTAMP
            int64       day;
@@ -620,7 +638,9 @@ AdjustIntervalForTypmod(Interval *interval, int32 typmod)
 #endif
        }
        /* HOUR TO SECOND */
-       else if (range == (MASK(HOUR) | MASK(MINUTE) | MASK(SECOND)))
+       else if (range == (INTERVAL_MASK(HOUR) |
+                          INTERVAL_MASK(MINUTE) |
+                          INTERVAL_MASK(SECOND)))
        {
 #ifdef HAVE_INT64_TIMESTAMP
            int64       day;
@@ -637,7 +657,8 @@ AdjustIntervalForTypmod(Interval *interval, int32 typmod)
 #endif
        }
        /* MINUTE TO SECOND */
-       else if (range == (MASK(MINUTE) | MASK(SECOND)))
+       else if (range == (INTERVAL_MASK(MINUTE) |
+                          INTERVAL_MASK(SECOND)))
        {
 #ifdef HAVE_INT64_TIMESTAMP
            int64       hour;
@@ -657,7 +678,7 @@ AdjustIntervalForTypmod(Interval *interval, int32 typmod)
            elog(ERROR, "AdjustIntervalForTypmod(): internal coding error");
 
        /* Need to adjust precision? If not, don't even try! */
-       if (precision != 0xFFFF)
+       if (precision != INTERVAL_FULL_PRECISION)
        {
            if ((precision < 0) || (precision > MAX_INTERVAL_PRECISION))
                elog(ERROR, "INTERVAL(%d) precision must be between %d and %d",

diff --git a/src/backend/utils/adt/varlena.c b/src/backend/utils/adt/varlena.c
index b3ff70d43bde2afc9ee2f412639894c293349e35..bdcffa954e0fe17aae68363d0ab2e93752c9f2fa 100644 (file)
--- a/src/backend/utils/adt/varlena.c
+++ b/src/backend/utils/adt/varlena.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *   $Header: /cvsroot/pgsql/src/backend/utils/adt/varlena.c,v 1.86 2002/06/20 20:29:38 momjian Exp $
+ *   $Header: /cvsroot/pgsql/src/backend/utils/adt/varlena.c,v 1.87 2002/08/04 06:44:47 thomas Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -550,7 +550,7 @@ varstr_cmp(char *arg1, int len1, char *arg2, int len2)
    /*
     * Unfortunately, there is no strncoll(), so in the non-C locale
     * case we have to do some memory copying.  This turns out to be
-    * significantly slower, so we optimize the case were LC_COLLATE
+    * significantly slower, so we optimize the case where LC_COLLATE
     * is C.
     */
    if (!lc_collate_is_c())