Patch to fix alpha-related problems. Sent in private mail by Berndt Josef

Wulf <wulf@ping.net.au>.  Fixes PR#10704.

1 files changed, 2112 insertions, 0 deletions

diff --git a/databases/postgresql/files/postgresql-7.0.3-alpha.diff b/databases/postgresql/files/postgresql-7.0.3-alpha.diff
new file mode 100644
index 00000000000..d57c5fd6f8d
--- /dev/null
+++ b/databases/postgresql/files/postgresql-7.0.3-alpha.diff
@@ -0,0 +1,2112 @@
+$NetBSD: postgresql-7.0.3-alpha.diff,v 1.1 2001/02/13 02:39:32 jlam Exp $
+
+This diff is derived by Berndt Josef Wulf <wulf@ping.net.au> from the patch
+located at:
+
+	http://www.rkirkpat.net/software/postgresql-7.0-alpha.patch.gz
+
+to patch cleanly into the pkgsrc PostgreSQL source tree, and fixes several
+problems related to 64-bit integers.  This patch will no longer be needed
+for the forthcoming PostgreSQL 7.1 release.
+
+--- backend/access/hash/hashfunc.c.orig	Mon Feb 12 21:28:48 2001
++++ backend/access/hash/hashfunc.c	Mon Feb 12 21:28:48 2001
+@@ -22,15 +22,15 @@
+ #include "access/hash.h"
+ 
+ uint32
+-hashint2(int16 key)
++hashint2(Datum key)
+ {
+-	return (uint32) ~key;
++	return (uint32) ~((int16)key);
+ }
+ 
+ uint32
+-hashint4(uint32 key)
++hashint4(Datum key)
+ {
+-	return ~key;
++	return ~((uint32)key);
+ }
+ 
+ uint32
+@@ -172,12 +172,12 @@
+ #define PRIME2			1048583
+ 
+ uint32
+-hashchar(char key)
++hashchar(Datum key)
+ {
+ 	uint32		h;
+ 
+ 	/* Convert char to integer */
+-	h = (key - ' ');
++	h = ((char)key - ' ');
+ 	h %= PRIME2;
+ 
+ 	return h;
+--- backend/access/nbtree/nbtcompare.c.orig	Mon Feb 12 21:28:48 2001
++++ backend/access/nbtree/nbtcompare.c	Mon Feb 12 21:28:48 2001
+@@ -27,13 +27,13 @@
+ #include "utils/builtins.h"
+ 
+ int32
+-btint2cmp(int16 a, int16 b)
++btint2cmp(Datum a, Datum b)
+ {
+-	return (int32) (a - b);
++	return (int32) ((int16)a - (int16)b);
+ }
+ 
+ int32
+-btint4cmp(int32 a, int32 b)
++btint4cmp(Datum a, Datum b)
+ {
+ 	if (a > b)
+ 		return 1;
+@@ -55,15 +55,15 @@
+ }
+ 
+ int32
+-btint24cmp(int16 a, int32 b)
++btint24cmp(Datum a, Datum b)
+ {
+-	return ((int32) a) - b;
++	return ((int16) a) - (int32)b;
+ }
+ 
+ int32
+-btint42cmp(int32 a, int16 b)
++btint42cmp(Datum a, Datum b)
+ {
+-	return a - ((int32) b);
++	return (int32)a - ((int16) b);
+ }
+ 
+ int32
+@@ -118,8 +118,9 @@
+ 
+ 
+ int32
+-btabstimecmp(AbsoluteTime a, AbsoluteTime b)
++btabstimecmp(Datum da, Datum db)
+ {
++	AbsoluteTime a = da,  b = db;
+ 	if (AbsoluteTimeIsBefore(a, b))
+ 		return -1;
+ 	else if (AbsoluteTimeIsBefore(b, a))
+@@ -129,7 +130,7 @@
+ }
+ 
+ int32
+-btcharcmp(char a, char b)
++btcharcmp(Datum a, Datum b)
+ {
+ 	return (int32) ((uint8) a - (uint8) b);
+ }
+--- backend/utils/adt/char.c.orig	Mon Feb 12 21:28:48 2001
++++ backend/utils/adt/char.c	Mon Feb 12 21:28:48 2001
+@@ -35,7 +35,7 @@
+  *		charout			- converts 'x' to "x"
+  */
+ char *
+-charout(int32 ch)
++charout(Datum ch)
+ {
+ 	char	   *result = (char *) palloc(2);
+ 
+@@ -70,7 +70,7 @@
+  *		printable character...
+  */
+ char *
+-cidout(int32 c)
++cidout(Datum c)
+ {
+ 	char	   *result;
+ 	CommandId	c2;
+@@ -87,69 +87,69 @@
+  *****************************************************************************/
+ 
+ bool
+-chareq(int8 arg1, int8 arg2)
++chareq(Datum arg1, Datum arg2)
+ {
+-	return arg1 == arg2;
++	return (int8)arg1 == (int8)arg2;
+ }
+ 
+ bool
+-charne(int8 arg1, int8 arg2)
++charne(Datum arg1, Datum arg2)
+ {
+-	return arg1 != arg2;
++	return (int8)arg1 != (int8)arg2;
+ }
+ 
+ bool
+-charlt(int8 arg1, int8 arg2)
++charlt(Datum arg1, Datum arg2)
+ {
+ 	return (uint8) arg1 < (uint8) arg2;
+ }
+ 
+ bool
+-charle(int8 arg1, int8 arg2)
++charle(Datum arg1, Datum arg2)
+ {
+ 	return (uint8) arg1 <= (uint8) arg2;
+ }
+ 
+ bool
+-chargt(int8 arg1, int8 arg2)
++chargt(Datum arg1, Datum arg2)
+ {
+ 	return (uint8) arg1 > (uint8) arg2;
+ }
+ 
+ bool
+-charge(int8 arg1, int8 arg2)
++charge(Datum arg1, Datum arg2)
+ {
+ 	return (uint8) arg1 >= (uint8) arg2;
+ }
+ 
+ int8
+-charpl(int8 arg1, int8 arg2)
++charpl(Datum arg1, Datum arg2)
+ {
+-	return arg1 + arg2;
++	return (int8)arg1 + (int8)arg2;
+ }
+ 
+ int8
+-charmi(int8 arg1, int8 arg2)
++charmi(Datum arg1, Datum arg2)
+ {
+-	return arg1 - arg2;
++	return (int8)arg1 - (int8)arg2;
+ }
+ 
+ int8
+-charmul(int8 arg1, int8 arg2)
++charmul(Datum arg1, Datum arg2)
+ {
+-	return arg1 * arg2;
++	return (int8)arg1 * (int8)arg2;
+ }
+ 
+ int8
+-chardiv(int8 arg1, int8 arg2)
++chardiv(Datum arg1, Datum arg2)
+ {
+-	return arg1 / arg2;
++	return (int8)arg1 / (int8)arg2;
+ }
+ 
+ bool
+-cideq(int8 arg1, int8 arg2)
++cideq(Datum arg1, Datum arg2)
+ {
+-	return arg1 == arg2;
++	return (int8)arg1 == (int8)arg2;
+ }
+ 
+ int8
+@@ -159,13 +159,13 @@
+ }
+ 
+ text *
+-char_text(int8 arg1)
++char_text(Datum arg1)
+ {
+ 	text	   *result;
+ 
+ 	result = palloc(VARHDRSZ + 1);
+ 	VARSIZE(result) = VARHDRSZ + 1;
+-	*(VARDATA(result)) = arg1;
++	*(VARDATA(result)) = (int8)arg1;
+ 
+ 	return result;
+ }
+--- backend/utils/adt/float.c.orig	Mon Feb 12 21:28:48 2001
++++ backend/utils/adt/float.c	Mon Feb 12 21:28:48 2001
+@@ -138,7 +138,7 @@
+  * until the distributions are updated.
+  *								--djm 12/16/96
+  */
+-#if ( defined(linux) && defined(__alpha__) ) && !defined(UNSAFE_FLOATS)
++#if ( defined(linux) && defined(__alpha__) ) && !defined(UNSAFE_FLOATS) && 0
+ #define UNSAFE_FLOATS
+ #endif
+ 
+@@ -864,9 +864,10 @@
+  *		i4tod			- converts an int4 number to a float8 number
+  */
+ float64
+-i4tod(int32 num)
++i4tod(Datum n)
+ {
+ 	float64		result;
++	int32	num = (int32) n;
+ 
+ 	result = (float64) palloc(sizeof(float64data));
+ 
+@@ -879,9 +880,10 @@
+  *		i2tod			- converts an int2 number to a float8 number
+  */
+ float64
+-i2tod(int16 num)
++i2tod(Datum n)
+ {
+ 	float64		result;
++	int16	num = (int16) n;
+ 
+ 	result = (float64) palloc(sizeof(float64data));
+ 
+@@ -932,9 +934,10 @@
+  *		i4tof			- converts an int4 number to a float8 number
+  */
+ float32
+-i4tof(int32 num)
++i4tof(Datum n)
+ {
+ 	float32		result;
++	int32	num = (int32) n;
+ 
+ 	result = (float32) palloc(sizeof(float32data));
+ 
+@@ -947,9 +950,10 @@
+  *		i2tof			- converts an int2 number to a float8 number
+  */
+ float32
+-i2tof(int16 num)
++i2tof(Datum n)
+ {
+ 	float32		result;
++	int16	num = (int16) n;
+ 
+ 	result = (float32) palloc(sizeof(float32data));
+ 
+--- backend/utils/adt/int.c.orig	Mon Feb 12 21:28:48 2001
++++ backend/utils/adt/int.c	Mon Feb 12 21:28:48 2001
+@@ -62,7 +62,7 @@
+  *		int2out			- converts short to "num"
+  */
+ char *
+-int2out(int16 sh)
++int2out(Datum sh)
+ {
+ 	char	   *result;
+ 
+@@ -227,12 +227,12 @@
+  *		int4out			- converts int4 to "num"
+  */
+ char *
+-int4out(int32 l)
++int4out(Datum l)
+ {
+ 	char	   *result;
+ 
+ 	result = (char *) palloc(12);		/* assumes sign, 10 digits, '\0' */
+-	ltoa(l, result);
++	ltoa((int32)l, result);
+ 	return result;
+ }
+ 
+@@ -244,14 +244,16 @@
+  */
+ 
+ int32
+-i2toi4(int16 arg1)
++i2toi4(Datum arg1)
+ {
+ 	return (int32) arg1;
+ }
+ 
+ int16
+-i4toi2(int32 arg1)
++i4toi2(Datum arg)
+ {
++	int32 arg1 = (int32) arg;
++
+ 	if (arg1 < SHRT_MIN)
+ 		elog(ERROR, "i4toi2: '%d' causes int2 underflow", arg1);
+ 	if (arg1 > SHRT_MAX)
+@@ -261,7 +263,7 @@
+ }
+ 
+ text *
+-int2_text(int16 arg1)
++int2_text(Datum arg1)
+ {
+ 	text	   *result;
+ 
+@@ -305,7 +307,7 @@
+ }	/* text_int2() */
+ 
+ text *
+-int4_text(int32 arg1)
++int4_text(Datum arg1)
+ {
+ 	text	   *result;
+ 
+@@ -364,147 +366,147 @@
+  *		intge			- returns 1 iff arg1 >= arg2
+  */
+ bool
+-int4eq(int32 arg1, int32 arg2)
++int4eq(Datum arg1, Datum arg2)
+ {
+-	return arg1 == arg2;
++	return (int32)arg1 == (int32)arg2;
+ }
+ 
+ bool
+-int4ne(int32 arg1, int32 arg2)
++int4ne(Datum arg1, Datum arg2)
+ {
+-	return arg1 != arg2;
++	return (int32)arg1 != (int32)arg2;
+ }
+ 
+ bool
+-int4lt(int32 arg1, int32 arg2)
++int4lt(Datum arg1, Datum arg2)
+ {
+-	return arg1 < arg2;
++	return (int32)arg1 < (int32)arg2;
+ }
+ 
+ bool
+-int4le(int32 arg1, int32 arg2)
++int4le(Datum arg1, Datum arg2)
+ {
+-	return arg1 <= arg2;
++	return (int32)arg1 <= (int32)arg2;
+ }
+ 
+ bool
+-int4gt(int32 arg1, int32 arg2)
++int4gt(Datum arg1, Datum arg2)
+ {
+-	return arg1 > arg2;
++	return (int32)arg1 > (int32)arg2;
+ }
+ 
+ bool
+-int4ge(int32 arg1, int32 arg2)
++int4ge(Datum arg1, Datum arg2)
+ {
+-	return arg1 >= arg2;
++	return (int32)arg1 >= (int32)arg2;
+ }
+ 
+ bool
+-int2eq(int16 arg1, int16 arg2)
++int2eq(Datum arg1, Datum arg2)
+ {
+-	return arg1 == arg2;
++	return (int16)arg1 == (int16)arg2;
+ }
+ 
+ bool
+-int2ne(int16 arg1, int16 arg2)
++int2ne(Datum arg1, Datum arg2)
+ {
+-	return arg1 != arg2;
++	return (int16)arg1 != (int16)arg2;
+ }
+ 
+ bool
+-int2lt(int16 arg1, int16 arg2)
++int2lt(Datum arg1, Datum arg2)
+ {
+-	return arg1 < arg2;
++	return (int16)arg1 < (int16)arg2;
+ }
+ 
+ bool
+-int2le(int16 arg1, int16 arg2)
++int2le(Datum arg1, Datum arg2)
+ {
+-	return arg1 <= arg2;
++	return (int16)arg1 <= (int16)arg2;
+ }
+ 
+ bool
+-int2gt(int16 arg1, int16 arg2)
++int2gt(Datum arg1, Datum arg2)
+ {
+-	return arg1 > arg2;
++	return (int16)arg1 > (int16)arg2;
+ }
+ 
+ bool
+-int2ge(int16 arg1, int16 arg2)
++int2ge(Datum arg1, Datum arg2)
+ {
+-	return arg1 >= arg2;
++	return (int16)arg1 >= (int16)arg2;
+ }
+ 
+ bool
+-int24eq(int32 arg1, int32 arg2)
++int24eq(Datum arg1, Datum arg2)
+ {
+-	return arg1 == arg2;
++	return (int32)arg1 == (int32)arg2;
+ }
+ 
+ bool
+-int24ne(int32 arg1, int32 arg2)
++int24ne(Datum arg1, Datum arg2)
+ {
+-	return arg1 != arg2;
++	return (int32)arg1 != (int32)arg2;
+ }
+ 
+ bool
+-int24lt(int32 arg1, int32 arg2)
++int24lt(Datum arg1, Datum arg2)
+ {
+-	return arg1 < arg2;
++	return (int32)arg1 < (int32)arg2;
+ }
+ 
+ bool
+-int24le(int32 arg1, int32 arg2)
++int24le(Datum arg1, Datum arg2)
+ {
+-	return arg1 <= arg2;
++	return (int32)arg1 <= (int32)arg2;
+ }
+ 
+ bool
+-int24gt(int32 arg1, int32 arg2)
++int24gt(Datum arg1, Datum arg2)
+ {
+-	return arg1 > arg2;
++	return (int32)arg1 > (int32)arg2;
+ }
+ 
+ bool
+-int24ge(int32 arg1, int32 arg2)
++int24ge(Datum arg1, Datum arg2)
+ {
+-	return arg1 >= arg2;
++	return (int32)arg1 >= (int32)arg2;
+ }
+ 
+ bool
+-int42eq(int32 arg1, int32 arg2)
++int42eq(Datum arg1, Datum arg2)
+ {
+-	return arg1 == arg2;
++	return (int32)arg1 == (int32)arg2;
+ }
+ 
+ bool
+-int42ne(int32 arg1, int32 arg2)
++int42ne(Datum arg1, Datum arg2)
+ {
+-	return arg1 != arg2;
++	return (int32)arg1 != (int32)arg2;
+ }
+ 
+ bool
+-int42lt(int32 arg1, int32 arg2)
++int42lt(Datum arg1, Datum arg2)
+ {
+-	return arg1 < arg2;
++	return (int32)arg1 < (int32)arg2;
+ }
+ 
+ bool
+-int42le(int32 arg1, int32 arg2)
++int42le(Datum arg1, Datum arg2)
+ {
+-	return arg1 <= arg2;
++	return (int32)arg1 <= (int32)arg2;
+ }
+ 
+ bool
+-int42gt(int32 arg1, int32 arg2)
++int42gt(Datum arg1, Datum arg2)
+ {
+-	return arg1 > arg2;
++	return (int32)arg1 > (int32)arg2;
+ }
+ 
+ bool
+-int42ge(int32 arg1, int32 arg2)
++int42ge(Datum arg1, Datum arg2)
+ {
+-	return arg1 >= arg2;
++	return (int32)arg1 >= (int32)arg2;
+ }
+ 
+ /*
+@@ -514,159 +516,160 @@
+  *		int[24]div		- returns arg1 / arg2
+  */
+ int32
+-int4um(int32 arg)
++int4um(Datum arg)
+ {
+-	return -arg;
++	return (int32)-arg;
+ }
+ 
+ int32
+-int4pl(int32 arg1, int32 arg2)
++int4pl(Datum arg1, Datum arg2)
+ {
+-	return arg1 + arg2;
++	return (int32)arg1 + (int32)arg2;
+ }
+ 
+ int32
+-int4mi(int32 arg1, int32 arg2)
++int4mi(Datum arg1, Datum arg2)
+ {
+-	return arg1 - arg2;
++	return (int32)arg1 - (int32)arg2;
+ }
+ 
+ int32
+-int4mul(int32 arg1, int32 arg2)
++int4mul(Datum arg1, Datum arg2)
+ {
+-	return arg1 * arg2;
++	return (int32)arg1 * (int32)arg2;
+ }
+ 
+ int32
+-int4div(int32 arg1, int32 arg2)
++int4div(Datum arg1, Datum arg2)
+ {
+-	return arg1 / arg2;
++	return (int32)arg1 / (int32)arg2;
+ }
+ 
+ int32
+-int4inc(int32 arg)
++int4inc(Datum arg)
+ {
+-	return arg + (int32) 1;
++	return (int32)++arg;
+ }
+ 
+ int16
+-int2um(int16 arg)
++int2um(Datum arg)
+ {
+-	return -arg;
++	return (int16)-arg;
+ }
+ 
+ int16
+-int2pl(int16 arg1, int16 arg2)
++int2pl(Datum arg1, Datum arg2)
+ {
+-	return arg1 + arg2;
++	return (int16)arg1 + (int16)arg2;
+ }
+ 
+ int16
+-int2mi(int16 arg1, int16 arg2)
++int2mi(Datum arg1, Datum arg2)
+ {
+-	return arg1 - arg2;
++	return (int16)arg1 - (int16)arg2;
+ }
+ 
+ int16
+-int2mul(int16 arg1, int16 arg2)
++int2mul(Datum arg1, Datum arg2)
+ {
+-	return arg1 * arg2;
++	return (int16)arg1 * (int16)arg2;
+ }
+ 
+ int16
+-int2div(int16 arg1, int16 arg2)
++int2div(Datum arg1, Datum arg2)
+ {
+-	return arg1 / arg2;
++	return (int16)arg1 / (int16)arg2;
+ }
+ 
+ int16
+-int2inc(int16 arg)
++int2inc(Datum arg)
+ {
+-	return arg + (int16) 1;
++	return (int16)++arg;
+ }
+ 
+ int32
+-int24pl(int32 arg1, int32 arg2)
++int24pl(Datum arg1, Datum arg2)
+ {
+-	return arg1 + arg2;
++	return (int32)arg1 + (int32)arg2;
+ }
+ 
+ int32
+-int24mi(int32 arg1, int32 arg2)
++int24mi(Datum arg1, Datum arg2)
+ {
+-	return arg1 - arg2;
++	return (int32)arg1 - (int32)arg2;
+ }
+ 
+ int32
+-int24mul(int32 arg1, int32 arg2)
++int24mul(Datum arg1, Datum arg2)
+ {
+-	return arg1 * arg2;
++	return (int32)arg1 * (int32)arg2;
+ }
+ 
+ int32
+-int24div(int32 arg1, int32 arg2)
++int24div(Datum arg1, Datum arg2)
+ {
+-	return arg1 / arg2;
++	return (int32)arg1 / (int32)arg2;
+ }
+ 
+ int32
+-int42pl(int32 arg1, int32 arg2)
++int42pl(Datum arg1, Datum arg2)
+ {
+-	return arg1 + arg2;
++	return (int32)arg1 + (int32)arg2;
+ }
+ 
+ int32
+-int42mi(int32 arg1, int32 arg2)
++int42mi(Datum arg1, Datum arg2)
+ {
+-	return arg1 - arg2;
++	return (int32)arg1 - (int32)arg2;
+ }
+ 
+ int32
+-int42mul(int32 arg1, int32 arg2)
++int42mul(Datum arg1, Datum arg2)
+ {
+-	return arg1 * arg2;
++	return (int32)arg1 * (int32)arg2;
+ }
+ 
+ int32
+-int42div(int32 arg1, int32 arg2)
++int42div(Datum arg1, Datum arg2)
+ {
+-	return arg1 / arg2;
++	return (int32)arg1 / (int32)arg2;
+ }
+ 
+ /*
+  *		int[24]mod		- returns arg1 mod arg2
+  */
+ int32
+-int4mod(int32 arg1, int32 arg2)
++int4mod(Datum arg1, Datum arg2)
+ {
+-	return arg1 % arg2;
++	return (int32)arg1 % (int32)arg2;
+ }
+ 
+ int32
+-int2mod(int16 arg1, int16 arg2)
++int2mod(Datum arg1, Datum arg2)
+ {
+-	return arg1 % arg2;
++	return (int16)arg1 % (int16)arg2;
+ }
+ 
+ int32
+-int24mod(int32 arg1, int32 arg2)
++int24mod(Datum arg1, Datum arg2)
+ {
+-	return arg1 % arg2;
++	return (int32)arg1 % (int32)arg2;
+ }
+ 
+ int32
+-int42mod(int32 arg1, int32 arg2)
++int42mod(Datum arg1, Datum arg2)
+ {
+-	return arg1 % arg2;
++	return (int32)arg1 % (int32)arg2;
+ }
+ 
+ /* int[24]fac()
+  * Factorial
+  */
+ int32
+-int4fac(int32 arg1)
++int4fac(Datum arg)
+ {
+ 	int32		result;
++	int32	arg1 = (int32) arg;
+ 
+ 	if (arg1 < 1)
+ 		result = 0;
+@@ -677,9 +680,10 @@
+ }
+ 
+ int32
+-int2fac(int16 arg1)
++int2fac(Datum arg)
+ {
+ 	int32		result;
++        int16           arg1 = (int16) arg;
+ 
+ 	if (arg1 < 1)
+ 		result = 0;
+@@ -693,37 +697,37 @@
+  * Absolute value
+  */
+ int32
+-int4abs(int32 arg1)
++int4abs(Datum arg1)
+ {
+-	return ((arg1 < 0) ? -arg1 : arg1);
++	return ((arg1 < 0) ? -arg1: arg1);
+ }
+ 
+ int16
+-int2abs(int16 arg1)
++int2abs(Datum arg1)
+ {
+-	return ((arg1 < 0) ? -arg1 : arg1);
++	return ((arg1 < 0) ? -arg1: arg1);
+ }
+ 
+ int16
+-int2larger(int16 arg1, int16 arg2)
++int2larger(Datum arg1, Datum arg2)
+ {
+-	return (arg1 > arg2) ? arg1 : arg2;
++	return ((int16)arg1 > (int16)arg2) ? (int16)arg1 : (int16)arg2;
+ }
+ 
+ int16
+-int2smaller(int16 arg1, int16 arg2)
++int2smaller(Datum arg1, Datum arg2)
+ {
+-	return (arg1 < arg2) ? arg1 : arg2;
++	return ((int16)arg1 < (int16)arg2) ? (int16)arg1 : (int16)arg2;
+ }
+ 
+ int32
+-int4larger(int32 arg1, int32 arg2)
++int4larger(Datum arg1, Datum arg2)
+ {
+-	return (arg1 > arg2) ? arg1 : arg2;
++	return ((int32)arg1 > (int32)arg2) ? (int32)arg1 : (int32)arg2;
+ }
+ 
+ int32
+-int4smaller(int32 arg1, int32 arg2)
++int4smaller(Datum arg1, Datum arg2)
+ {
+-	return (arg1 < arg2) ? arg1 : arg2;
++	return ((int32)arg1 < (int32)arg2) ? (int32)arg1 : (int32)arg2;
+ }
+--- backend/utils/adt/int8.c.orig	Mon Feb 12 21:28:48 2001
++++ backend/utils/adt/int8.c	Mon Feb 12 21:28:48 2001
+@@ -176,57 +176,57 @@
+  * Is 64-bit val1 relop 32-bit val2?
+  */
+ bool
+-int84eq(int64 *val1, int32 val2)
++int84eq(int64 *val1, Datum val2)
+ {
+ 	if (!val1)
+ 		return 0;
+ 
+-	return *val1 == val2;
++	return *val1 == (int32)val2;
+ }	/* int84eq() */
+ 
+ bool
+-int84ne(int64 *val1, int32 val2)
++int84ne(int64 *val1, Datum val2)
+ {
+ 	if (!val1)
+ 		return 0;
+ 
+-	return *val1 != val2;
++	return *val1 != (int32)val2;
+ }	/* int84ne() */
+ 
+ bool
+-int84lt(int64 *val1, int32 val2)
++int84lt(int64 *val1, Datum val2)
+ {
+ 	if (!val1)
+ 		return 0;
+ 
+-	return *val1 < val2;
++	return *val1 < (int32)val2;
+ }	/* int84lt() */
+ 
+ bool
+-int84gt(int64 *val1, int32 val2)
++int84gt(int64 *val1, Datum val2)
+ {
+ 	if (!val1)
+ 		return 0;
+ 
+-	return *val1 > val2;
++	return *val1 > (int32)val2;
+ }	/* int84gt() */
+ 
+ bool
+-int84le(int64 *val1, int32 val2)
++int84le(int64 *val1, Datum val2)
+ {
+ 	if (!val1)
+ 		return 0;
+ 
+-	return *val1 <= val2;
++	return *val1 <= (int32)val2;
+ }	/* int84le() */
+ 
+ bool
+-int84ge(int64 *val1, int32 val2)
++int84ge(int64 *val1, Datum val2)
+ {
+ 	if (!val1)
+ 		return 0;
+ 
+-	return *val1 >= val2;
++	return *val1 >= (int32)val2;
+ }	/* int84ge() */
+ 
+ 
+@@ -234,57 +234,57 @@
+  * Is 32-bit val1 relop 64-bit val2?
+  */
+ bool
+-int48eq(int32 val1, int64 *val2)
++int48eq(Datum val1, int64 *val2)
+ {
+ 	if (!val2)
+ 		return 0;
+ 
+-	return val1 == *val2;
++	return (int32)val1 == *val2;
+ }	/* int48eq() */
+ 
+ bool
+-int48ne(int32 val1, int64 *val2)
++int48ne(Datum val1, int64 *val2)
+ {
+ 	if (!val2)
+ 		return 0;
+ 
+-	return val1 != *val2;
++	return (int32)val1 != *val2;
+ }	/* int48ne() */
+ 
+ bool
+-int48lt(int32 val1, int64 *val2)
++int48lt(Datum val1, int64 *val2)
+ {
+ 	if (!val2)
+ 		return 0;
+ 
+-	return val1 < *val2;
++	return (int32)val1 < *val2;
+ }	/* int48lt() */
+ 
+ bool
+-int48gt(int32 val1, int64 *val2)
++int48gt(Datum val1, int64 *val2)
+ {
+ 	if (!val2)
+ 		return 0;
+ 
+-	return val1 > *val2;
++	return (int32)val1 > *val2;
+ }	/* int48gt() */
+ 
+ bool
+-int48le(int32 val1, int64 *val2)
++int48le(Datum val1, int64 *val2)
+ {
+ 	if (!val2)
+ 		return 0;
+ 
+-	return val1 <= *val2;
++	return (int32)val1 <= *val2;
+ }	/* int48le() */
+ 
+ bool
+-int48ge(int32 val1, int64 *val2)
++int48ge(Datum val1, int64 *val2)
+ {
+ 	if (!val2)
+ 		return 0;
+ 
+-	return val1 >= *val2;
++	return (int32)val1 >= *val2;
+ }	/* int48ge() */
+ 
+ 
+@@ -444,106 +444,106 @@
+ 
+ 
+ int64 *
+-int84pl(int64 *val1, int32 val2)
++int84pl(int64 *val1, Datum val2)
+ {
+ 	int64	   *result = palloc(sizeof(int64));
+ 
+ 	if (!PointerIsValid(val1))
+ 		return NULL;
+ 
+-	*result = *val1 + (int64) val2;
++	*result = *val1 + (int32) val2;
+ 
+ 	return result;
+ }	/* int84pl() */
+ 
+ int64 *
+-int84mi(int64 *val1, int32 val2)
++int84mi(int64 *val1, Datum val2)
+ {
+ 	int64	   *result = palloc(sizeof(int64));
+ 
+ 	if (!PointerIsValid(val1))
+ 		return NULL;
+ 
+-	*result = *val1 - (int64) val2;
++	*result = *val1 - (int32) val2;
+ 
+ 	return result;
+ }	/* int84mi() */
+ 
+ int64 *
+-int84mul(int64 *val1, int32 val2)
++int84mul(int64 *val1, Datum val2)
+ {
+ 	int64	   *result = palloc(sizeof(int64));
+ 
+ 	if (!PointerIsValid(val1))
+ 		return NULL;
+ 
+-	*result = *val1 * (int64) val2;
++	*result = *val1 * (int32) val2;
+ 
+ 	return result;
+ }	/* int84mul() */
+ 
+ int64 *
+-int84div(int64 *val1, int32 val2)
++int84div(int64 *val1, Datum val2)
+ {
+ 	int64	   *result = palloc(sizeof(int64));
+ 
+ 	if (!PointerIsValid(val1))
+ 		return NULL;
+ 
+-	*result = *val1 / (int64) val2;
++	*result = *val1 / (int32) val2;
+ 
+ 	return result;
+ }	/* int84div() */
+ 
+ 
+ int64 *
+-int48pl(int32 val1, int64 *val2)
++int48pl(Datum val1, int64 *val2)
+ {
+ 	int64	   *result = palloc(sizeof(int64));
+ 
+ 	if (!PointerIsValid(val2))
+ 		return NULL;
+ 
+-	*result = (int64) val1 + *val2;
++	*result = (int32) val1 + *val2;
+ 
+ 	return result;
+ }	/* int48pl() */
+ 
+ int64 *
+-int48mi(int32 val1, int64 *val2)
++int48mi(Datum val1, int64 *val2)
+ {
+ 	int64	   *result = palloc(sizeof(int64));
+ 
+ 	if (!PointerIsValid(val2))
+ 		return NULL;
+ 
+-	*result = (int64) val1 - *val2;
++	*result = (int32) val1 - *val2;
+ 
+ 	return result;
+ }	/* int48mi() */
+ 
+ int64 *
+-int48mul(int32 val1, int64 *val2)
++int48mul(Datum val1, int64 *val2)
+ {
+ 	int64	   *result = palloc(sizeof(int64));
+ 
+ 	if (!PointerIsValid(val2))
+ 		return NULL;
+ 
+-	*result = (int64) val1 **val2;
++	*result = (int32) val1 **val2;
+ 
+ 	return result;
+ }	/* int48mul() */
+ 
+ int64 *
+-int48div(int32 val1, int64 *val2)
++int48div(Datum val1, int64 *val2)
+ {
+ 	int64	   *result = palloc(sizeof(int64));
+ 
+ 	if (!PointerIsValid(val2))
+ 		return NULL;
+ 
+-	*result = (int64) val1 / *val2;
++	*result = (int32) val1 / *val2;
+ 
+ 	return result;
+ }	/* int48div() */
+@@ -554,11 +554,11 @@
+  *---------------------------------------------------------*/
+ 
+ int64 *
+-int48(int32 val)
++int48(Datum val)
+ {
+ 	int64	   *result = palloc(sizeof(int64));
+ 
+-	*result = val;
++	*result = (int32)val;
+ 
+ 	return result;
+ }	/* int48() */
+--- backend/utils/adt/nabstime.c.orig	Mon Feb 12 21:28:48 2001
++++ backend/utils/adt/nabstime.c	Mon Feb 12 21:28:48 2001
+@@ -209,11 +209,11 @@
+ 
+ 
+ void
+-abstime2tm(AbsoluteTime time, int *tzp, struct tm * tm, char *tzn)
++abstime2tm(Datum time, int *tzp, struct tm * tm, char *tzn)
+ {
+ #ifdef USE_POSIX_TIME
+ 	struct tm  *tx;
+-
++	time_t	t = (time_t) time;
+ #else							/* ! USE_POSIX_TIME */
+ 	struct timeb tb;			/* the old V7-ism */
+ 
+@@ -222,10 +222,10 @@
+ 
+ #ifdef USE_POSIX_TIME
+ 	if (tzp != NULL)
+-		tx = localtime((time_t *) &time);
++		tx = localtime( &t );
+ 	else
+ 	{
+-		tx = gmtime((time_t *) &time);
++		tx = gmtime( &t );
+ 	};
+ #endif
+ 
+@@ -304,8 +304,8 @@
+ static AbsoluteTime
+ tm2abstime(struct tm * tm, int tz)
+ {
+-	int			day,
+-				sec;
++	int			day;
++	AbsoluteTime		sec;
+ 
+ 	/* validate, before going out of range on some members */
+ 	if (tm->tm_year < 1901 || tm->tm_year > 2038
+@@ -407,8 +407,9 @@
+  * Given an AbsoluteTime return the English text version of the date
+  */
+ char *
+-nabstimeout(AbsoluteTime time)
++nabstimeout(Datum t)
+ {
++	AbsoluteTime time = (AbsoluteTime) t;
+ 	char	   *result;
+ 	int			tz;
+ 	double		fsec = 0;
+@@ -453,8 +454,10 @@
+  *	AbsoluteTimeIsBefore -- true iff time1 is after time2.
+  */
+ bool
+-AbsoluteTimeIsBefore(AbsoluteTime time1, AbsoluteTime time2)
++AbsoluteTimeIsBefore(Datum t1, Datum t2)
+ {
++	AbsoluteTime time1 = t1,  time2 = t2;
++
+ 	Assert(AbsoluteTimeIsValid(time1));
+ 	Assert(AbsoluteTimeIsValid(time2));
+ 
+@@ -469,8 +472,10 @@
+ 
+ #ifdef NOT_USED
+ bool
+-AbsoluteTimeIsAfter(AbsoluteTime time1, AbsoluteTime time2)
++AbsoluteTimeIsAfter(Datum t1, Datum t2)
+ {
++	AbsoluteTime time1 = t1,  time2 = t2;
++
+ 	Assert(AbsoluteTimeIsValid(time1));
+ 	Assert(AbsoluteTimeIsValid(time2));
+ 
+@@ -488,8 +493,10 @@
+ /* abstime_finite()
+  */
+ bool
+-abstime_finite(AbsoluteTime abstime)
++abstime_finite(Datum d)
+ {
++	AbsoluteTime abstime = (AbsoluteTime) d;
++
+ 	return ((abstime != INVALID_ABSTIME)
+ 		  && (abstime != NOSTART_ABSTIME) && (abstime != NOEND_ABSTIME));
+ }	/* abstime_finite() */
+@@ -504,8 +511,10 @@
+  *		abstimege		- returns 1, iff t1 greater than or equal to t2
+  */
+ bool
+-abstimeeq(AbsoluteTime t1, AbsoluteTime t2)
++abstimeeq(Datum d1, Datum d2)
+ {
++	AbsoluteTime t1 = d1, t2 = d2;
++
+ 	if (t1 == INVALID_ABSTIME || t2 == INVALID_ABSTIME)
+ 		return FALSE;
+ 	if (t1 == CURRENT_ABSTIME)
+@@ -517,8 +526,10 @@
+ }
+ 
+ bool
+-abstimene(AbsoluteTime t1, AbsoluteTime t2)
++abstimene(Datum d1, Datum d2)
+ {
++	AbsoluteTime t1 = d1, t2 = d2;
++
+ 	if (t1 == INVALID_ABSTIME || t2 == INVALID_ABSTIME)
+ 		return FALSE;
+ 	if (t1 == CURRENT_ABSTIME)
+@@ -530,8 +541,10 @@
+ }
+ 
+ bool
+-abstimelt(AbsoluteTime t1, AbsoluteTime t2)
++abstimelt(Datum d1, Datum d2)
+ {
++	AbsoluteTime t1 = d1, t2 = d2;
++
+ 	if (t1 == INVALID_ABSTIME || t2 == INVALID_ABSTIME)
+ 		return FALSE;
+ 	if (t1 == CURRENT_ABSTIME)
+@@ -543,8 +556,10 @@
+ }
+ 
+ bool
+-abstimegt(AbsoluteTime t1, AbsoluteTime t2)
++abstimegt(Datum d1, Datum d2)
+ {
++	AbsoluteTime t1 = d1, t2 = d2;
++
+ 	if (t1 == INVALID_ABSTIME || t2 == INVALID_ABSTIME)
+ 		return FALSE;
+ 	if (t1 == CURRENT_ABSTIME)
+@@ -556,8 +571,10 @@
+ }
+ 
+ bool
+-abstimele(AbsoluteTime t1, AbsoluteTime t2)
++abstimele(Datum d1, Datum d2)
+ {
++	AbsoluteTime t1 = d1, t2 = d2;
++
+ 	if (t1 == INVALID_ABSTIME || t2 == INVALID_ABSTIME)
+ 		return FALSE;
+ 	if (t1 == CURRENT_ABSTIME)
+@@ -569,8 +586,10 @@
+ }
+ 
+ bool
+-abstimege(AbsoluteTime t1, AbsoluteTime t2)
++abstimege(Datum d1, Datum d2)
+ {
++	AbsoluteTime t1 = d1, t2 = d2;
++
+ 	if (t1 == INVALID_ABSTIME || t2 == INVALID_ABSTIME)
+ 		return FALSE;
+ 	if (t1 == CURRENT_ABSTIME)
+@@ -640,8 +659,9 @@
+  * Convert abstime to timestamp.
+  */
+ Timestamp  *
+-abstime_timestamp(AbsoluteTime abstime)
++abstime_timestamp(Datum d)
+ {
++	AbsoluteTime abstime = (AbsoluteTime)d;
+ 	Timestamp  *result;
+ 
+ 	if (!PointerIsValid(result = palloc(sizeof(Timestamp))))
+@@ -729,8 +749,9 @@
+  *		reltimeout		- converts the internal format to a reltime string
+  */
+ char *
+-reltimeout(RelativeTime time)
++reltimeout(Datum t)
+ {
++	RelativeTime time = (RelativeTime) t;
+ 	char	   *result;
+ 	struct tm	tt,
+ 			   *tm = &tt;
+@@ -755,8 +776,10 @@
+ 
+ 
+ static void
+-reltime2tm(RelativeTime time, struct tm * tm)
++reltime2tm(RelativeTime t, struct tm * tm)
+ {
++	RelativeTime time = (RelativeTime) t;
++
+ 	TMODULO(time, tm->tm_year, 31536000);
+ 	TMODULO(time, tm->tm_mon, 2592000);
+ 	TMODULO(time, tm->tm_mday, 86400);
+@@ -916,8 +939,9 @@
+ 
+ 
+ Interval   *
+-reltime_interval(RelativeTime reltime)
++reltime_interval(Datum d)
+ {
++        RelativeTime reltime = d;
+ 	Interval   *result;
+ 	int			year,
+ 				month;
+@@ -947,8 +971,9 @@
+  *		mktinterval		- creates a time interval with endpoints t1 and t2
+  */
+ TimeInterval
+-mktinterval(AbsoluteTime t1, AbsoluteTime t2)
++mktinterval(Datum d1, Datum d2)
+ {
++	AbsoluteTime t1 = d1, t2 = d2;
+ 	AbsoluteTime tstart = ABSTIMEMIN(t1, t2),
+ 				tend = ABSTIMEMAX(t1, t2);
+ 	TimeInterval interval;
+@@ -977,8 +1002,10 @@
+  *		timepl			- returns the value of (abstime t1 + relime t2)
+  */
+ AbsoluteTime
+-timepl(AbsoluteTime t1, RelativeTime t2)
++timepl(Datum d1, Datum d2)
+ {
++	AbsoluteTime t1 = d1;
++	RelativeTime t2 = d2;
+ 	if (t1 == CURRENT_ABSTIME)
+ 		t1 = GetCurrentTransactionStartTime();
+ 
+@@ -996,8 +1023,11 @@
+  *		timemi			- returns the value of (abstime t1 - reltime t2)
+  */
+ AbsoluteTime
+-timemi(AbsoluteTime t1, RelativeTime t2)
++timemi(Datum d1, Datum d2)
+ {
++	AbsoluteTime t1 = d1;
++	RelativeTime t2 = d2;
++
+ 	if (t1 == CURRENT_ABSTIME)
+ 		t1 = GetCurrentTransactionStartTime();
+ 
+@@ -1015,8 +1045,10 @@
+  *		abstimemi		- returns the value of (abstime t1 - abstime t2)
+  */
+ static RelativeTime
+-abstimemi(AbsoluteTime t1, AbsoluteTime t2)
++abstimemi(Datum d1, Datum d2)
+ {
++	AbsoluteTime t1 = d1, t2 = d2;
++
+ 	if (t1 == CURRENT_ABSTIME)
+ 		t1 = GetCurrentTransactionStartTime();
+ 	if (t2 == CURRENT_ABSTIME)
+@@ -1034,7 +1066,7 @@
+  *		intinterval		- returns 1, iff absolute date is in the interval
+  */
+ int
+-intinterval(AbsoluteTime t, TimeInterval interval)
++intinterval(Datum t, TimeInterval interval)
+ {
+ 	if (interval->status == T_INTERVAL_VALID && t != INVALID_ABSTIME)
+ 		return (abstimege(t, interval->data[0]) &&
+@@ -1048,6 +1080,7 @@
+ RelativeTime
+ tintervalrel(TimeInterval interval)
+ {
++
+ 	if (interval->status == T_INTERVAL_VALID)
+ 		return abstimemi(interval->data[1], interval->data[0]);
+ 	else
+@@ -1078,51 +1111,57 @@
+  *		reltimege		- returns 1, iff t1 greater than or equal to t2
+  */
+ bool
+-reltimeeq(RelativeTime t1, RelativeTime t2)
++reltimeeq(Datum t1, Datum t2)
+ {
+-	if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
++	if ((RelativeTime)t1 == INVALID_RELTIME 
++	||  (RelativeTime)t2 == INVALID_RELTIME)
+ 		return 0;
+-	return t1 == t2;
++	return (RelativeTime)t1 == (RelativeTime)t2;
+ }
+ 
+ bool
+-reltimene(RelativeTime t1, RelativeTime t2)
++reltimene(Datum t1, Datum t2)
+ {
+-	if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
++	if ((RelativeTime)t1 == INVALID_RELTIME 
++	||  (RelativeTime)t2 == INVALID_RELTIME)
+ 		return 0;
+-	return t1 != t2;
++	return (RelativeTime)t1 != (RelativeTime)t2;
+ }
+ 
+ bool
+-reltimelt(RelativeTime t1, RelativeTime t2)
++reltimelt(Datum t1, Datum t2)
+ {
+-	if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
++	if ((RelativeTime)t1 == INVALID_RELTIME 
++	||  (RelativeTime)t2 == INVALID_RELTIME)
+ 		return 0;
+-	return t1 < t2;
++	return (RelativeTime)t1 < (RelativeTime)t2;
+ }
+ 
+ bool
+-reltimegt(RelativeTime t1, RelativeTime t2)
++reltimegt(Datum t1, Datum t2)
+ {
+-	if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
++	if ((RelativeTime)t1 == INVALID_RELTIME 
++	||  (RelativeTime)t2 == INVALID_RELTIME)
+ 		return 0;
+-	return t1 > t2;
++	return (RelativeTime)t1 > (RelativeTime)t2;
+ }
+ 
+ bool
+-reltimele(RelativeTime t1, RelativeTime t2)
++reltimele(Datum t1, Datum t2)
+ {
+-	if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
++	if ((RelativeTime)t1 == INVALID_RELTIME 
++	||  (RelativeTime)t2 == INVALID_RELTIME)
+ 		return 0;
+-	return t1 <= t2;
++	return (RelativeTime)t1 <= (RelativeTime)t2;
+ }
+ 
+ bool
+-reltimege(RelativeTime t1, RelativeTime t2)
++reltimege(Datum t1, Datum t2)
+ {
+-	if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
++	if ((RelativeTime)t1 == INVALID_RELTIME 
++	||  (RelativeTime)t2 == INVALID_RELTIME)
+ 		return 0;
+-	return t1 >= t2;
++	return (RelativeTime)t1 >= (RelativeTime)t2;
+ }
+ 
+ 
+@@ -1362,8 +1401,9 @@
+  *								reltime t
+  */
+ bool
+-tintervalleneq(TimeInterval i, RelativeTime t)
++tintervalleneq(TimeInterval i, Datum d)
+ {
++        RelativeTime t = d;
+ 	RelativeTime rt;
+ 
+ 	if ((i->status == T_INTERVAL_INVAL) || (t == INVALID_RELTIME))
+@@ -1377,8 +1417,9 @@
+  *								to reltime t
+  */
+ bool
+-tintervallenne(TimeInterval i, RelativeTime t)
++tintervallenne(TimeInterval i, Datum d)
+ {
++        RelativeTime t = d;
+ 	RelativeTime rt;
+ 
+ 	if ((i->status == T_INTERVAL_INVAL) || (t == INVALID_RELTIME))
+@@ -1392,8 +1433,9 @@
+  *								reltime t
+  */
+ bool
+-tintervallenlt(TimeInterval i, RelativeTime t)
++tintervallenlt(TimeInterval i, Datum d)
+ {
++        RelativeTime t = d;
+ 	RelativeTime rt;
+ 
+ 	if ((i->status == T_INTERVAL_INVAL) || (t == INVALID_RELTIME))
+@@ -1407,8 +1449,9 @@
+  *								reltime t
+  */
+ bool
+-tintervallengt(TimeInterval i, RelativeTime t)
++tintervallengt(TimeInterval i, Datum d)
+ {
++        RelativeTime t = d;
+ 	RelativeTime rt;
+ 
+ 	if ((i->status == T_INTERVAL_INVAL) || (t == INVALID_RELTIME))
+@@ -1422,8 +1465,9 @@
+  *									than reltime t
+  */
+ bool
+-tintervallenle(TimeInterval i, RelativeTime t)
++tintervallenle(TimeInterval i, Datum d)
+ {
++        RelativeTime t = d;
+ 	RelativeTime rt;
+ 
+ 	if ((i->status == T_INTERVAL_INVAL) || (t == INVALID_RELTIME))
+@@ -1437,8 +1481,9 @@
+  *								equal than reltime t
+  */
+ bool
+-tintervallenge(TimeInterval i, RelativeTime t)
++tintervallenge(TimeInterval i, Datum d)
+ {
++        RelativeTime t = d;
+ 	RelativeTime rt;
+ 
+ 	if ((i->status == T_INTERVAL_INVAL) || (t == INVALID_RELTIME))
+--- backend/utils/adt/numeric.c.orig	Mon Feb 12 21:28:48 2001
++++ backend/utils/adt/numeric.c	Mon Feb 12 21:28:48 2001
+@@ -187,7 +187,7 @@
+  * ----------
+  */
+ Numeric
+-numeric_in(char *str, int dummy, int32 typmod)
++numeric_in(char *str, int dummy, Datum typmod)
+ {
+ 	NumericVar	value;
+ 	Numeric		res;
+@@ -217,7 +217,7 @@
+ 	init_var(&value);
+ 	set_var_from_str(str, &value);
+ 
+-	apply_typmod(&value, typmod);
++	apply_typmod(&value, (int32)typmod);
+ 
+ 	res = make_result(&value);
+ 	free_var(&value);
+@@ -1706,8 +1706,9 @@
+ 
+ 
+ Numeric
+-int4_numeric(int32 val)
++int4_numeric(Datum v)
+ {
++	int32 val = v;
+ 	Numeric		res;
+ 	NumericVar	result;
+ 	char	   *tmp;
+--- backend/utils/adt/oid.c.orig	Mon Feb 12 21:28:48 2001
++++ backend/utils/adt/oid.c	Mon Feb 12 21:28:48 2001
+@@ -185,17 +185,17 @@
+ }
+ 
+ bool
+-oideqint4(Oid arg1, int32 arg2)
++oideqint4(Oid arg1, Datum arg2)
+ {
+ /* oid is unsigned, but int4 is signed */
+-	return arg2 >= 0 && arg1 == arg2;
++	return (int32)arg2 >= 0 && arg1 == (int32)arg2;
+ }
+ 
+ bool
+-int4eqoid(int32 arg1, Oid arg2)
++int4eqoid(Datum arg1, Oid arg2)
+ {
+ /* oid is unsigned, but int4 is signed */
+-	return arg1 >= 0 && arg1 == arg2;
++	return (int32)arg1 >= 0 && (int32)arg1 == arg2;
+ }
+ 
+ text *
+--- backend/utils/adt/varchar.c.orig	Mon Feb 12 21:28:48 2001
++++ backend/utils/adt/varchar.c	Mon Feb 12 21:28:48 2001
+@@ -62,8 +62,9 @@
+  *	  because we pass typelem as the second argument for array_in.)
+  */
+ char *
+-bpcharin(char *s, int dummy, int32 atttypmod)
++bpcharin(char *s, Datum dummy, Datum a)
+ {
++	int32 atttypmod = a;
+ 	char	   *result,
+ 			   *r;
+ 	int			len;
+@@ -147,8 +148,9 @@
+  * len is the length specified in () plus VARHDRSZ bytes.
+  */
+ char *
+-bpchar(char *s, int32 len)
++bpchar(char *s, Datum l)
+ {
++	int32 len = l;
+ 	char	   *result,
+ 			   *r;
+ 	int			rlen,
+@@ -219,9 +221,9 @@
+  * len is the length specified in () plus VARHDRSZ bytes.
+  */
+ ArrayType  *
+-_bpchar(ArrayType *v, int32 len)
++_bpchar(ArrayType *v, Datum len)
+ {
+-	return array_map(v, BPCHAROID, bpchar, BPCHAROID, 1, len);
++	return array_map(v, BPCHAROID, bpchar, BPCHAROID, 1, (int32)len);
+ }
+ 
+ 
+@@ -238,7 +240,7 @@
+  * Convert char to bpchar(1).
+  */
+ char *
+-char_bpchar(int32 c)
++char_bpchar(Datum c)
+ {
+ 	char	   *result;
+ 
+@@ -330,8 +332,9 @@
+  *	  because we pass typelem as the second argument for array_in.)
+  */
+ char *
+-varcharin(char *s, int dummy, int32 atttypmod)
++varcharin(char *s, int dummy, Datum a)
+ {
++	int32 atttypmod = a;
+ 	char	   *result;
+ 	int			len;
+ 
+@@ -392,8 +395,9 @@
+  * slen is the length specified in () plus VARHDRSZ bytes.
+  */
+ char *
+-varchar(char *s, int32 slen)
++varchar(char *s, Datum ds)
+ {
++	int32	slen = ds;
+ 	char	   *result;
+ 	int			len;
+ 
+@@ -430,9 +434,9 @@
+  * len is the length specified in () plus VARHDRSZ bytes.
+  */
+ ArrayType  *
+-_varchar(ArrayType *v, int32 len)
++_varchar(ArrayType *v, Datum len)
+ {
+-	return array_map(v, VARCHAROID, varchar, VARCHAROID, 1, len);
++	return array_map(v, VARCHAROID, varchar, VARCHAROID, 1, (int32)len);
+ }
+ 
+ 
+--- backend/utils/adt/varlena.c.orig	Mon Feb 12 21:28:48 2001
++++ backend/utils/adt/varlena.c	Mon Feb 12 21:28:48 2001
+@@ -324,8 +324,9 @@
+  * - Thomas Lockhart 1998-12-10
+  */
+ text *
+-text_substr(text *string, int32 m, int32 n)
++text_substr(text *string, Datum dm, Datum dn)
+ {
++	int32 m = dm, n = dn;
+ 	text	   *ret;
+ 	int			len;
+ 
+--- include/access/hash.h.orig	Mon Feb 12 21:28:43 2001
++++ include/access/hash.h	Mon Feb 12 21:28:43 2001
+@@ -263,15 +263,15 @@
+ extern void hashdelete(Relation rel, ItemPointer tid);
+ 
+ /* hashfunc.c */
+-extern uint32 hashint2(int16 key);
+-extern uint32 hashint4(uint32 key);
++extern uint32 hashint2(Datum key);
++extern uint32 hashint4(Datum key);
+ extern uint32 hashint8(int64 *key);
+ extern uint32 hashfloat4(float32 keyp);
+ extern uint32 hashfloat8(float64 keyp);
+ extern uint32 hashoid(Oid key);
+ extern uint32 hashoidvector(Oid *key);
+ extern uint32 hashint2vector(int16 *key);
+-extern uint32 hashchar(char key);
++extern uint32 hashchar(Datum key);
+ extern uint32 hashtext(struct varlena * key);
+ extern uint32 hashname(NameData *n);
+ 
+--- include/utils/builtins.h.orig	Mon Feb 12 21:28:43 2001
++++ include/utils/builtins.h	Mon Feb 12 21:28:43 2001
+@@ -55,95 +55,95 @@
+ 
+ /* char.c */
+ extern int32 charin(char *ch);
+-extern char *charout(int32 ch);
++extern char *charout(Datum ch);
+ extern int32 cidin(char *s);
+-extern char *cidout(int32 c);
+-extern bool chareq(int8 arg1, int8 arg2);
+-extern bool charne(int8 arg1, int8 arg2);
+-extern bool charlt(int8 arg1, int8 arg2);
+-extern bool charle(int8 arg1, int8 arg2);
+-extern bool chargt(int8 arg1, int8 arg2);
+-extern bool charge(int8 arg1, int8 arg2);
+-extern int8 charpl(int8 arg1, int8 arg2);
+-extern int8 charmi(int8 arg1, int8 arg2);
+-extern int8 charmul(int8 arg1, int8 arg2);
+-extern int8 chardiv(int8 arg1, int8 arg2);
+-extern bool cideq(int8 arg1, int8 arg2);
++extern char *cidout(Datum c);
++extern bool chareq(Datum arg1, Datum arg2);
++extern bool charne(Datum arg1, Datum arg2);
++extern bool charlt(Datum arg1, Datum arg2);
++extern bool charle(Datum arg1, Datum arg2);
++extern bool chargt(Datum arg1, Datum arg2);
++extern bool charge(Datum arg1, Datum arg2);
++extern int8 charpl(Datum arg1, Datum arg2);
++extern int8 charmi(Datum arg1, Datum arg2);
++extern int8 charmul(Datum arg1, Datum arg2);
++extern int8 chardiv(Datum arg1, Datum arg2);
++extern bool cideq(Datum arg1, Datum arg2);
+ extern int8 text_char(text *arg1);
+-extern text *char_text(int8 arg1);
++extern text *char_text(Datum arg1);
+ 
+ /* int.c */
+ extern int32 int2in(char *num);
+-extern char *int2out(int16 sh);
++extern char *int2out(Datum sh);
+ extern int16 *int2vectorin(char *shs);
+ extern char *int2vectorout(int16 *shs);
+ extern bool int2vectoreq(int16 *arg1, int16 *arg2);
+ extern int32 *int44in(char *input_string);
+ extern char *int44out(int32 *an_array);
+ extern int32 int4in(char *num);
+-extern char *int4out(int32 l);
+-extern int32 i2toi4(int16 arg1);
+-extern int16 i4toi2(int32 arg1);
+-extern text *int2_text(int16 arg1);
++extern char *int4out(Datum l);
++extern int32 i2toi4(Datum arg1);
++extern int16 i4toi2(Datum arg1);
++extern text *int2_text(Datum arg1);
+ extern int16 text_int2(text *arg1);
+-extern text *int4_text(int32 arg1);
++extern text *int4_text(Datum arg1);
+ extern int32 text_int4(text *arg1);
+-extern bool int4eq(int32 arg1, int32 arg2);
+-extern bool int4ne(int32 arg1, int32 arg2);
+-extern bool int4lt(int32 arg1, int32 arg2);
+-extern bool int4le(int32 arg1, int32 arg2);
+-extern bool int4gt(int32 arg1, int32 arg2);
+-extern bool int4ge(int32 arg1, int32 arg2);
+-extern bool int2eq(int16 arg1, int16 arg2);
+-extern bool int2ne(int16 arg1, int16 arg2);
+-extern bool int2lt(int16 arg1, int16 arg2);
+-extern bool int2le(int16 arg1, int16 arg2);
+-extern bool int2gt(int16 arg1, int16 arg2);
+-extern bool int2ge(int16 arg1, int16 arg2);
+-extern bool int24eq(int32 arg1, int32 arg2);
+-extern bool int24ne(int32 arg1, int32 arg2);
+-extern bool int24lt(int32 arg1, int32 arg2);
+-extern bool int24le(int32 arg1, int32 arg2);
+-extern bool int24gt(int32 arg1, int32 arg2);
+-extern bool int24ge(int32 arg1, int32 arg2);
+-extern bool int42eq(int32 arg1, int32 arg2);
+-extern bool int42ne(int32 arg1, int32 arg2);
+-extern bool int42lt(int32 arg1, int32 arg2);
+-extern bool int42le(int32 arg1, int32 arg2);
+-extern bool int42gt(int32 arg1, int32 arg2);
+-extern bool int42ge(int32 arg1, int32 arg2);
+-extern int32 int4um(int32 arg);
+-extern int32 int4pl(int32 arg1, int32 arg2);
+-extern int32 int4mi(int32 arg1, int32 arg2);
+-extern int32 int4mul(int32 arg1, int32 arg2);
+-extern int32 int4div(int32 arg1, int32 arg2);
+-extern int32 int4abs(int32 arg);
+-extern int32 int4inc(int32 arg);
+-extern int16 int2um(int16 arg);
+-extern int16 int2pl(int16 arg1, int16 arg2);
+-extern int16 int2mi(int16 arg1, int16 arg2);
+-extern int16 int2mul(int16 arg1, int16 arg2);
+-extern int16 int2div(int16 arg1, int16 arg2);
+-extern int16 int2abs(int16 arg);
+-extern int16 int2inc(int16 arg);
+-extern int32 int24pl(int32 arg1, int32 arg2);
+-extern int32 int24mi(int32 arg1, int32 arg2);
+-extern int32 int24mul(int32 arg1, int32 arg2);
+-extern int32 int24div(int32 arg1, int32 arg2);
+-extern int32 int42pl(int32 arg1, int32 arg2);
+-extern int32 int42mi(int32 arg1, int32 arg2);
+-extern int32 int42mul(int32 arg1, int32 arg2);
+-extern int32 int42div(int32 arg1, int32 arg2);
+-extern int32 int4mod(int32 arg1, int32 arg2);
+-extern int32 int2mod(int16 arg1, int16 arg2);
+-extern int32 int24mod(int32 arg1, int32 arg2);
+-extern int32 int42mod(int32 arg1, int32 arg2);
+-extern int32 int4fac(int32 arg1);
+-extern int32 int2fac(int16 arg1);
+-extern int16 int2larger(int16 arg1, int16 arg2);
+-extern int16 int2smaller(int16 arg1, int16 arg2);
+-extern int32 int4larger(int32 arg1, int32 arg2);
+-extern int32 int4smaller(int32 arg1, int32 arg2);
++extern bool int4eq(Datum arg1, Datum arg2);
++extern bool int4ne(Datum arg1, Datum arg2);
++extern bool int4lt(Datum arg1, Datum arg2);
++extern bool int4le(Datum arg1, Datum arg2);
++extern bool int4gt(Datum arg1, Datum arg2);
++extern bool int4ge(Datum arg1, Datum arg2);
++extern bool int2eq(Datum arg1, Datum arg2);
++extern bool int2ne(Datum arg1, Datum arg2);
++extern bool int2lt(Datum arg1, Datum arg2);
++extern bool int2le(Datum arg1, Datum arg2);
++extern bool int2gt(Datum arg1, Datum arg2);
++extern bool int2ge(Datum arg1, Datum arg2);
++extern bool int24eq(Datum arg1, Datum arg2);
++extern bool int24ne(Datum arg1, Datum arg2);
++extern bool int24lt(Datum arg1, Datum arg2);
++extern bool int24le(Datum arg1, Datum arg2);
++extern bool int24gt(Datum arg1, Datum arg2);
++extern bool int24ge(Datum arg1, Datum arg2);
++extern bool int42eq(Datum arg1, Datum arg2);
++extern bool int42ne(Datum arg1, Datum arg2);
++extern bool int42lt(Datum arg1, Datum arg2);
++extern bool int42le(Datum arg1, Datum arg2);
++extern bool int42gt(Datum arg1, Datum arg2);
++extern bool int42ge(Datum arg1, Datum arg2);
++extern int32 int4um(Datum arg);
++extern int32 int4pl(Datum arg1, Datum arg2);
++extern int32 int4mi(Datum arg1, Datum arg2);
++extern int32 int4mul(Datum arg1, Datum arg2);
++extern int32 int4div(Datum arg1, Datum arg2);
++extern int32 int4abs(Datum arg);
++extern int32 int4inc(Datum arg);
++extern int16 int2um(Datum arg);
++extern int16 int2pl(Datum arg1, Datum arg2);
++extern int16 int2mi(Datum arg1, Datum arg2);
++extern int16 int2mul(Datum arg1, Datum arg2);
++extern int16 int2div(Datum arg1, Datum arg2);
++extern int16 int2abs(Datum arg);
++extern int16 int2inc(Datum arg);
++extern int32 int24pl(Datum arg1, Datum arg2);
++extern int32 int24mi(Datum arg1, Datum arg2);
++extern int32 int24mul(Datum arg1, Datum arg2);
++extern int32 int24div(Datum arg1, Datum arg2);
++extern int32 int42pl(Datum arg1, Datum arg2);
++extern int32 int42mi(Datum arg1, Datum arg2);
++extern int32 int42mul(Datum arg1, Datum arg2);
++extern int32 int42div(Datum arg1, Datum arg2);
++extern int32 int4mod(Datum arg1, Datum arg2);
++extern int32 int2mod(Datum arg1, Datum arg2);
++extern int32 int24mod(Datum arg1, Datum arg2);
++extern int32 int42mod(Datum arg1, Datum arg2);
++extern int32 int4fac(Datum arg1);
++extern int32 int2fac(Datum arg1);
++extern int16 int2larger(Datum arg1, Datum arg2);
++extern int16 int2smaller(Datum arg1, Datum arg2);
++extern int32 int4larger(Datum arg1, Datum arg2);
++extern int32 int4smaller(Datum arg1, Datum arg2);
+ 
+ /* name.c */
+ extern NameData *namein(const char *s);
+@@ -177,17 +177,17 @@
+  *		Per-opclass comparison functions for new btrees.  These are
+  *		stored in pg_amproc and defined in nbtree/
+  */
+-extern int32 btint2cmp(int16 a, int16 b);
+-extern int32 btint4cmp(int32 a, int32 b);
++extern int32 btint2cmp(Datum a, Datum b);
++extern int32 btint4cmp(Datum a, Datum b);
+ extern int32 btint8cmp(int64 *a, int64 *b);
+-extern int32 btint24cmp(int16 a, int32 b);
+-extern int32 btint42cmp(int32 a, int16 b);
++extern int32 btint24cmp(Datum a, Datum b);
++extern int32 btint42cmp(Datum a, Datum b);
+ extern int32 btfloat4cmp(float32 a, float32 b);
+ extern int32 btfloat8cmp(float64 a, float64 b);
+ extern int32 btoidcmp(Oid a, Oid b);
+ extern int32 btoidvectorcmp(Oid *a, Oid *b);
+-extern int32 btabstimecmp(AbsoluteTime a, AbsoluteTime b);
+-extern int32 btcharcmp(char a, char b);
++extern int32 btabstimecmp(Datum a, Datum b);
++extern int32 btcharcmp(Datum a, Datum b);
+ extern int32 btnamecmp(NameData *a, NameData *b);
+ extern int32 bttextcmp(struct varlena * a, struct varlena * b);
+ extern int32 btboolcmp(bool a, bool b);
+@@ -252,13 +252,13 @@
+ extern bool float8gt(float64 arg1, float64 arg2);
+ extern bool float8ge(float64 arg1, float64 arg2);
+ extern float64 ftod(float32 num);
+-extern float64 i4tod(int32 num);
+-extern float64 i2tod(int16 num);
++extern float64 i4tod(Datum num);
++extern float64 i2tod(Datum num);
+ extern float32 dtof(float64 num);
+ extern int32 dtoi4(float64 num);
+ extern int16 dtoi2(float64 num);
+-extern float32 i4tof(int32 num);
+-extern float32 i2tof(int16 num);
++extern float32 i4tof(Datum num);
++extern float32 i2tof(Datum num);
+ extern int32 ftoi4(float32 num);
+ extern int16 ftoi2(float32 num);
+ extern float64 text_float8(text *str);
+@@ -337,8 +337,8 @@
+ extern bool oidvectorle(Oid *arg1, Oid *arg2);
+ extern bool oidvectorge(Oid *arg1, Oid *arg2);
+ extern bool oidvectorgt(Oid *arg1, Oid *arg2);
+-extern bool oideqint4(Oid arg1, int32 arg2);
+-extern bool int4eqoid(int32 arg1, Oid arg2);
++extern bool oideqint4(Oid arg1, Datum arg2);
++extern bool int4eqoid(Datum arg1, Oid arg2);
+ extern text *oid_text(Oid arg1);
+ extern Oid	text_oid(text *arg1);
+ 
+@@ -461,11 +461,11 @@
+ extern ItemPointer currtid_byrelname(const text *relName, ItemPointer);
+ 
+ /* varchar.c */
+-extern char *bpcharin(char *s, int dummy, int32 atttypmod);
++extern char *bpcharin(char *s, Datum dummy, Datum atttypmod);
+ extern char *bpcharout(char *s);
+-extern char *bpchar(char *s, int32 slen);
+-extern ArrayType *_bpchar(ArrayType *v, int32 slen);
+-extern char *char_bpchar(int32 c);
++extern char *bpchar(char *s, Datum slen);
++extern ArrayType *_bpchar(ArrayType *v, Datum slen);
++extern char *char_bpchar(Datum c);
+ extern int32 bpchar_char(char *s);
+ extern char *name_bpchar(NameData *s);
+ extern NameData *bpchar_name(char *s);
+@@ -480,10 +480,10 @@
+ extern int32 bpcharoctetlen(char *arg);
+ extern uint32 hashbpchar(struct varlena * key);
+ 
+-extern char *varcharin(char *s, int dummy, int32 atttypmod);
++extern char *varcharin(char *s, int dummy, Datum atttypmod);
+ extern char *varcharout(char *s);
+-extern char *varchar(char *s, int32 slen);
+-extern ArrayType *_varchar(ArrayType *v, int32 slen);
++extern char *varchar(char *s, Datum slen);
++extern ArrayType *_varchar(ArrayType *v, Datum slen);
+ extern bool varchareq(char *arg1, char *arg2);
+ extern bool varcharne(char *arg1, char *arg2);
+ extern bool varcharlt(char *arg1, char *arg2);
+@@ -511,7 +511,7 @@
+ extern int32 textlen(text *arg);
+ extern int32 textoctetlen(text *arg);
+ extern int32 textpos(text *arg1, text *arg2);
+-extern text *text_substr(text *string, int32 m, int32 n);
++extern text *text_substr(text *string, Datum m, Datum n);
+ extern text *name_text(NameData *s);
+ extern NameData *text_name(text *s);
+ 
+@@ -590,7 +590,7 @@
+ extern text *macaddr_manuf(macaddr *addr);
+ 
+ /* numeric.c */
+-extern Numeric numeric_in(char *str, int dummy, int32 typmod);
++extern Numeric numeric_in(char *str, int dummy, Datum typmod);
+ extern char *numeric_out(Numeric num);
+ extern Numeric numeric(Numeric num, int32 typmod);
+ extern Numeric numeric_abs(Numeric num);
+@@ -621,7 +621,7 @@
+ extern Numeric numeric_ln(Numeric num);
+ extern Numeric numeric_log(Numeric num1, Numeric num2);
+ extern Numeric numeric_power(Numeric num1, Numeric num2);
+-extern Numeric int4_numeric(int32 val);
++extern Numeric int4_numeric(Datum val);
+ extern int32 numeric_int4(Numeric num);
+ extern Numeric int8_numeric(int64 *val);
+ extern int64 *numeric_int8(Numeric num);
+--- include/utils/int8.h.orig	Mon Feb 12 21:28:43 2001
++++ include/utils/int8.h	Mon Feb 12 21:28:43 2001
+@@ -57,19 +57,19 @@
+ extern bool int8le(int64 *val1, int64 *val2);
+ extern bool int8ge(int64 *val1, int64 *val2);
+ 
+-extern bool int84eq(int64 *val1, int32 val2);
+-extern bool int84ne(int64 *val1, int32 val2);
+-extern bool int84lt(int64 *val1, int32 val2);
+-extern bool int84gt(int64 *val1, int32 val2);
+-extern bool int84le(int64 *val1, int32 val2);
+-extern bool int84ge(int64 *val1, int32 val2);
++extern bool int84eq(int64 *val1, Datum val2);
++extern bool int84ne(int64 *val1, Datum val2);
++extern bool int84lt(int64 *val1, Datum val2);
++extern bool int84gt(int64 *val1, Datum val2);
++extern bool int84le(int64 *val1, Datum val2);
++extern bool int84ge(int64 *val1, Datum val2);
+ 
+-extern bool int48eq(int32 val1, int64 *val2);
+-extern bool int48ne(int32 val1, int64 *val2);
+-extern bool int48lt(int32 val1, int64 *val2);
+-extern bool int48gt(int32 val1, int64 *val2);
+-extern bool int48le(int32 val1, int64 *val2);
+-extern bool int48ge(int32 val1, int64 *val2);
++extern bool int48eq(Datum val1, int64 *val2);
++extern bool int48ne(Datum val1, int64 *val2);
++extern bool int48lt(Datum val1, int64 *val2);
++extern bool int48gt(Datum val1, int64 *val2);
++extern bool int48le(Datum val1, int64 *val2);
++extern bool int48ge(Datum val1, int64 *val2);
+ 
+ extern int64 *int8um(int64 *val);
+ extern int64 *int8pl(int64 *val1, int64 *val2);
+@@ -82,17 +82,17 @@
+ extern int64 *int8larger(int64 *val1, int64 *val2);
+ extern int64 *int8smaller(int64 *val1, int64 *val2);
+ 
+-extern int64 *int84pl(int64 *val1, int32 val2);
+-extern int64 *int84mi(int64 *val1, int32 val2);
+-extern int64 *int84mul(int64 *val1, int32 val2);
+-extern int64 *int84div(int64 *val1, int32 val2);
++extern int64 *int84pl(int64 *val1, Datum val2);
++extern int64 *int84mi(int64 *val1, Datum val2);
++extern int64 *int84mul(int64 *val1, Datum val2);
++extern int64 *int84div(int64 *val1, Datum val2);
+ 
+-extern int64 *int48pl(int32 val1, int64 *val2);
+-extern int64 *int48mi(int32 val1, int64 *val2);
+-extern int64 *int48mul(int32 val1, int64 *val2);
+-extern int64 *int48div(int32 val1, int64 *val2);
++extern int64 *int48pl(Datum val1, int64 *val2);
++extern int64 *int48mi(Datum val1, int64 *val2);
++extern int64 *int48mul(Datum val1, int64 *val2);
++extern int64 *int48div(Datum val1, int64 *val2);
+ 
+-extern int64 *int48(int32 val);
++extern int64 *int48(Datum val);
+ extern int32 int84(int64 *val);
+ 
+ #ifdef NOT_USED
+--- include/utils/nabstime.h.orig	Mon Feb 12 21:28:43 2001
++++ include/utils/nabstime.h	Mon Feb 12 21:28:43 2001
+@@ -105,43 +105,43 @@
+  * nabstime.c prototypes
+  */
+ extern AbsoluteTime nabstimein(char *timestr);
+-extern char *nabstimeout(AbsoluteTime time);
++extern char *nabstimeout(Datum time);
+ 
+-extern bool abstimeeq(AbsoluteTime t1, AbsoluteTime t2);
+-extern bool abstimene(AbsoluteTime t1, AbsoluteTime t2);
+-extern bool abstimelt(AbsoluteTime t1, AbsoluteTime t2);
+-extern bool abstimegt(AbsoluteTime t1, AbsoluteTime t2);
+-extern bool abstimele(AbsoluteTime t1, AbsoluteTime t2);
+-extern bool abstimege(AbsoluteTime t1, AbsoluteTime t2);
+-extern bool abstime_finite(AbsoluteTime time);
++extern bool abstimeeq(Datum t1, Datum t2);
++extern bool abstimene(Datum t1, Datum t2);
++extern bool abstimelt(Datum t1, Datum t2);
++extern bool abstimegt(Datum t1, Datum t2);
++extern bool abstimele(Datum t1, Datum t2);
++extern bool abstimege(Datum t1, Datum t2);
++extern bool abstime_finite(Datum time);
+ 
+ extern AbsoluteTime timestamp_abstime(Timestamp *timestamp);
+-extern Timestamp *abstime_timestamp(AbsoluteTime abstime);
++extern Timestamp *abstime_timestamp(Datum abstime);
+ 
+-extern bool AbsoluteTimeIsBefore(AbsoluteTime time1, AbsoluteTime time2);
++extern bool AbsoluteTimeIsBefore(Datum time1, Datum time2);
+ 
+-extern void abstime2tm(AbsoluteTime time, int *tzp, struct tm * tm, char *tzn);
++extern void abstime2tm(Datum time, int *tzp, struct tm * tm, char *tzn);
+ 
+ extern RelativeTime reltimein(char *timestring);
+-extern char *reltimeout(RelativeTime timevalue);
++extern char *reltimeout(Datum timevalue);
+ extern TimeInterval tintervalin(char *intervalstr);
+ extern char *tintervalout(TimeInterval interval);
+ extern RelativeTime interval_reltime(Interval *interval);
+-extern Interval *reltime_interval(RelativeTime reltime);
+-extern TimeInterval mktinterval(AbsoluteTime t1, AbsoluteTime t2);
+-extern AbsoluteTime timepl(AbsoluteTime t1, RelativeTime t2);
+-extern AbsoluteTime timemi(AbsoluteTime t1, RelativeTime t2);
++extern Interval *reltime_interval(Datum reltime);
++extern TimeInterval mktinterval(Datum t1, Datum t2);
++extern AbsoluteTime timepl(Datum t1, Datum t2);
++extern AbsoluteTime timemi(Datum t1, Datum t2);
+ 
+ /* extern RelativeTime abstimemi(AbsoluteTime t1, AbsoluteTime t2);  static*/
+-extern int	intinterval(AbsoluteTime t, TimeInterval interval);
++extern int	intinterval(Datum t, TimeInterval interval);
+ extern RelativeTime tintervalrel(TimeInterval interval);
+ extern AbsoluteTime timenow(void);
+-extern bool reltimeeq(RelativeTime t1, RelativeTime t2);
+-extern bool reltimene(RelativeTime t1, RelativeTime t2);
+-extern bool reltimelt(RelativeTime t1, RelativeTime t2);
+-extern bool reltimegt(RelativeTime t1, RelativeTime t2);
+-extern bool reltimele(RelativeTime t1, RelativeTime t2);
+-extern bool reltimege(RelativeTime t1, RelativeTime t2);
++extern bool reltimeeq(Datum t1, Datum t2);
++extern bool reltimene(Datum t1, Datum t2);
++extern bool reltimelt(Datum t1, Datum t2);
++extern bool reltimegt(Datum t1, Datum t2);
++extern bool reltimele(Datum t1, Datum t2);
++extern bool reltimege(Datum t1, Datum t2);
+ extern bool tintervalsame(TimeInterval i1, TimeInterval i2);
+ extern bool tintervaleq(TimeInterval i1, TimeInterval i2);
+ extern bool tintervalne(TimeInterval i1, TimeInterval i2);
+@@ -149,12 +149,12 @@
+ extern bool tintervalgt(TimeInterval i1, TimeInterval i2);
+ extern bool tintervalle(TimeInterval i1, TimeInterval i2);
+ extern bool tintervalge(TimeInterval i1, TimeInterval i2);
+-extern bool tintervalleneq(TimeInterval i, RelativeTime t);
+-extern bool tintervallenne(TimeInterval i, RelativeTime t);
+-extern bool tintervallenlt(TimeInterval i, RelativeTime t);
+-extern bool tintervallengt(TimeInterval i, RelativeTime t);
+-extern bool tintervallenle(TimeInterval i, RelativeTime t);
+-extern bool tintervallenge(TimeInterval i, RelativeTime t);
++extern bool tintervalleneq(TimeInterval i, Datum t);
++extern bool tintervallenne(TimeInterval i, Datum t);
++extern bool tintervallenlt(TimeInterval i, Datum t);
++extern bool tintervallengt(TimeInterval i, Datum t);
++extern bool tintervallenle(TimeInterval i, Datum t);
++extern bool tintervallenge(TimeInterval i, Datum t);
+ extern bool tintervalct(TimeInterval i1, TimeInterval i2);
+ extern bool tintervalov(TimeInterval i1, TimeInterval i2);
+ extern AbsoluteTime tintervalstart(TimeInterval i);