diff -uNr pgsql/src/backend/access/hash/hashfunc.c pgsql.alpha/src/backend/access/hash/hashfunc.c
--- pgsql/src/backend/access/hash/hashfunc.c	Mon Feb 21 02:00:07 2000
+++ pgsql.alpha/src/backend/access/hash/hashfunc.c	Fri Mar 10 18:38:36 2000
@@ -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;
diff -uNr pgsql/src/backend/access/nbtree/nbtcompare.c pgsql.alpha/src/backend/access/nbtree/nbtcompare.c
--- pgsql/src/backend/access/nbtree/nbtcompare.c	Sat Feb 12 02:00:06 2000
+++ pgsql.alpha/src/backend/access/nbtree/nbtcompare.c	Fri Mar 10 18:42:02 2000
@@ -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);
 }
diff -uNr pgsql/src/backend/utils/adt/char.c pgsql.alpha/src/backend/utils/adt/char.c
--- pgsql/src/backend/utils/adt/char.c	Wed Jan 26 02:00:28 2000
+++ pgsql.alpha/src/backend/utils/adt/char.c	Tue Feb 29 09:45:18 2000
@@ -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;
 }
diff -uNr pgsql/src/backend/utils/adt/float.c pgsql.alpha/src/backend/utils/adt/float.c
--- pgsql/src/backend/utils/adt/float.c	Wed Jan 26 02:00:28 2000
+++ pgsql.alpha/src/backend/utils/adt/float.c	Tue Feb 29 09:45:18 2000
@@ -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));
 
diff -uNr pgsql/src/backend/utils/adt/int.c pgsql.alpha/src/backend/utils/adt/int.c
--- pgsql/src/backend/utils/adt/int.c	Mon Feb 21 02:00:23 2000
+++ pgsql.alpha/src/backend/utils/adt/int.c	Fri Mar 10 19:07:58 2000
@@ -62,7 +62,7 @@
  *		int2out			- converts short to "num"
  */
 char *
-int2out(int16 sh)
+int2out(Datum sh)
 {
 	char	   *result;
 
@@ -226,12 +226,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;
 }
 
@@ -243,14 +243,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)
@@ -260,7 +262,7 @@
 }
 
 text *
-int2_text(int16 arg1)
+int2_text(Datum arg1)
 {
 	text	   *result;
 
@@ -301,7 +303,7 @@
 }	/* text_int2() */
 
 text *
-int4_text(int32 arg1)
+int4_text(Datum arg1)
 {
 	text	   *result;
 
@@ -357,147 +359,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;
 }
 
 /*
@@ -507,159 +509,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		- returns arg1!
  */
 int32
-int4fac(int32 arg1)
+int4fac(Datum arg)
 {
 	int32		result;
+	int32	arg1 = (int32) arg;
 
 	if (arg1 < 1)
 		result = 0;
@@ -670,9 +673,10 @@
 }
 
 int32
-int2fac(int16 arg1)
+int2fac(Datum arg)
 {
 	int16		result;
+	int16		arg1 = (int16) arg;
 
 	if (arg1 < 1)
 		result = 0;
@@ -683,25 +687,25 @@
 }
 
 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;
 }
diff -uNr pgsql/src/backend/utils/adt/nabstime.c pgsql.alpha/src/backend/utils/adt/nabstime.c
--- pgsql/src/backend/utils/adt/nabstime.c	Thu Feb 17 02:00:14 2000
+++ pgsql.alpha/src/backend/utils/adt/nabstime.c	Sat Mar 18 19:48:38 2000
@@ -207,11 +207,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 */
 
@@ -220,10 +220,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
 
@@ -299,8 +299,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
@@ -402,8 +402,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;
@@ -448,8 +449,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));
 
@@ -464,8 +467,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));
 
@@ -483,8 +488,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() */
@@ -499,8 +506,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)
@@ -512,8 +521,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)
@@ -525,8 +536,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)
@@ -538,8 +551,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)
@@ -551,8 +566,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)
@@ -564,8 +581,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)
@@ -635,8 +654,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))))
@@ -724,8 +744,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;
@@ -750,8 +771,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);
@@ -911,8 +934,9 @@
 
 
 Interval   *
-reltime_interval(RelativeTime reltime)
+reltime_interval(Datum d)
 {
+        RelativeTime reltime = d;
 	Interval   *result;
 	int			year,
 				month;
@@ -942,8 +966,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;
@@ -972,8 +997,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();
 
@@ -991,8 +1018,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();
 
@@ -1010,8 +1040,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)
@@ -1029,7 +1061,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]) &&
@@ -1043,6 +1075,7 @@
 RelativeTime
 tintervalrel(TimeInterval interval)
 {
+
 	if (interval->status == T_INTERVAL_VALID)
 		return abstimemi(interval->data[1], interval->data[0]);
 	else
@@ -1073,51 +1106,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;
 }
 
 
@@ -1357,8 +1396,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))
@@ -1372,8 +1412,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))
@@ -1387,8 +1428,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))
@@ -1402,8 +1444,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))
@@ -1417,8 +1460,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))
@@ -1432,8 +1476,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))
diff -uNr pgsql/src/backend/utils/adt/numeric.c pgsql.alpha/src/backend/utils/adt/numeric.c
--- pgsql/src/backend/utils/adt/numeric.c	Thu Jan 20 02:00:14 2000
+++ pgsql.alpha/src/backend/utils/adt/numeric.c	Tue Feb 29 09:45:18 2000
@@ -184,7 +184,7 @@
  * ----------
  */
 Numeric
-numeric_in(char *str, int dummy, int32 typmod)
+numeric_in(char *str, int dummy, Datum typmod)
 {
 	NumericVar	value;
 	Numeric		res;
@@ -214,7 +214,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);
@@ -1597,8 +1597,9 @@
  * ----------------------------------------------------------------------
  */
 Numeric
-int4_numeric(int32 val)
+int4_numeric(Datum v)
 {
+	int32 val = v;
 	Numeric		res;
 	NumericVar	result;
 	char	   *tmp;
diff -uNr pgsql/src/backend/utils/adt/oid.c pgsql.alpha/src/backend/utils/adt/oid.c
--- pgsql/src/backend/utils/adt/oid.c	Wed Jan 26 02:00:30 2000
+++ pgsql.alpha/src/backend/utils/adt/oid.c	Tue Feb 29 09:45:18 2000
@@ -184,17 +184,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 *
diff -uNr pgsql/src/backend/utils/adt/varchar.c pgsql.alpha/src/backend/utils/adt/varchar.c
--- pgsql/src/backend/utils/adt/varchar.c	Wed Jan 26 02:00:30 2000
+++ pgsql.alpha/src/backend/utils/adt/varchar.c	Tue Feb 29 09:45:18 2000
@@ -61,8 +61,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;
@@ -138,8 +139,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,
@@ -213,9 +215,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);
 }
 
 
@@ -232,7 +234,7 @@
  * Convert char to bpchar(1).
  */
 char *
-char_bpchar(int32 c)
+char_bpchar(Datum c)
 {
 	char	   *result;
 
@@ -324,8 +326,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;
 
@@ -382,8 +385,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;
 
@@ -424,9 +428,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);
 }
 
 
diff -uNr pgsql/src/backend/utils/adt/varlena.c pgsql.alpha/src/backend/utils/adt/varlena.c
--- pgsql/src/backend/utils/adt/varlena.c	Wed Jan 26 02:00:30 2000
+++ pgsql.alpha/src/backend/utils/adt/varlena.c	Tue Feb 29 09:45:18 2000
@@ -327,8 +327,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;
 
diff -uNr pgsql/src/include/access/hash.h pgsql.alpha/src/include/access/hash.h
--- pgsql/src/include/access/hash.h	Mon Feb 21 02:00:25 2000
+++ pgsql.alpha/src/include/access/hash.h	Fri Mar 10 19:22:25 2000
@@ -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);
 
diff -uNr pgsql/src/include/utils/builtins.h pgsql.alpha/src/include/utils/builtins.h
--- pgsql/src/include/utils/builtins.h	Mon Feb 21 02:00:26 2000
+++ pgsql.alpha/src/include/utils/builtins.h	Fri Mar 10 19:55:11 2000
@@ -53,93 +53,93 @@
 
 /* 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 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 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 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 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);
@@ -172,17 +172,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);
@@ -247,13 +247,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);
@@ -316,8 +316,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);
 
@@ -392,11 +392,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);
@@ -411,10 +411,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);
@@ -442,7 +442,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);
 
@@ -516,7 +516,7 @@
 text	   *macaddr_manuf(macaddr *addr);
 
 /* numeric.c */
-Numeric		numeric_in(char *str, int dummy, int32 typmod);
+Numeric		numeric_in(char *str, int dummy, Datum typmod);
 char	   *numeric_out(Numeric num);
 Numeric		numeric(Numeric num, int32 typmod);
 Numeric		numeric_abs(Numeric num);
@@ -546,7 +546,7 @@
 Numeric		numeric_ln(Numeric num);
 Numeric		numeric_log(Numeric num1, Numeric num2);
 Numeric		numeric_power(Numeric num1, Numeric num2);
-Numeric		int4_numeric(int32 val);
+Numeric		int4_numeric(Datum val);
 int32		numeric_int4(Numeric num);
 Numeric		float4_numeric(float32 val);
 float32		numeric_float4(Numeric num);
diff -uNr pgsql/src/include/utils/nabstime.h pgsql.alpha/src/include/utils/nabstime.h
--- pgsql/src/include/utils/nabstime.h	Thu Feb 17 02:00:18 2000
+++ pgsql.alpha/src/include/utils/nabstime.h	Sun Mar 12 19:24:05 2000
@@ -110,43 +110,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);
@@ -154,12 +154,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);
diff -uNr pgsql/src/template/linux_alpha pgsql.alpha/src/template/linux_alpha
--- pgsql/src/template/linux_alpha	Fri Jul 30 02:00:39 1999
+++ pgsql.alpha/src/template/linux_alpha	Fri Mar 10 20:13:03 2000
@@ -8,3 +8,4 @@
 DLSUFFIX:.so
 YFLAGS:-d
 YACC:bison -y
+CPU:alpha