From 48165ec2262b73c5b81a6caabab66d883d013a83 Mon Sep 17 00:00:00 2001
From: Tom Lane <tgl@sss.pgh.pa.us>
Date: Mon, 5 Jun 2000 07:29:25 +0000
Subject: [PATCH] Latest round of fmgr updates.  All functions with bool,char,
 or int2 inputs have been converted to newstyle.  This should go a long way
 towards fixing our portability problems with platforms where char and short
 parameters are passed differently from int-width parameters.  Still more to
 do for the Alpha port however.

---
 src/backend/access/hash/hashfunc.c            | 209 +++--
 src/backend/access/nbtree/nbtcompare.c        | 206 +++--
 src/backend/access/transam/xid.c              |  43 +-
 src/backend/bootstrap/bootstrap.c             |   6 +-
 src/backend/commands/comment.c                |   2 +-
 src/backend/commands/copy.c                   |   9 +-
 src/backend/parser/parse_expr.c               |   5 +-
 src/backend/storage/large_object/inv_api.c    |   5 +-
 src/backend/storage/smgr/smgr.c               |  18 +-
 src/backend/storage/smgr/smgrtype.c           |  47 +-
 src/backend/tcop/fastpath.c                   |   4 +-
 src/backend/utils/adt/acl.c                   |  21 +-
 src/backend/utils/adt/bool.c                  | 157 +++-
 src/backend/utils/adt/cash.c                  |  76 +-
 src/backend/utils/adt/char.c                  | 218 +++--
 src/backend/utils/adt/float.c                 |  79 +-
 src/backend/utils/adt/formatting.c            |  10 +-
 src/backend/utils/adt/geo_selfuncs.c          |  86 +-
 src/backend/utils/adt/int.c                   | 761 ++++++++++--------
 src/backend/utils/adt/misc.c                  |  73 +-
 src/backend/utils/adt/numeric.c               |  34 +-
 src/backend/utils/adt/oid.c                   | 193 +++--
 src/backend/utils/adt/regproc.c               |  64 +-
 src/backend/utils/adt/selfuncs.c              | 441 ++++------
 src/backend/utils/adt/varchar.c               |  44 +-
 src/backend/utils/cache/catcache.c            |  48 +-
 src/backend/utils/fmgr/fmgr.c                 | 170 ++--
 src/include/access/hash.h                     |  34 +-
 src/include/access/xact.h                     |   8 +-
 src/include/catalog/catversion.h              |   4 +-
 src/include/catalog/pg_operator.h             |  26 +-
 src/include/catalog/pg_proc.h                 | 424 +++++-----
 src/include/catalog/pg_type.h                 |  28 +-
 src/include/fmgr.h                            |  65 +-
 src/include/storage/smgr.h                    |  10 +-
 src/include/utils/builtins.h                  | 396 +++++----
 src/include/utils/cash.h                      |   6 +-
 src/include/utils/catcache.h                  |   6 +-
 src/include/utils/geo_decls.h                 |  21 +-
 src/pl/plperl/plperl.c                        |   5 +-
 src/pl/plpgsql/src/gram.y                     |   4 +-
 src/pl/tcl/pltcl.c                            |   5 +-
 src/test/regress/expected/opr_sanity.out      |  42 +-
 .../regress/input/create_function_2.source    |   2 +-
 .../regress/output/create_function_2.source   |   2 +-
 src/test/regress/regress.c                    |  24 +-
 src/test/regress/sql/opr_sanity.sql           |  42 +-
 47 files changed, 2175 insertions(+), 2008 deletions(-)

diff --git a/src/backend/access/hash/hashfunc.c b/src/backend/access/hash/hashfunc.c
index 80d9ac3741..9a6d36f205 100644
--- a/src/backend/access/hash/hashfunc.c
+++ b/src/backend/access/hash/hashfunc.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/hash/hashfunc.c,v 1.25 2000/04/12 17:14:44 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/hash/hashfunc.c,v 1.26 2000/06/05 07:28:35 tgl Exp $
  *
  * NOTES
  *	  These functions are stored in pg_amproc.	For each operator class
@@ -21,134 +21,132 @@
 
 #include "access/hash.h"
 
-uint32
-hashint2(int16 key)
+Datum
+hashint2(PG_FUNCTION_ARGS)
 {
-	return (uint32) ~key;
+	PG_RETURN_UINT32((uint32) ~ PG_GETARG_INT16(0));
 }
 
-uint32
-hashint4(uint32 key)
+Datum
+hashint4(PG_FUNCTION_ARGS)
 {
-	return ~key;
+	PG_RETURN_UINT32(~ PG_GETARG_UINT32(0));
 }
 
-uint32
-hashint8(int64 *key)
+Datum
+hashint8(PG_FUNCTION_ARGS)
 {
-	return ~((uint32) *key);
+	/* we just use the low 32 bits... */
+	PG_RETURN_UINT32(~((uint32) PG_GETARG_INT64(0)));
 }
 
 /* Hash function from Chris Torek. */
-uint32
-hashfloat4(float32 keyp)
+Datum
+hashfloat4(PG_FUNCTION_ARGS)
 {
-	int			len;
+	float4		key = PG_GETARG_FLOAT4(0);
+	char	   *kp = (char *) &key;
+	int			len = sizeof(key);
 	int			loop;
 	uint32		h;
-	char	   *kp = (char *) keyp;
-
-	len = sizeof(float32data);
 
 #define HASH4a	 h = (h << 5) - h + *kp++;
 #define HASH4b	 h = (h << 5) + h + *kp++;
 #define HASH4 HASH4b
 
-
 	h = 0;
-	if (len > 0)
-	{
-		loop = (len + 8 - 1) >> 3;
+	/*
+	 * This is a tad silly, given that we expect len = 4, but a smart
+	 * compiler should be able to eliminate the redundant code...
+	 */
+	loop = (len + 8 - 1) >> 3;
 
-		switch (len & (8 - 1))
-		{
-			case 0:
-				do
-				{				/* All fall throughs */
-					HASH4;
-			case 7:
-					HASH4;
-			case 6:
-					HASH4;
-			case 5:
-					HASH4;
-			case 4:
-					HASH4;
-			case 3:
-					HASH4;
-			case 2:
-					HASH4;
-			case 1:
-					HASH4;
-				} while (--loop);
-		}
+	switch (len & (8 - 1))
+	{
+		case 0:
+			do
+			{					/* All fall throughs */
+				HASH4;
+		case 7:
+				HASH4;
+		case 6:
+				HASH4;
+		case 5:
+				HASH4;
+		case 4:
+				HASH4;
+		case 3:
+				HASH4;
+		case 2:
+				HASH4;
+		case 1:
+				HASH4;
+			} while (--loop);
 	}
-	return h;
+	PG_RETURN_UINT32(h);
 }
 
-
-uint32
-hashfloat8(float64 keyp)
+Datum
+hashfloat8(PG_FUNCTION_ARGS)
 {
-	int			len;
+	float8		key = PG_GETARG_FLOAT8(0);
+	char	   *kp = (char *) &key;
+	int			len = sizeof(key);
 	int			loop;
 	uint32		h;
-	char	   *kp = (char *) keyp;
-
-	len = sizeof(float64data);
 
 #define HASH4a	 h = (h << 5) - h + *kp++;
 #define HASH4b	 h = (h << 5) + h + *kp++;
 #define HASH4 HASH4b
 
-
 	h = 0;
-	if (len > 0)
-	{
-		loop = (len + 8 - 1) >> 3;
+	/*
+	 * This is a tad silly, given that we expect len = 8, but a smart
+	 * compiler should be able to eliminate the redundant code...
+	 */
+	loop = (len + 8 - 1) >> 3;
 
-		switch (len & (8 - 1))
-		{
-			case 0:
-				do
-				{				/* All fall throughs */
-					HASH4;
-			case 7:
-					HASH4;
-			case 6:
-					HASH4;
-			case 5:
-					HASH4;
-			case 4:
-					HASH4;
-			case 3:
-					HASH4;
-			case 2:
-					HASH4;
-			case 1:
-					HASH4;
-				} while (--loop);
-		}
+	switch (len & (8 - 1))
+	{
+		case 0:
+			do
+			{					/* All fall throughs */
+				HASH4;
+		case 7:
+				HASH4;
+		case 6:
+				HASH4;
+		case 5:
+				HASH4;
+		case 4:
+				HASH4;
+		case 3:
+				HASH4;
+		case 2:
+				HASH4;
+		case 1:
+				HASH4;
+			} while (--loop);
 	}
-	return h;
+	PG_RETURN_UINT32(h);
 }
 
-
-uint32
-hashoid(Oid key)
+Datum
+hashoid(PG_FUNCTION_ARGS)
 {
-	return (uint32) ~key;
+	PG_RETURN_UINT32(~(uint32) PG_GETARG_OID(0));
 }
 
-uint32
-hashoidvector(Oid *key)
+Datum
+hashoidvector(PG_FUNCTION_ARGS)
 {
+	Oid		   *key = (Oid *) PG_GETARG_POINTER(0);
 	int			i;
 	uint32		result = 0;
 
 	for (i = INDEX_MAX_KEYS; --i >= 0;)
 		result = (result << 1) ^ (~(uint32) key[i]);
-	return result;
+	PG_RETURN_UINT32(result);
 }
 
 /*
@@ -156,55 +154,50 @@ hashoidvector(Oid *key)
  * hash function, because it has no pg_proc entry.	We only need it
  * for catcache indexing.
  */
-uint32
-hashint2vector(int16 *key)
+Datum
+hashint2vector(PG_FUNCTION_ARGS)
 {
+	int16	   *key = (int16 *) PG_GETARG_POINTER(0);
 	int			i;
 	uint32		result = 0;
 
 	for (i = INDEX_MAX_KEYS; --i >= 0;)
 		result = (result << 1) ^ (~(uint32) key[i]);
-	return result;
+	PG_RETURN_UINT32(result);
 }
 
 
 #define PRIME1			37
 #define PRIME2			1048583
 
-uint32
-hashchar(char key)
+Datum
+hashchar(PG_FUNCTION_ARGS)
 {
 	uint32		h;
 
 	/* Convert char to integer */
-	h = (key - ' ');
+	h = (PG_GETARG_CHAR(0) - ' ');
 	h %= PRIME2;
 
-	return h;
+	PG_RETURN_UINT32(h);
 }
 
-
-uint32
-hashname(NameData *n)
+Datum
+hashname(PG_FUNCTION_ARGS)
 {
+	char	   *key = NameStr(* PG_GETARG_NAME(0));
+	int			len = NAMEDATALEN;
 	uint32		h;
-	int			len;
-	char	   *key;
-
-	key = NameStr(*n);
 
 	h = 0;
-	len = NAMEDATALEN;
 	/* Convert string to integer */
 	while (len--)
 		h = h * PRIME1 ^ (*key++ - ' ');
 	h %= PRIME2;
 
-	return h;
+	PG_RETURN_UINT32(h);
 }
 
-
-
 /*
  * (Comment from the original db3 hashing code: )
  *
@@ -216,19 +209,17 @@ hashname(NameData *n)
  *
  * "OZ's original sdbm hash"
  */
-uint32
-hashtext(struct varlena * key)
+Datum
+hashtext(PG_FUNCTION_ARGS)
 {
+	text	   *key = PG_GETARG_TEXT_P(0);
 	int			keylen;
 	char	   *keydata;
 	uint32		n;
 	int			loop;
 
 	keydata = VARDATA(key);
-	keylen = VARSIZE(key);
-
-	/* keylen includes the four bytes in which string keylength is stored */
-	keylen -= sizeof(VARSIZE(key));
+	keylen = VARSIZE(key) - VARHDRSZ;
 
 #define HASHC	n = *keydata++ + 65599 * n
 
@@ -260,5 +251,5 @@ hashtext(struct varlena * key)
 				} while (--loop);
 		}
 	}
-	return n;
+	PG_RETURN_UINT32(n);
 }
diff --git a/src/backend/access/nbtree/nbtcompare.c b/src/backend/access/nbtree/nbtcompare.c
index 3e58c677a0..aba0151c83 100644
--- a/src/backend/access/nbtree/nbtcompare.c
+++ b/src/backend/access/nbtree/nbtcompare.c
@@ -8,141 +8,203 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtcompare.c,v 1.34 2000/04/12 17:14:49 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtcompare.c,v 1.35 2000/06/05 07:28:36 tgl Exp $
  *
- *	NOTES
- *		These functions are stored in pg_amproc.  For each operator class
- *		defined on btrees, they compute
+ * NOTES
+ *
+ *	These functions are stored in pg_amproc.  For each operator class
+ *	defined on btrees, they compute
  *
  *				compare(a, b):
  *						< 0 if a < b,
  *						= 0 if a == b,
  *						> 0 if a > b.
+ *
+ *	The result is always an int32 regardless of the input datatype.
+ *
+ *	NOTE: although any negative int32 is acceptable for reporting "<",
+ *	and any positive int32 is acceptable for reporting ">", routines
+ *	that work on 32-bit or wider datatypes can't just return "a - b".
+ *	That could overflow and give the wrong answer.
+ *
  *-------------------------------------------------------------------------
  */
 
-
 #include "postgres.h"
 
 #include "utils/builtins.h"
 
-int32
-btint2cmp(int16 a, int16 b)
+Datum
+btboolcmp(PG_FUNCTION_ARGS)
 {
-	return (int32) (a - b);
+	bool		a = PG_GETARG_BOOL(0);
+	bool		b = PG_GETARG_BOOL(1);
+
+	PG_RETURN_INT32((int32) a - (int32) b);
 }
 
-int32
-btint4cmp(int32 a, int32 b)
+Datum
+btint2cmp(PG_FUNCTION_ARGS)
+{
+	int16		a = PG_GETARG_INT16(0);
+	int16		b = PG_GETARG_INT16(1);
+
+	PG_RETURN_INT32((int32) a - (int32) b);
+}
+
+Datum
+btint4cmp(PG_FUNCTION_ARGS)
 {
+	int32		a = PG_GETARG_INT32(0);
+	int32		b = PG_GETARG_INT32(1);
+
 	if (a > b)
-		return 1;
+		PG_RETURN_INT32(1);
 	else if (a == b)
-		return 0;
+		PG_RETURN_INT32(0);
 	else
-		return -1;
+		PG_RETURN_INT32(-1);
 }
 
-int32
-btint8cmp(int64 *a, int64 *b)
+Datum
+btint8cmp(PG_FUNCTION_ARGS)
 {
-	if (*a > *b)
-		return 1;
-	else if (*a == *b)
-		return 0;
+	int64		a = PG_GETARG_INT64(0);
+	int64		b = PG_GETARG_INT64(1);
+
+	if (a > b)
+		PG_RETURN_INT32(1);
+	else if (a == b)
+		PG_RETURN_INT32(0);
 	else
-		return -1;
+		PG_RETURN_INT32(-1);
 }
 
-int32
-btint24cmp(int16 a, int32 b)
+Datum
+btint24cmp(PG_FUNCTION_ARGS)
 {
-	return ((int32) a) - b;
+	int16		a = PG_GETARG_INT16(0);
+	int32		b = PG_GETARG_INT32(1);
+
+	if (a > b)
+		PG_RETURN_INT32(1);
+	else if (a == b)
+		PG_RETURN_INT32(0);
+	else
+		PG_RETURN_INT32(-1);
 }
 
-int32
-btint42cmp(int32 a, int16 b)
+Datum
+btint42cmp(PG_FUNCTION_ARGS)
 {
-	return a - ((int32) b);
+	int32		a = PG_GETARG_INT32(0);
+	int16		b = PG_GETARG_INT16(1);
+
+	if (a > b)
+		PG_RETURN_INT32(1);
+	else if (a == b)
+		PG_RETURN_INT32(0);
+	else
+		PG_RETURN_INT32(-1);
 }
 
-int32
-btfloat4cmp(float32 a, float32 b)
+Datum
+btfloat4cmp(PG_FUNCTION_ARGS)
 {
-	if (*a > *b)
-		return 1;
-	else if (*a == *b)
-		return 0;
+	float4		a = PG_GETARG_FLOAT4(0);
+	float4		b = PG_GETARG_FLOAT4(1);
+
+	if (a > b)
+		PG_RETURN_INT32(1);
+	else if (a == b)
+		PG_RETURN_INT32(0);
 	else
-		return -1;
+		PG_RETURN_INT32(-1);
 }
 
-int32
-btfloat8cmp(float64 a, float64 b)
+Datum
+btfloat8cmp(PG_FUNCTION_ARGS)
 {
-	if (*a > *b)
-		return 1;
-	else if (*a == *b)
-		return 0;
+	float8		a = PG_GETARG_FLOAT8(0);
+	float8		b = PG_GETARG_FLOAT8(1);
+
+	if (a > b)
+		PG_RETURN_INT32(1);
+	else if (a == b)
+		PG_RETURN_INT32(0);
 	else
-		return -1;
+		PG_RETURN_INT32(-1);
 }
 
-int32
-btoidcmp(Oid a, Oid b)
+Datum
+btoidcmp(PG_FUNCTION_ARGS)
 {
+	Oid			a = PG_GETARG_OID(0);
+	Oid			b = PG_GETARG_OID(1);
+
 	if (a > b)
-		return 1;
+		PG_RETURN_INT32(1);
 	else if (a == b)
-		return 0;
+		PG_RETURN_INT32(0);
 	else
-		return -1;
+		PG_RETURN_INT32(-1);
 }
 
-int32
-btoidvectorcmp(Oid *a, Oid *b)
+Datum
+btoidvectorcmp(PG_FUNCTION_ARGS)
 {
+	Oid		   *a = (Oid *) PG_GETARG_POINTER(0);
+	Oid		   *b = (Oid *) PG_GETARG_POINTER(1);
 	int			i;
 
 	for (i = 0; i < INDEX_MAX_KEYS; i++)
-		/* we use this because we need the int4gt, etc */
-		if (!int4eq(a[i], b[i]))
+	{
+		if (a[i] != b[i])
 		{
-			if (int4gt(a[i], b[i]))
-				return 1;
+			if (a[i] > b[i])
+				PG_RETURN_INT32(1);
 			else
-				return -1;
+				PG_RETURN_INT32(-1);
 		}
-	return 0;
+	}
+	PG_RETURN_INT32(0);
 }
 
-
 int32
 btabstimecmp(AbsoluteTime a, AbsoluteTime b)
 {
 	if (AbsoluteTimeIsBefore(a, b))
-		return -1;
+		PG_RETURN_INT32(-1);
 	else if (AbsoluteTimeIsBefore(b, a))
-		return 1;
+		PG_RETURN_INT32(1);
 	else
-		return 0;
+		PG_RETURN_INT32(0);
 }
 
-int32
-btcharcmp(char a, char b)
+Datum
+btcharcmp(PG_FUNCTION_ARGS)
 {
-	return (int32) ((uint8) a - (uint8) b);
+	char		a = PG_GETARG_CHAR(0);
+	char		b = PG_GETARG_CHAR(1);
+
+	/* Be careful to compare chars as unsigned */
+	PG_RETURN_INT32((int32) ((uint8) a) - (int32) ((uint8) b));
 }
 
-int32
-btnamecmp(NameData *a, NameData *b)
+Datum
+btnamecmp(PG_FUNCTION_ARGS)
 {
-	return strncmp(NameStr(*a), NameStr(*b), NAMEDATALEN);
+	Name		a = PG_GETARG_NAME(0);
+	Name		b = PG_GETARG_NAME(1);
+
+	PG_RETURN_INT32(strncmp(NameStr(*a), NameStr(*b), NAMEDATALEN));
 }
 
-int32
-bttextcmp(struct varlena * a, struct varlena * b)
+Datum
+bttextcmp(PG_FUNCTION_ARGS)
 {
+	text	   *a = PG_GETARG_TEXT_P(0);
+	text	   *b = PG_GETARG_TEXT_P(1);
 	int			res;
 	unsigned char *ap,
 			   *bp;
@@ -187,7 +249,7 @@ bttextcmp(struct varlena * a, struct varlena * b)
 	{
 		do
 		{
-			res = (int) (*ap++ - *bp++);
+			res = (int) *ap++ - (int) *bp++;
 			len--;
 		} while (res == 0 && len != 0);
 	}
@@ -195,7 +257,7 @@ bttextcmp(struct varlena * a, struct varlena * b)
 #endif
 
 	if (res != 0 || VARSIZE(a) == VARSIZE(b))
-		return res;
+		PG_RETURN_INT32(res);
 
 	/*
 	 * The two strings are the same in the first len bytes, and they are
@@ -203,13 +265,7 @@ bttextcmp(struct varlena * a, struct varlena * b)
 	 */
 
 	if (VARSIZE(a) < VARSIZE(b))
-		return -1;
+		PG_RETURN_INT32(-1);
 	else
-		return 1;
-}
-
-int32
-btboolcmp(bool a, bool b)
-{
-	return (int32) ((uint8) a - (uint8) b);
+		PG_RETURN_INT32(1);
 }
diff --git a/src/backend/access/transam/xid.c b/src/backend/access/transam/xid.c
index df5c59543c..28171a7f33 100644
--- a/src/backend/access/transam/xid.c
+++ b/src/backend/access/transam/xid.c
@@ -1,12 +1,12 @@
 /*-------------------------------------------------------------------------
  *
  * xid.c
- *	  POSTGRES transaction identifier code.
+ *	  POSTGRES transaction identifier type.
  *
  * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- *	$Id: xid.c,v 1.27 2000/01/26 05:56:04 momjian Exp $
+ *	$Id: xid.c,v 1.28 2000/06/05 07:28:38 tgl Exp $
  *
  * OLD COMMENTS
  * XXX WARNING
@@ -19,33 +19,42 @@
  *-------------------------------------------------------------------------
  */
 
-
 #include "postgres.h"
+
 #include "access/xact.h"
 
+/*
+ * TransactionId is typedef'd as uint32, so...
+ */
+#define PG_GETARG_TRANSACTIONID(n)  PG_GETARG_UINT32(n)
+#define PG_RETURN_TRANSACTIONID(x)  PG_RETURN_UINT32(x)
+
+
 extern TransactionId NullTransactionId;
 extern TransactionId DisabledTransactionId;
 extern TransactionId AmiTransactionId;
 extern TransactionId FirstTransactionId;
 
 /* XXX name for catalogs */
-TransactionId
-xidin(char *representation)
+Datum
+xidin(PG_FUNCTION_ARGS)
 {
-	return atol(representation);
+	char	   *representation = PG_GETARG_CSTRING(0);
+
+	PG_RETURN_TRANSACTIONID((TransactionId) atol(representation));
 }
 
 /* XXX name for catalogs */
-char *
-xidout(TransactionId transactionId)
+Datum
+xidout(PG_FUNCTION_ARGS)
 {
+	TransactionId transactionId = PG_GETARG_TRANSACTIONID(0);
 	/* maximum 32 bit unsigned integer representation takes 10 chars */
 	char	   *representation = palloc(11);
 
-	snprintf(representation, 11, "%u", transactionId);
-
-	return representation;
+	snprintf(representation, 11, "%lu", (unsigned long) transactionId);
 
+	PG_RETURN_CSTRING(representation);
 }
 
 /* ----------------------------------------------------------------
@@ -57,13 +66,14 @@ xidout(TransactionId transactionId)
  *		xideq			- returns 1, iff xid1 == xid2
  *								  0  else;
  */
-bool
-xideq(TransactionId xid1, TransactionId xid2)
+Datum
+xideq(PG_FUNCTION_ARGS)
 {
-	return (bool) (xid1 == xid2);
-}
-
+	TransactionId xid1 = PG_GETARG_TRANSACTIONID(0);
+	TransactionId xid2 = PG_GETARG_TRANSACTIONID(1);
 
+	PG_RETURN_BOOL(xid1 == xid2);
+}
 
 /* ----------------------------------------------------------------
  *		TransactionIdAdd
@@ -73,5 +83,4 @@ void
 TransactionIdAdd(TransactionId *xid, int value)
 {
 	*xid += value;
-	return;
 }
diff --git a/src/backend/bootstrap/bootstrap.c b/src/backend/bootstrap/bootstrap.c
index 9c0f58e159..e8aa2a7402 100644
--- a/src/backend/bootstrap/bootstrap.c
+++ b/src/backend/bootstrap/bootstrap.c
@@ -8,7 +8,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/bootstrap/bootstrap.c,v 1.84 2000/05/31 00:28:14 petere Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/bootstrap/bootstrap.c,v 1.85 2000/06/05 07:28:40 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -38,7 +38,7 @@
 #include "utils/lsyscache.h"
 #include "utils/portal.h"
 
-#define ALLOC(t, c)		(t *)calloc((unsigned)(c), sizeof(t))
+#define ALLOC(t, c)		((t *) calloc((unsigned)(c), sizeof(t)))
 
 extern void BaseInit(void);
 extern void StartupXLOG(void);
@@ -112,7 +112,7 @@ static struct typinfo Procid[] = {
 	{"int4", INT4OID, 0, 4, F_INT4IN, F_INT4OUT},
 	{"regproc", REGPROCOID, 0, 4, F_REGPROCIN, F_REGPROCOUT},
 	{"text", TEXTOID, 0, -1, F_TEXTIN, F_TEXTOUT},
-	{"oid", OIDOID, 0, 4, F_INT4IN, F_INT4OUT},
+	{"oid", OIDOID, 0, 4, F_OIDIN, F_OIDOUT},
 	{"tid", TIDOID, 0, 6, F_TIDIN, F_TIDOUT},
 	{"xid", XIDOID, 0, 4, F_XIDIN, F_XIDOUT},
 	{"cid", CIDOID, 0, 4, F_CIDIN, F_CIDOUT},
diff --git a/src/backend/commands/comment.c b/src/backend/commands/comment.c
index cd2c71359f..9739c68ffd 100644
--- a/src/backend/commands/comment.c
+++ b/src/backend/commands/comment.c
@@ -772,7 +772,7 @@ CommentOperator(char *opername, List *arguments, char *comment)
 	/*** Get the procedure associated with the operator ***/
 
 	data = (Form_pg_operator) GETSTRUCT(optuple);
-	oid = regproctooid(data->oprcode);
+	oid = RegprocToOid(data->oprcode);
 	if (oid == InvalidOid)
 		elog(ERROR, "operator '%s' does not have an underlying function", opername);
 
diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index adba62242a..68773ba14e 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/commands/copy.c,v 1.110 2000/06/02 15:57:18 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/commands/copy.c,v 1.111 2000/06/05 07:28:42 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -473,7 +473,9 @@ CopyTo(Relation rel, bool binary, bool oids, FILE *fp, char *delim, char *null_p
 
 		if (oids && !binary)
 		{
-			CopySendString(oidout(tuple->t_data->t_oid), fp);
+			CopySendString(DatumGetCString(DirectFunctionCall1(oidout,
+									ObjectIdGetDatum(tuple->t_data->t_oid))),
+						   fp);
 			CopySendChar(delim[0], fp);
 		}
 
@@ -782,7 +784,8 @@ CopyFrom(Relation rel, bool binary, bool oids, FILE *fp, char *delim, char *null
 					done = 1;
 				else
 				{
-					loaded_oid = oidin(string);
+					loaded_oid = DatumGetObjectId(DirectFunctionCall1(oidin,
+												  CStringGetDatum(string)));
 					if (loaded_oid == InvalidOid)
 						elog(ERROR, "COPY TEXT: Invalid Oid");
 				}
diff --git a/src/backend/parser/parse_expr.c b/src/backend/parser/parse_expr.c
index ed8ee41e45..b2785f820a 100644
--- a/src/backend/parser/parse_expr.c
+++ b/src/backend/parser/parse_expr.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.79 2000/05/30 00:49:50 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.80 2000/06/05 07:28:43 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -892,7 +892,8 @@ parser_typecast_constant(Value *expr, TypeName *typename)
 	{
 		case T_Integer:
 			string_palloced = true;
-			const_string = int4out(expr->val.ival);
+			const_string = DatumGetCString(DirectFunctionCall1(int4out,
+										   Int32GetDatum(expr->val.ival)));
 			break;
 		case T_Float:
 		case T_String:
diff --git a/src/backend/storage/large_object/inv_api.c b/src/backend/storage/large_object/inv_api.c
index 6f60e902ca..506a12a0a9 100644
--- a/src/backend/storage/large_object/inv_api.c
+++ b/src/backend/storage/large_object/inv_api.c
@@ -9,7 +9,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/storage/large_object/inv_api.c,v 1.68 2000/05/28 17:56:03 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/storage/large_object/inv_api.c,v 1.69 2000/06/05 07:28:45 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -174,7 +174,8 @@ inv_create(int flags)
 	if (!RelationIsValid(indr))
 	{
 		elog(ERROR, "cannot create index for large obj on %s under inversion",
-			 smgrout(DEFAULT_SMGR));
+			 DatumGetCString(DirectFunctionCall1(smgrout,
+							 Int16GetDatum(DEFAULT_SMGR))));
 	}
 
 	retval = (LargeObjectDesc *) palloc(sizeof(LargeObjectDesc));
diff --git a/src/backend/storage/smgr/smgr.c b/src/backend/storage/smgr/smgr.c
index 3b857cd319..419cc8610f 100644
--- a/src/backend/storage/smgr/smgr.c
+++ b/src/backend/storage/smgr/smgr.c
@@ -11,7 +11,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/storage/smgr/smgr.c,v 1.35 2000/04/12 17:15:42 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/storage/smgr/smgr.c,v 1.36 2000/06/05 07:28:47 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -105,7 +105,9 @@ smgrinit()
 		if (smgrsw[i].smgr_init)
 		{
 			if ((*(smgrsw[i].smgr_init)) () == SM_FAIL)
-				elog(FATAL, "initialization failed on %s", smgrout(i));
+				elog(FATAL, "initialization failed on %s",
+					 DatumGetCString(DirectFunctionCall1(smgrout,
+														 Int16GetDatum(i))));
 		}
 	}
 
@@ -125,7 +127,9 @@ smgrshutdown(int dummy)
 		if (smgrsw[i].smgr_shutdown)
 		{
 			if ((*(smgrsw[i].smgr_shutdown)) () == SM_FAIL)
-				elog(FATAL, "shutdown failed on %s", smgrout(i));
+				elog(FATAL, "shutdown failed on %s",
+					 DatumGetCString(DirectFunctionCall1(smgrout,
+														 Int16GetDatum(i))));
 		}
 	}
 }
@@ -445,7 +449,9 @@ smgrcommit()
 		if (smgrsw[i].smgr_commit)
 		{
 			if ((*(smgrsw[i].smgr_commit)) () == SM_FAIL)
-				elog(FATAL, "transaction commit failed on %s", smgrout(i));
+				elog(FATAL, "transaction commit failed on %s",
+					 DatumGetCString(DirectFunctionCall1(smgrout,
+														 Int16GetDatum(i))));
 		}
 	}
 
@@ -462,7 +468,9 @@ smgrabort()
 		if (smgrsw[i].smgr_abort)
 		{
 			if ((*(smgrsw[i].smgr_abort)) () == SM_FAIL)
-				elog(FATAL, "transaction abort failed on %s", smgrout(i));
+				elog(FATAL, "transaction abort failed on %s",
+					 DatumGetCString(DirectFunctionCall1(smgrout,
+														 Int16GetDatum(i))));
 		}
 	}
 
diff --git a/src/backend/storage/smgr/smgrtype.c b/src/backend/storage/smgr/smgrtype.c
index e6cd6c3bf4..49d08e1a7a 100644
--- a/src/backend/storage/smgr/smgrtype.c
+++ b/src/backend/storage/smgr/smgrtype.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/storage/smgr/smgrtype.c,v 1.16 2000/01/26 05:57:05 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/storage/smgr/smgrtype.c,v 1.17 2000/06/05 07:28:47 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -37,45 +37,48 @@ static smgrid StorageManager[] = {
 
 static int	NStorageManagers = lengthof(StorageManager);
 
-int2
-smgrin(char *s)
+Datum
+smgrin(PG_FUNCTION_ARGS)
 {
-	int			i;
+	char	   *s = PG_GETARG_CSTRING(0);
+	int16		i;
 
 	for (i = 0; i < NStorageManagers; i++)
 	{
 		if (strcmp(s, StorageManager[i].smgr_name) == 0)
-			return (int2) i;
+			PG_RETURN_INT16(i);
 	}
-	elog(ERROR, "smgrin: illegal storage manager name %s", s);
-	return 0;
+	elog(ERROR, "smgrin: unknown storage manager name '%s'", s);
+	PG_RETURN_INT16(0);
 }
 
-char *
-smgrout(int2 i)
+Datum
+smgrout(PG_FUNCTION_ARGS)
 {
+	int16		i = PG_GETARG_INT16(0);
 	char	   *s;
 
 	if (i >= NStorageManagers || i < 0)
 		elog(ERROR, "Illegal storage manager id %d", i);
 
-	s = (char *) palloc(strlen(StorageManager[i].smgr_name) + 1);
-	strcpy(s, StorageManager[i].smgr_name);
-	return s;
+	s = pstrdup(StorageManager[i].smgr_name);
+	PG_RETURN_CSTRING(s);
 }
 
-bool
-smgreq(int2 a, int2 b)
+Datum
+smgreq(PG_FUNCTION_ARGS)
 {
-	if (a == b)
-		return true;
-	return false;
+	int16		a = PG_GETARG_INT16(0);
+	int16		b = PG_GETARG_INT16(1);
+
+	PG_RETURN_BOOL(a == b);
 }
 
-bool
-smgrne(int2 a, int2 b)
+Datum
+smgrne(PG_FUNCTION_ARGS)
 {
-	if (a == b)
-		return false;
-	return true;
+	int16		a = PG_GETARG_INT16(0);
+	int16		b = PG_GETARG_INT16(1);
+
+	PG_RETURN_BOOL(a != b);
 }
diff --git a/src/backend/tcop/fastpath.c b/src/backend/tcop/fastpath.c
index 45c62f365e..10ff95b962 100644
--- a/src/backend/tcop/fastpath.c
+++ b/src/backend/tcop/fastpath.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/tcop/fastpath.c,v 1.40 2000/05/30 07:09:23 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/tcop/fastpath.c,v 1.41 2000/06/05 07:28:49 tgl Exp $
  *
  * NOTES
  *	  This cruft is the server side of PQfn.
@@ -164,7 +164,7 @@ valid_fp_info(Oid func_id, struct fp_info * fip)
 	Assert(fip != (struct fp_info *) NULL);
 
 	return (OidIsValid(fip->funcid) &&
-			oideq(func_id, fip->funcid) &&
+			func_id == fip->funcid &&
 			TransactionIdIsCurrentTransactionId(fip->xid) &&
 			CommandIdIsCurrentCommandId(fip->cid));
 }
diff --git a/src/backend/utils/adt/acl.c b/src/backend/utils/adt/acl.c
index 6c27fbe03f..0a6c664e7d 100644
--- a/src/backend/utils/adt/acl.c
+++ b/src/backend/utils/adt/acl.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/acl.c,v 1.45 2000/04/12 17:15:47 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/acl.c,v 1.46 2000/06/05 07:28:51 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -21,6 +21,7 @@
 #include "catalog/pg_type.h"
 #include "lib/stringinfo.h"
 #include "utils/acl.h"
+#include "utils/builtins.h"
 #include "utils/memutils.h"
 #include "utils/syscache.h"
 
@@ -268,7 +269,6 @@ aclitemout(AclItem *aip)
 	static AclItem default_aclitem = {ACL_ID_WORLD,
 		ACL_IDTYPE_WORLD,
 	ACL_WORLD_DEFAULT};
-	extern char *int2out();
 	char	   *tmpname;
 
 	if (!aip)
@@ -287,20 +287,11 @@ aclitemout(AclItem *aip)
 									   0, 0, 0);
 			if (!HeapTupleIsValid(htup))
 			{
-				char	   *tmp = int2out(aip->ai_id);
-
-#ifdef NOT_USED
-
-				When this	elog(NOTICE) goes to the libpq client,
-							it crashes the
-							client because the NOTICE protocol is coming right in the middle
-							of a request for a field value.We skip the NOTICE for now.
-
-							elog(NOTICE, "aclitemout: usesysid %d not found",
-											 aip->ai_id);
-
-#endif
+				/* Generate numeric UID if we don't find an entry */
+				char	   *tmp;
 
+				tmp = DatumGetCString(DirectFunctionCall1(int4out,
+									  Int32GetDatum((int32) aip->ai_id)));
 				strcat(p, tmp);
 				pfree(tmp);
 			}
diff --git a/src/backend/utils/adt/bool.c b/src/backend/utils/adt/bool.c
index c5657babcf..bdf695aa52 100644
--- a/src/backend/utils/adt/bool.c
+++ b/src/backend/utils/adt/bool.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/bool.c,v 1.22 2000/02/10 19:51:39 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/bool.c,v 1.23 2000/06/05 07:28:51 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -29,43 +29,45 @@
  *
  * In the switch statement, check the most-used possibilities first.
  */
-bool
-boolin(char *b)
+Datum
+boolin(PG_FUNCTION_ARGS)
 {
+	char	   *b = PG_GETARG_CSTRING(0);
+
 	switch (*b)
 	{
 			case 't':
 			case 'T':
 			if (strncasecmp(b, "true", strlen(b)) == 0)
-				return TRUE;
+				PG_RETURN_BOOL(true);
 			break;
 
 		case 'f':
 		case 'F':
 			if (strncasecmp(b, "false", strlen(b)) == 0)
-				return FALSE;
+				PG_RETURN_BOOL(false);
 			break;
 
 		case 'y':
 		case 'Y':
 			if (strncasecmp(b, "yes", strlen(b)) == 0)
-				return TRUE;
+				PG_RETURN_BOOL(true);
 			break;
 
 		case '1':
 			if (strncasecmp(b, "1", strlen(b)) == 0)
-				return TRUE;
+				PG_RETURN_BOOL(true);
 			break;
 
 		case 'n':
 		case 'N':
 			if (strncasecmp(b, "no", strlen(b)) == 0)
-				return FALSE;
+				PG_RETURN_BOOL(false);
 			break;
 
 		case '0':
 			if (strncasecmp(b, "0", strlen(b)) == 0)
-				return FALSE;
+				PG_RETURN_BOOL(false);
 			break;
 
 		default:
@@ -73,72 +75,143 @@ boolin(char *b)
 	}
 
 	elog(ERROR, "Bad boolean external representation '%s'", b);
+
 	/* not reached */
-	return FALSE;
-}	/* boolin() */
+	PG_RETURN_BOOL(false);
+}
 
 /*
  *		boolout			- converts 1 or 0 to "t" or "f"
  */
-char *
-boolout(bool b)
+Datum
+boolout(PG_FUNCTION_ARGS)
 {
+	bool		b = PG_GETARG_BOOL(0);
 	char	   *result = (char *) palloc(2);
 
-	*result = (b) ? 't' : 'f';
+	result[0] = (b) ? 't' : 'f';
 	result[1] = '\0';
-	return result;
-}	/* boolout() */
+	PG_RETURN_CSTRING(result);
+}
 
 
 /*****************************************************************************
  *	 PUBLIC ROUTINES														 *
  *****************************************************************************/
 
-bool
-booleq(bool arg1, bool arg2)
+Datum
+booleq(PG_FUNCTION_ARGS)
 {
-	return arg1 == arg2;
+	bool		arg1 = PG_GETARG_BOOL(0);
+	bool		arg2 = PG_GETARG_BOOL(1);
+
+	PG_RETURN_BOOL(arg1 == arg2);
 }
 
-bool
-boolne(bool arg1, bool arg2)
+Datum
+boolne(PG_FUNCTION_ARGS)
 {
-	return arg1 != arg2;
+	bool		arg1 = PG_GETARG_BOOL(0);
+	bool		arg2 = PG_GETARG_BOOL(1);
+
+	PG_RETURN_BOOL(arg1 != arg2);
 }
 
-bool
-boollt(bool arg1, bool arg2)
+Datum
+boollt(PG_FUNCTION_ARGS)
 {
-	return arg1 < arg2;
+	bool		arg1 = PG_GETARG_BOOL(0);
+	bool		arg2 = PG_GETARG_BOOL(1);
+
+	PG_RETURN_BOOL(arg1 < arg2);
 }
 
-bool
-boolgt(bool arg1, bool arg2)
+Datum
+boolgt(PG_FUNCTION_ARGS)
 {
-	return arg1 > arg2;
+	bool		arg1 = PG_GETARG_BOOL(0);
+	bool		arg2 = PG_GETARG_BOOL(1);
+
+	PG_RETURN_BOOL(arg1 > arg2);
 }
 
-bool
-boolle(bool arg1, bool arg2)
+Datum
+boolle(PG_FUNCTION_ARGS)
+{
+	bool		arg1 = PG_GETARG_BOOL(0);
+	bool		arg2 = PG_GETARG_BOOL(1);
+
+	PG_RETURN_BOOL(arg1 <= arg2);
+}
+
+Datum
+boolge(PG_FUNCTION_ARGS)
+{
+	bool		arg1 = PG_GETARG_BOOL(0);
+	bool		arg2 = PG_GETARG_BOOL(1);
+
+	PG_RETURN_BOOL(arg1 >= arg2);
+}
+
+/*
+ * Per SQL92, istrue() and isfalse() should return false, not NULL,
+ * when presented a NULL input (since NULL is our implementation of
+ * UNKNOWN).  Conversely isnottrue() and isnotfalse() should return true.
+ * Therefore, these routines are all declared not-strict in pg_proc
+ * and must do their own checking for null inputs.
+ *
+ * Note we don't need isunknown() and isnotunknown() functions, since
+ * nullvalue() and nonnullvalue() will serve.
+ */
+
+Datum
+istrue(PG_FUNCTION_ARGS)
 {
-	return arg1 <= arg2;
+	bool		b;
+
+	if (PG_ARGISNULL(0))
+		PG_RETURN_BOOL(false);
+
+	b = PG_GETARG_BOOL(0);
+
+	PG_RETURN_BOOL(b);
 }
 
-bool
-boolge(bool arg1, bool arg2)
+Datum
+isfalse(PG_FUNCTION_ARGS)
 {
-	return arg1 >= arg2;
+	bool		b;
+
+	if (PG_ARGISNULL(0))
+		PG_RETURN_BOOL(false);
+
+	b = PG_GETARG_BOOL(0);
+
+	PG_RETURN_BOOL(! b);
 }
 
-bool
-istrue(bool arg1)
+Datum
+isnottrue(PG_FUNCTION_ARGS)
 {
-	return arg1 == TRUE;
-}	/* istrue() */
+	bool		b;
 
-bool
-isfalse(bool arg1)
+	if (PG_ARGISNULL(0))
+		PG_RETURN_BOOL(true);
+
+	b = PG_GETARG_BOOL(0);
+
+	PG_RETURN_BOOL(! b);
+}
+
+Datum
+isnotfalse(PG_FUNCTION_ARGS)
 {
-	return arg1 != TRUE;
-}	/* isfalse() */
+	bool		b;
+
+	if (PG_ARGISNULL(0))
+		PG_RETURN_BOOL(true);
+
+	b = PG_GETARG_BOOL(0);
+
+	PG_RETURN_BOOL(b);
+}
diff --git a/src/backend/utils/adt/cash.c b/src/backend/utils/adt/cash.c
index 9a06bc3895..9bfc46bda6 100644
--- a/src/backend/utils/adt/cash.c
+++ b/src/backend/utils/adt/cash.c
@@ -9,7 +9,7 @@
  * workings can be found in the book "Software Solutions in C" by
  * Dale Schumacher, Academic Press, ISBN: 0-12-632360-7.
  *
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/cash.c,v 1.36 2000/05/16 20:48:49 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/cash.c,v 1.37 2000/06/05 07:28:51 tgl Exp $
  */
 
 #include <limits.h>
@@ -35,6 +35,24 @@ static struct lconv *lconvert = NULL;
 
 #endif
 
+
+/*
+ * Cash is a pass-by-ref SQL type, so we must pass and return pointers.
+ * These macros and support routine hide the pass-by-refness.
+ */
+#define PG_GETARG_CASH(n)  (* ((Cash *) DatumGetPointer(fcinfo->arg[n])))
+#define PG_RETURN_CASH(x)  return CashGetDatum(x)
+
+static Datum
+CashGetDatum(Cash value)
+{
+	Cash	   *result = (Cash *) palloc(sizeof(Cash));
+
+	*result = value;
+	return PointerGetDatum(result);
+}
+
+
 /* cash_in()
  * Convert a string to a cash data type.
  * Format is [$]###[,]###[.##]
@@ -573,32 +591,30 @@ cash_div_int4(Cash *c, int4 i)
 /* cash_mul_int2()
  * Multiply cash by int2.
  */
-Cash *
-cash_mul_int2(Cash *c, int2 s)
+Datum
+cash_mul_int2(PG_FUNCTION_ARGS)
 {
-	Cash	   *result;
-
-	if (!PointerIsValid(c))
-		return NULL;
-
-	if (!PointerIsValid(result = palloc(sizeof(Cash))))
-		elog(ERROR, "Memory allocation failed, can't multiply cash");
-
-	*result = ((s) * (*c));
-
-	return result;
-}	/* cash_mul_int2() */
+	Cash		c = PG_GETARG_CASH(0);
+	int16		s = PG_GETARG_INT16(1);
+	Cash		result;
 
+	result = c * s;
+	PG_RETURN_CASH(result);
+}
 
 /* int2_mul_cash()
  * Multiply int2 by cash.
  */
-Cash *
-int2_mul_cash(int2 s, Cash *c)
+Datum
+int2_mul_cash(PG_FUNCTION_ARGS)
 {
-	return cash_mul_int2(c, s);
-}	/* int2_mul_cash() */
+	int16		s = PG_GETARG_INT16(0);
+	Cash		c = PG_GETARG_CASH(1);
+	Cash		result;
 
+	result = s * c;
+	PG_RETURN_CASH(result);
+}
 
 /* cash_div_int2()
  * Divide cash by int2.
@@ -606,25 +622,19 @@ int2_mul_cash(int2 s, Cash *c)
  * XXX Don't know if rounding or truncating is correct behavior.
  * Round for now. - tgl 97/04/15
  */
-Cash *
-cash_div_int2(Cash *c, int2 s)
+Datum
+cash_div_int2(PG_FUNCTION_ARGS)
 {
-	Cash	   *result;
-
-	if (!PointerIsValid(c))
-		return NULL;
-
-	if (!PointerIsValid(result = palloc(sizeof(Cash))))
-		elog(ERROR, "Memory allocation failed, can't divide cash");
+	Cash		c = PG_GETARG_CASH(0);
+	int16		s = PG_GETARG_INT16(1);
+	Cash		result;
 
 	if (s == 0)
 		elog(ERROR, "cash_div:  divide by 0 error");
 
-	*result = rint(*c / s);
-
-	return result;
-}	/* cash_div_int2() */
-
+	result = rint(c / s);
+	PG_RETURN_CASH(result);
+}
 
 /* cashlarger()
  * Return larger of two cash values.
diff --git a/src/backend/utils/adt/char.c b/src/backend/utils/adt/char.c
index 6675e4cb99..04e40406f8 100644
--- a/src/backend/utils/adt/char.c
+++ b/src/backend/utils/adt/char.c
@@ -2,18 +2,19 @@
  *
  * char.c
  *	  Functions for the built-in type "char".
- *	  Functions for the built-in type "cid".
+ *	  Functions for the built-in type "cid" (what's that doing here?)
  *
  * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/char.c,v 1.27 2000/01/26 05:57:13 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/char.c,v 1.28 2000/06/05 07:28:51 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
 #include "postgres.h"
+
 #include "utils/builtins.h"
 
 /*****************************************************************************
@@ -23,149 +24,194 @@
 /*
  *		charin			- converts "x" to 'x'
  */
-int32
-charin(char *ch)
+Datum
+charin(PG_FUNCTION_ARGS)
 {
-	if (ch == NULL)
-		return (int32) '\0';
-	return (int32) *ch;
+	char	   *ch = PG_GETARG_CSTRING(0);
+
+	PG_RETURN_CHAR(ch[0]);
 }
 
 /*
  *		charout			- converts 'x' to "x"
  */
-char *
-charout(int32 ch)
+Datum
+charout(PG_FUNCTION_ARGS)
 {
+	char		ch = PG_GETARG_CHAR(0);
 	char	   *result = (char *) palloc(2);
 
-	result[0] = (char) ch;
+	result[0] = ch;
 	result[1] = '\0';
-	return result;
+	PG_RETURN_CSTRING(result);
 }
 
+/*****************************************************************************
+ *	 PUBLIC ROUTINES														 *
+ *****************************************************************************/
+
 /*
- *		cidin	- converts "..." to internal representation.
+ * NOTE: comparisons are done as though char is unsigned (uint8).
+ * Arithmetic is done as though char is signed (int8).
  *
- *		NOTE: we must not use 'charin' because cid might be a non
- *		printable character...
+ * You wanted consistency?
  */
-int32
-cidin(char *s)
-{
-	CommandId	c;
 
-	if (s == NULL)
-		c = 0;
-	else
-		c = atoi(s);
+Datum
+chareq(PG_FUNCTION_ARGS)
+{
+	char		arg1 = PG_GETARG_CHAR(0);
+	char		arg2 = PG_GETARG_CHAR(1);
 
-	return (int32) c;
+	PG_RETURN_BOOL(arg1 == arg2);
 }
 
-/*
- *		cidout	- converts a cid to "..."
- *
- *		NOTE: we must no use 'charout' because cid might be a non
- *		printable character...
- */
-char *
-cidout(int32 c)
+Datum
+charne(PG_FUNCTION_ARGS)
 {
-	char	   *result;
-	CommandId	c2;
+	char		arg1 = PG_GETARG_CHAR(0);
+	char		arg2 = PG_GETARG_CHAR(1);
 
-	result = palloc(12);
-	c2 = (CommandId) c;
-	sprintf(result, "%u", (unsigned) (c2));
-	return result;
+	PG_RETURN_BOOL(arg1 != arg2);
 }
 
-
-/*****************************************************************************
- *	 PUBLIC ROUTINES														 *
- *****************************************************************************/
-
-bool
-chareq(int8 arg1, int8 arg2)
+Datum
+charlt(PG_FUNCTION_ARGS)
 {
-	return arg1 == arg2;
+	char		arg1 = PG_GETARG_CHAR(0);
+	char		arg2 = PG_GETARG_CHAR(1);
+
+	PG_RETURN_BOOL((uint8) arg1 < (uint8) arg2);
 }
 
-bool
-charne(int8 arg1, int8 arg2)
+Datum
+charle(PG_FUNCTION_ARGS)
 {
-	return arg1 != arg2;
+	char		arg1 = PG_GETARG_CHAR(0);
+	char		arg2 = PG_GETARG_CHAR(1);
+
+	PG_RETURN_BOOL((uint8) arg1 <= (uint8) arg2);
 }
 
-bool
-charlt(int8 arg1, int8 arg2)
+Datum
+chargt(PG_FUNCTION_ARGS)
 {
-	return (uint8) arg1 < (uint8) arg2;
+	char		arg1 = PG_GETARG_CHAR(0);
+	char		arg2 = PG_GETARG_CHAR(1);
+
+	PG_RETURN_BOOL((uint8) arg1 > (uint8) arg2);
 }
 
-bool
-charle(int8 arg1, int8 arg2)
+Datum
+charge(PG_FUNCTION_ARGS)
 {
-	return (uint8) arg1 <= (uint8) arg2;
+	char		arg1 = PG_GETARG_CHAR(0);
+	char		arg2 = PG_GETARG_CHAR(1);
+
+	PG_RETURN_BOOL((uint8) arg1 >= (uint8) arg2);
 }
 
-bool
-chargt(int8 arg1, int8 arg2)
+Datum
+charpl(PG_FUNCTION_ARGS)
 {
-	return (uint8) arg1 > (uint8) arg2;
+	char		arg1 = PG_GETARG_CHAR(0);
+	char		arg2 = PG_GETARG_CHAR(1);
+
+	PG_RETURN_CHAR((int8) arg1 + (int8) arg2);
 }
 
-bool
-charge(int8 arg1, int8 arg2)
+Datum
+charmi(PG_FUNCTION_ARGS)
 {
-	return (uint8) arg1 >= (uint8) arg2;
+	char		arg1 = PG_GETARG_CHAR(0);
+	char		arg2 = PG_GETARG_CHAR(1);
+
+	PG_RETURN_CHAR((int8) arg1 - (int8) arg2);
 }
 
-int8
-charpl(int8 arg1, int8 arg2)
+Datum
+charmul(PG_FUNCTION_ARGS)
 {
-	return arg1 + arg2;
+	char		arg1 = PG_GETARG_CHAR(0);
+	char		arg2 = PG_GETARG_CHAR(1);
+
+	PG_RETURN_CHAR((int8) arg1 * (int8) arg2);
 }
 
-int8
-charmi(int8 arg1, int8 arg2)
+Datum
+chardiv(PG_FUNCTION_ARGS)
 {
-	return arg1 - arg2;
+	char		arg1 = PG_GETARG_CHAR(0);
+	char		arg2 = PG_GETARG_CHAR(1);
+
+	PG_RETURN_CHAR((int8) arg1 / (int8) arg2);
 }
 
-int8
-charmul(int8 arg1, int8 arg2)
+Datum
+text_char(PG_FUNCTION_ARGS)
 {
-	return arg1 * arg2;
+	text	   *arg1 = PG_GETARG_TEXT_P(0);
+
+	/* XXX what if arg1 has length zero? */
+	PG_RETURN_CHAR(*(VARDATA(arg1)));
 }
 
-int8
-chardiv(int8 arg1, int8 arg2)
+Datum
+char_text(PG_FUNCTION_ARGS)
 {
-	return arg1 / arg2;
+	char		arg1 = PG_GETARG_CHAR(0);
+	text	   *result = palloc(VARHDRSZ + 1);
+
+	VARSIZE(result) = VARHDRSZ + 1;
+	*(VARDATA(result)) = arg1;
+
+	PG_RETURN_TEXT_P(result);
 }
 
-bool
-cideq(int8 arg1, int8 arg2)
+
+/*****************************************************************************
+ *	 USER I/O ROUTINES														 *
+ *****************************************************************************/
+
+/*
+ *		cidin	- converts CommandId to internal representation.
+ */
+Datum
+cidin(PG_FUNCTION_ARGS)
 {
-	return arg1 == arg2;
+	char	   *s = PG_GETARG_CSTRING(0);
+	CommandId	c;
+
+	c = atoi(s);
+
+	/* XXX assume that CommandId is 32 bits... */
+	PG_RETURN_INT32((int32) c);
 }
 
-int8
-text_char(text *arg1)
+/*
+ *		cidout	- converts a cid to external representation.
+ */
+Datum
+cidout(PG_FUNCTION_ARGS)
 {
-	return ((int8) *(VARDATA(arg1)));
+	/* XXX assume that CommandId is 32 bits... */
+	CommandId	c = PG_GETARG_INT32(0);
+	char	   *result = (char *) palloc(16);
+
+	sprintf(result, "%u", (unsigned int) c);
+	PG_RETURN_CSTRING(result);
 }
 
-text *
-char_text(int8 arg1)
-{
-	text	   *result;
+/*****************************************************************************
+ *	 PUBLIC ROUTINES														 *
+ *****************************************************************************/
 
-	result = palloc(VARHDRSZ + 1);
-	VARSIZE(result) = VARHDRSZ + 1;
-	*(VARDATA(result)) = arg1;
+Datum
+cideq(PG_FUNCTION_ARGS)
+{
+	/* XXX assume that CommandId is 32 bits... */
+	CommandId	arg1 = PG_GETARG_INT32(0);
+	CommandId	arg2 = PG_GETARG_INT32(1);
 
-	return result;
+	PG_RETURN_BOOL(arg1 == arg2);
 }
diff --git a/src/backend/utils/adt/float.c b/src/backend/utils/adt/float.c
index 354ee0110b..b7b654cc32 100644
--- a/src/backend/utils/adt/float.c
+++ b/src/backend/utils/adt/float.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/float.c,v 1.57 2000/04/12 17:15:49 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/float.c,v 1.58 2000/06/05 07:28:51 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -122,25 +122,6 @@ extern double rint(double x);
 #define FLOAT8_MAX		 DBL_MAX
 #define FLOAT8_MIN		 DBL_MIN
 
-/*
- * if FLOAT8_MIN and FLOAT8_MAX are the limits of the range a
- * double can store, then how are we ever going to wind up
- * with something stored in a double that is outside those
- * limits?	(and similarly for FLOAT4_{MIN,MAX}/float.)
- * doesn't make sense to me, and it causes a
- * floating point exception on linuxalpha, so UNSAFE_FLOATS
- * it is.
- * (maybe someone wanted to allow for values other than DBL_MIN/
- * DBL_MAX for FLOAT8_MIN/FLOAT8_MAX?)
- *								--djm 12/12/96
- * according to Richard Henderson this is a known bug in gcc on
- * the Alpha.  might as well leave the workaround in
- * until the distributions are updated.
- *								--djm 12/16/96
- */
-#if ( defined(linux) && defined(__alpha__) ) && !defined(UNSAFE_FLOATS)
-#define UNSAFE_FLOATS
-#endif
 
 /*
    check to see if a float4 val is outside of
@@ -844,19 +825,17 @@ dtoi4(float64 num)
 /*
  *		dtoi2			- converts a float8 number to an int2 number
  */
-int16
-dtoi2(float64 num)
+Datum
+dtoi2(PG_FUNCTION_ARGS)
 {
+	float8		num = PG_GETARG_FLOAT8(0);
 	int16		result;
 
-	if (!num)
-		return 0;				/* fmgr will return NULL anyway */
-
-	if ((*num < SHRT_MIN) || (*num > SHRT_MAX))
+	if ((num < SHRT_MIN) || (num > SHRT_MAX))
 		elog(ERROR, "dtoi2: integer out of range");
 
-	result = rint(*num);
-	return result;
+	result = (int16) rint(num);
+	PG_RETURN_INT16(result);
 }
 
 
@@ -878,15 +857,14 @@ i4tod(int32 num)
 /*
  *		i2tod			- converts an int2 number to a float8 number
  */
-float64
-i2tod(int16 num)
+Datum
+i2tod(PG_FUNCTION_ARGS)
 {
-	float64		result;
+	int16		num = PG_GETARG_INT16(0);
+	float8		result;
 
-	result = (float64) palloc(sizeof(float64data));
-
-	*result = num;
-	return result;
+	result = num;
+	PG_RETURN_FLOAT8(result);
 }
 
 
@@ -910,21 +888,19 @@ ftoi4(float32 num)
 
 
 /*
- *		ftoi2			- converts a float8 number to an int2 number
+ *		ftoi2			- converts a float4 number to an int2 number
  */
-int16
-ftoi2(float32 num)
+Datum
+ftoi2(PG_FUNCTION_ARGS)
 {
+	float4		num = PG_GETARG_FLOAT4(0);
 	int16		result;
 
-	if (!num)
-		return 0;				/* fmgr will return NULL anyway */
-
-	if ((*num < SHRT_MIN) || (*num > SHRT_MAX))
+	if ((num < SHRT_MIN) || (num > SHRT_MAX))
 		elog(ERROR, "ftoi2: integer out of range");
 
-	result = rint(*num);
-	return result;
+	result = (int16) rint(num);
+	PG_RETURN_INT16(result);
 }
 
 
@@ -944,17 +920,16 @@ i4tof(int32 num)
 
 
 /*
- *		i2tof			- converts an int2 number to a float8 number
+ *		i2tof			- converts an int2 number to a float4 number
  */
-float32
-i2tof(int16 num)
+Datum
+i2tof(PG_FUNCTION_ARGS)
 {
-	float32		result;
-
-	result = (float32) palloc(sizeof(float32data));
+	int16		num = PG_GETARG_INT16(0);
+	float4		result;
 
-	*result = num;
-	return result;
+	result = num;
+	PG_RETURN_FLOAT4(result);
 }
 
 
diff --git a/src/backend/utils/adt/formatting.c b/src/backend/utils/adt/formatting.c
index 8d204a1595..674bbefea5 100644
--- a/src/backend/utils/adt/formatting.c
+++ b/src/backend/utils/adt/formatting.c
@@ -1,7 +1,7 @@
 /* -----------------------------------------------------------------------
  * formatting.c
  *
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/formatting.c,v 1.8 2000/04/12 17:15:49 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/formatting.c,v 1.9 2000/06/05 07:28:51 tgl Exp $
  *
  *
  *	 Portions Copyright (c) 1999-2000, PostgreSQL, Inc
@@ -4048,11 +4048,15 @@ int4_to_char(int32 value, text *fmt)
 	{
 		if (IS_MULTI(&Num))
 		{
-			orgnum = int4out(int4mul(value, (int32) pow((double) 10, (double) Num.multi)));
+			orgnum = DatumGetCString(DirectFunctionCall1(int4out,
+						Int32GetDatum(value * ((int32) pow((double) 10, (double) Num.multi)))));
 			Num.pre += Num.multi;
 		}
 		else
-			orgnum = int4out(value);
+		{
+			orgnum = DatumGetCString(DirectFunctionCall1(int4out,
+									 Int32GetDatum(value)));
+		}
 		len = strlen(orgnum);
 
 		if (*orgnum == '-')
diff --git a/src/backend/utils/adt/geo_selfuncs.c b/src/backend/utils/adt/geo_selfuncs.c
index 5b77e1c330..e5f239612e 100644
--- a/src/backend/utils/adt/geo_selfuncs.c
+++ b/src/backend/utils/adt/geo_selfuncs.c
@@ -9,7 +9,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/geo_selfuncs.c,v 1.15 2000/05/13 06:04:46 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/geo_selfuncs.c,v 1.16 2000/06/05 07:28:52 tgl Exp $
  *
  *	XXX These are totally bogus.  Perhaps someone will make them do
  *	something reasonable, someday.
@@ -44,32 +44,16 @@
  * Selectivity for operators that depend on area, such as "overlap".
  */
 
-float64
-areasel(Oid opid,
-		Oid relid,
-		AttrNumber attno,
-		Datum value,
-		int32 flag)
+Datum
+areasel(PG_FUNCTION_ARGS)
 {
-	float64		result;
-
-	result = (float64) palloc(sizeof(float64data));
-	*result = 0.02;
-	return result;
+	PG_RETURN_FLOAT8(0.02);
 }
 
-float64
-areajoinsel(Oid opid,
-			Oid relid1,
-			AttrNumber attno1,
-			Oid relid2,
-			AttrNumber attno2)
+Datum
+areajoinsel(PG_FUNCTION_ARGS)
 {
-	float64		result;
-
-	result = (float64) palloc(sizeof(float64data));
-	*result = 0.02;
-	return result;
+	PG_RETURN_FLOAT8(0.02);
 }
 
 /*
@@ -79,32 +63,16 @@ areajoinsel(Oid opid,
  * a given box?
  */
 
-float64
-positionsel(Oid opid,
-			Oid relid,
-			AttrNumber attno,
-			Datum value,
-			int32 flag)
+Datum
+positionsel(PG_FUNCTION_ARGS)
 {
-	float64		result;
-
-	result = (float64) palloc(sizeof(float64data));
-	*result = 0.1;
-	return result;
+	PG_RETURN_FLOAT8(0.1);
 }
 
-float64
-positionjoinsel(Oid opid,
-				Oid relid1,
-				AttrNumber attno1,
-				Oid relid2,
-				AttrNumber attno2)
+Datum
+positionjoinsel(PG_FUNCTION_ARGS)
 {
-	float64		result;
-
-	result = (float64) palloc(sizeof(float64data));
-	*result = 0.1;
-	return result;
+	PG_RETURN_FLOAT8(0.1);
 }
 
 /*
@@ -114,30 +82,14 @@ positionjoinsel(Oid opid,
  * estimate than areasel does.
  */
 
-float64
-contsel(Oid opid,
-		Oid relid,
-		AttrNumber attno,
-		Datum value,
-		int32 flag)
+Datum
+contsel(PG_FUNCTION_ARGS)
 {
-	float64		result;
-
-	result = (float64) palloc(sizeof(float64data));
-	*result = 0.01;
-	return result;
+	PG_RETURN_FLOAT8(0.01);
 }
 
-float64
-contjoinsel(Oid opid,
-			Oid relid1,
-			AttrNumber attno1,
-			Oid relid2,
-			AttrNumber attno2)
+Datum
+contjoinsel(PG_FUNCTION_ARGS)
 {
-	float64		result;
-
-	result = (float64) palloc(sizeof(float64data));
-	*result = 0.01;
-	return result;
+	PG_RETURN_FLOAT8(0.01);
 }
diff --git a/src/backend/utils/adt/int.c b/src/backend/utils/adt/int.c
index 242e9c5401..6e236a01c7 100644
--- a/src/backend/utils/adt/int.c
+++ b/src/backend/utils/adt/int.c
@@ -1,14 +1,14 @@
 /*-------------------------------------------------------------------------
  *
  * int.c
- *	  Functions for the built-in integer types.
+ *	  Functions for the built-in integer types (except int8).
  *
  * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/int.c,v 1.36 2000/04/12 17:15:50 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/int.c,v 1.37 2000/06/05 07:28:52 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -25,13 +25,12 @@
  *
  *		Arithmetic operators:
  *		 intmod, int4fac
- *
- * XXX makes massive and possibly unwarranted type promotion assumptions.
- * fix me when we figure out what we want to do about ANSIfication...
  */
 
 #include <ctype.h>
+
 #include "postgres.h"
+
 #ifdef HAVE_LIMITS_H
 #include <limits.h>
 #endif
@@ -52,42 +51,39 @@
 /*
  *		int2in			- converts "num" to short
  */
-int32
-int2in(char *num)
+Datum
+int2in(PG_FUNCTION_ARGS)
 {
-	return (int32) pg_atoi(num, sizeof(int16), '\0');
+	char	   *num = PG_GETARG_CSTRING(0);
+
+	PG_RETURN_INT16(pg_atoi(num, sizeof(int16), '\0'));
 }
 
 /*
  *		int2out			- converts short to "num"
  */
-char *
-int2out(int16 sh)
+Datum
+int2out(PG_FUNCTION_ARGS)
 {
-	char	   *result;
+	int16		arg1 = PG_GETARG_INT16(0);
+	char	   *result = (char *) palloc(7); /* sign, 5 digits, '\0' */
 
-	result = (char *) palloc(7);/* assumes sign, 5 digits, '\0' */
-	itoa((int) sh, result);
-	return result;
+	itoa((int) arg1, result);
+	PG_RETURN_CSTRING(result);
 }
 
 /*
  *		int2vectorin			- converts "num num ..." to internal form
  *
- *		Note:
- *				Fills any nonexistent digits with NULLs.
+ *		Note: Fills any missing slots with zeroes.
  */
-int16 *
-int2vectorin(char *intString)
+Datum
+int2vectorin(PG_FUNCTION_ARGS)
 {
-	int16	   *result;
+	char	   *intString = PG_GETARG_CSTRING(0);
+	int16	   *result = (int16 *) palloc(sizeof(int16[INDEX_MAX_KEYS]));
 	int			slot;
 
-	if (intString == NULL)
-		return NULL;
-
-	result = (int16 *) palloc(sizeof(int16[INDEX_MAX_KEYS]));
-
 	for (slot = 0; *intString && slot < INDEX_MAX_KEYS; slot++)
 	{
 		if (sscanf(intString, "%hd", &result[slot]) != 1)
@@ -104,28 +100,21 @@ int2vectorin(char *intString)
 	while (slot < INDEX_MAX_KEYS)
 		result[slot++] = 0;
 
-	return result;
+	PG_RETURN_POINTER(result);
 }
 
 /*
  *		int2vectorout		- converts internal form to "num num ..."
  */
-char *
-int2vectorout(int16 *int2Array)
+Datum
+int2vectorout(PG_FUNCTION_ARGS)
 {
+	int16	   *int2Array = (int16 *) PG_GETARG_POINTER(0);
 	int			num,
 				maxnum;
 	char	   *rp;
 	char	   *result;
 
-	if (int2Array == NULL)
-	{
-		result = (char *) palloc(2);
-		result[0] = '-';
-		result[1] = '\0';
-		return result;
-	}
-
 	/* find last non-zero value in vector */
 	for (maxnum = INDEX_MAX_KEYS - 1; maxnum >= 0; maxnum--)
 		if (int2Array[maxnum] != 0)
@@ -142,71 +131,72 @@ int2vectorout(int16 *int2Array)
 			;
 	}
 	*rp = '\0';
-	return result;
+	PG_RETURN_CSTRING(result);
 }
 
 /*
  * We don't have a complete set of int2vector support routines,
  * but we need int2vectoreq for catcache indexing.
  */
-bool
-int2vectoreq(int16 *arg1, int16 *arg2)
+Datum
+int2vectoreq(PG_FUNCTION_ARGS)
 {
-	return (bool) (memcmp(arg1, arg2, INDEX_MAX_KEYS * sizeof(int16)) == 0);
+	int16	   *arg1 = (int16 *) PG_GETARG_POINTER(0);
+	int16	   *arg2 = (int16 *) PG_GETARG_POINTER(1);
+
+	PG_RETURN_BOOL(memcmp(arg1, arg2, INDEX_MAX_KEYS * sizeof(int16)) == 0);
 }
 
+/*
+ * Type int44 has no real-world use, but the regression tests use it.
+ * It's a four-element vector of int4's.
+ */
 
 /*
  *		int44in			- converts "num num ..." to internal form
  *
- *		Note:
- *				Fills any nonexistent digits with NULLs.
+ *		Note: Fills any missing positions with zeroes.
  */
-int32 *
-int44in(char *input_string)
+Datum
+int44in(PG_FUNCTION_ARGS)
 {
-	int32	   *foo = (int32 *) palloc(4 * sizeof(int32));
-	int			i = 0;
+	char	   *input_string = PG_GETARG_CSTRING(0);
+	int32	   *result = (int32 *) palloc(4 * sizeof(int32));
+	int			i;
 
 	i = sscanf(input_string,
 			   "%d, %d, %d, %d",
-			   &foo[0],
-			   &foo[1],
-			   &foo[2],
-			   &foo[3]);
+			   &result[0],
+			   &result[1],
+			   &result[2],
+			   &result[3]);
 	while (i < 4)
-		foo[i++] = 0;
+		result[i++] = 0;
 
-	return foo;
+	PG_RETURN_POINTER(result);
 }
 
 /*
  *		int44out		- converts internal form to "num num ..."
  */
-char *
-int44out(int32 *an_array)
+Datum
+int44out(PG_FUNCTION_ARGS)
 {
-	int			temp = 4;
-	char	   *output_string = NULL;
+	int32	   *an_array = (int32 *) PG_GETARG_POINTER(0);
+	char	   *result = (char *) palloc(16 * 4); /* Allow 14 digits + sign */
 	int			i;
+	char	   *walk;
 
-	if (temp > 0)
+	walk = result;
+	for (i = 0; i < 4; i++)
 	{
-		char	   *walk;
-
-		output_string = (char *) palloc(16 * temp);		/* assume 15 digits +
-														 * sign */
-		walk = output_string;
-		for (i = 0; i < temp; i++)
-		{
-			itoa(an_array[i], walk);
-			while (*++walk != '\0')
-				;
-			*walk++ = ' ';
-		}
-		*--walk = '\0';
+		itoa(an_array[i], walk);
+		while (*++walk != '\0')
+			;
+		*walk++ = ' ';
 	}
-	return output_string;
+	*--walk = '\0';
+	PG_RETURN_CSTRING(result);
 }
 
 
@@ -217,23 +207,25 @@ int44out(int32 *an_array)
 /*
  *		int4in			- converts "num" to int4
  */
-int32
-int4in(char *num)
+Datum
+int4in(PG_FUNCTION_ARGS)
 {
-	return pg_atoi(num, sizeof(int32), '\0');
+	char	   *num = PG_GETARG_CSTRING(0);
+
+	PG_RETURN_INT32(pg_atoi(num, sizeof(int32), '\0'));
 }
 
 /*
  *		int4out			- converts int4 to "num"
  */
-char *
-int4out(int32 l)
+Datum
+int4out(PG_FUNCTION_ARGS)
 {
-	char	   *result;
+	int32		arg1 = PG_GETARG_INT32(0);
+	char	   *result = (char *) palloc(12); /* sign, 10 digits, '\0' */
 
-	result = (char *) palloc(12);		/* assumes sign, 10 digits, '\0' */
-	ltoa(l, result);
-	return result;
+	ltoa(arg1, result);
+	PG_RETURN_CSTRING(result);
 }
 
 
@@ -243,116 +235,94 @@ int4out(int32 l)
  *		===================
  */
 
-int32
-i2toi4(int16 arg1)
+Datum
+i2toi4(PG_FUNCTION_ARGS)
 {
-	return (int32) arg1;
+	int16		arg1 = PG_GETARG_INT16(0);
+
+	PG_RETURN_INT32((int32) arg1);
 }
 
-int16
-i4toi2(int32 arg1)
+Datum
+i4toi2(PG_FUNCTION_ARGS)
 {
+	int32		arg1 = PG_GETARG_INT32(0);
+
 	if (arg1 < SHRT_MIN)
 		elog(ERROR, "i4toi2: '%d' causes int2 underflow", arg1);
 	if (arg1 > SHRT_MAX)
 		elog(ERROR, "i4toi2: '%d' causes int2 overflow", arg1);
 
-	return (int16) arg1;
+	PG_RETURN_INT16((int16) arg1);
 }
 
-text *
-int2_text(int16 arg1)
+Datum
+int2_text(PG_FUNCTION_ARGS)
 {
-	text	   *result;
-
-	int			len;
-	char	   *str;
-
-	str = int2out(arg1);
-	len = (strlen(str) + VARHDRSZ);
-
-	result = palloc(len);
+	int16		arg1 = PG_GETARG_INT16(0);
+	text	   *result = (text *) palloc(7+VARHDRSZ); /* sign,5 digits, '\0' */
 
-	VARSIZE(result) = len;
-	memmove(VARDATA(result), str, (len - VARHDRSZ));
-
-	pfree(str);
-
-	return result;
-}	/* int2_text() */
+	itoa((int) arg1, VARDATA(result));
+	VARSIZE(result) = strlen(VARDATA(result)) + VARHDRSZ;
+	PG_RETURN_TEXT_P(result);
+}
 
-int16
-text_int2(text *string)
+Datum
+text_int2(PG_FUNCTION_ARGS)
 {
-	int16		result;
-
+	text	   *string = PG_GETARG_TEXT_P(0);
+	Datum		result;
 	int			len;
 	char	   *str;
 
-	if (!string)
-		return 0;
-
-	len = (VARSIZE(string) - VARHDRSZ);
+	len = VARSIZE(string) - VARHDRSZ;
 
 	str = palloc(len + 1);
-	memmove(str, VARDATA(string), len);
+	memcpy(str, VARDATA(string), len);
 	*(str + len) = '\0';
 
-	result = int2in(str);
+	result = DirectFunctionCall1(int2in, CStringGetDatum(str));
 	pfree(str);
 
 	return result;
-}	/* text_int2() */
+}
 
-text *
-int4_text(int32 arg1)
+Datum
+int4_text(PG_FUNCTION_ARGS)
 {
-	text	   *result;
-
-	int			len;
-	char	   *str;
-
-	str = int4out(arg1);
-	len = (strlen(str) + VARHDRSZ);
-
-	result = palloc(len);
-
-	VARSIZE(result) = len;
-	memmove(VARDATA(result), str, (len - VARHDRSZ));
+	int32		arg1 = PG_GETARG_INT32(0);
+	text	   *result = (text *) palloc(12+VARHDRSZ); /* sign,10 digits,'\0' */
 
-	pfree(str);
-
-	return result;
-}	/* int4_text() */
+	ltoa(arg1, VARDATA(result));
+	VARSIZE(result) = strlen(VARDATA(result)) + VARHDRSZ;
+	PG_RETURN_TEXT_P(result);
+}
 
-int32
-text_int4(text *string)
+Datum
+text_int4(PG_FUNCTION_ARGS)
 {
-	int32		result;
-
+	text	   *string = PG_GETARG_TEXT_P(0);
+	Datum		result;
 	int			len;
 	char	   *str;
 
-	if (!string)
-		return 0;
-
-	len = (VARSIZE(string) - VARHDRSZ);
+	len = VARSIZE(string) - VARHDRSZ;
 
 	str = palloc(len + 1);
-	memmove(str, VARDATA(string), len);
+	memcpy(str, VARDATA(string), len);
 	*(str + len) = '\0';
 
-	result = int4in(str);
+	result = DirectFunctionCall1(int4in, CStringGetDatum(str));
 	pfree(str);
 
 	return result;
-}	/* text_int4() */
+}
 
 
 /*
- *		=========================
- *		BOOLEAN OPERATOR ROUTINES
- *		=========================
+ *		============================
+ *		COMPARISON OPERATOR ROUTINES
+ *		============================
  */
 
 /*
@@ -363,148 +333,221 @@ text_int4(text *string)
  *		intgt			- returns 1 iff arg1 > arg2
  *		intge			- returns 1 iff arg1 >= arg2
  */
-bool
-int4eq(int32 arg1, int32 arg2)
+
+Datum
+int4eq(PG_FUNCTION_ARGS)
 {
-	return arg1 == arg2;
+	int32		arg1 = PG_GETARG_INT32(0);
+	int32		arg2 = PG_GETARG_INT32(1);
+
+	PG_RETURN_BOOL(arg1 == arg2);
 }
 
-bool
-int4ne(int32 arg1, int32 arg2)
+Datum
+int4ne(PG_FUNCTION_ARGS)
 {
-	return arg1 != arg2;
+	int32		arg1 = PG_GETARG_INT32(0);
+	int32		arg2 = PG_GETARG_INT32(1);
+
+	PG_RETURN_BOOL(arg1 != arg2);
 }
 
-bool
-int4lt(int32 arg1, int32 arg2)
+Datum
+int4lt(PG_FUNCTION_ARGS)
 {
-	return arg1 < arg2;
+	int32		arg1 = PG_GETARG_INT32(0);
+	int32		arg2 = PG_GETARG_INT32(1);
+
+	PG_RETURN_BOOL(arg1 < arg2);
 }
 
-bool
-int4le(int32 arg1, int32 arg2)
+Datum
+int4le(PG_FUNCTION_ARGS)
 {
-	return arg1 <= arg2;
+	int32		arg1 = PG_GETARG_INT32(0);
+	int32		arg2 = PG_GETARG_INT32(1);
+
+	PG_RETURN_BOOL(arg1 <= arg2);
 }
 
-bool
-int4gt(int32 arg1, int32 arg2)
+Datum
+int4gt(PG_FUNCTION_ARGS)
 {
-	return arg1 > arg2;
+	int32		arg1 = PG_GETARG_INT32(0);
+	int32		arg2 = PG_GETARG_INT32(1);
+
+	PG_RETURN_BOOL(arg1 > arg2);
 }
 
-bool
-int4ge(int32 arg1, int32 arg2)
+Datum
+int4ge(PG_FUNCTION_ARGS)
 {
-	return arg1 >= arg2;
+	int32		arg1 = PG_GETARG_INT32(0);
+	int32		arg2 = PG_GETARG_INT32(1);
+
+	PG_RETURN_BOOL(arg1 >= arg2);
 }
 
-bool
-int2eq(int16 arg1, int16 arg2)
+Datum
+int2eq(PG_FUNCTION_ARGS)
 {
-	return arg1 == arg2;
+	int16		arg1 = PG_GETARG_INT16(0);
+	int16		arg2 = PG_GETARG_INT16(1);
+
+	PG_RETURN_BOOL(arg1 == arg2);
 }
 
-bool
-int2ne(int16 arg1, int16 arg2)
+Datum
+int2ne(PG_FUNCTION_ARGS)
 {
-	return arg1 != arg2;
+	int16		arg1 = PG_GETARG_INT16(0);
+	int16		arg2 = PG_GETARG_INT16(1);
+
+	PG_RETURN_BOOL(arg1 != arg2);
 }
 
-bool
-int2lt(int16 arg1, int16 arg2)
+Datum
+int2lt(PG_FUNCTION_ARGS)
 {
-	return arg1 < arg2;
+	int16		arg1 = PG_GETARG_INT16(0);
+	int16		arg2 = PG_GETARG_INT16(1);
+
+	PG_RETURN_BOOL(arg1 < arg2);
 }
 
-bool
-int2le(int16 arg1, int16 arg2)
+Datum
+int2le(PG_FUNCTION_ARGS)
 {
-	return arg1 <= arg2;
+	int16		arg1 = PG_GETARG_INT16(0);
+	int16		arg2 = PG_GETARG_INT16(1);
+
+	PG_RETURN_BOOL(arg1 <= arg2);
 }
 
-bool
-int2gt(int16 arg1, int16 arg2)
+Datum
+int2gt(PG_FUNCTION_ARGS)
 {
-	return arg1 > arg2;
+	int16		arg1 = PG_GETARG_INT16(0);
+	int16		arg2 = PG_GETARG_INT16(1);
+
+	PG_RETURN_BOOL(arg1 > arg2);
 }
 
-bool
-int2ge(int16 arg1, int16 arg2)
+Datum
+int2ge(PG_FUNCTION_ARGS)
 {
-	return arg1 >= arg2;
+	int16		arg1 = PG_GETARG_INT16(0);
+	int16		arg2 = PG_GETARG_INT16(1);
+
+	PG_RETURN_BOOL(arg1 >= arg2);
 }
 
-bool
-int24eq(int32 arg1, int32 arg2)
+Datum
+int24eq(PG_FUNCTION_ARGS)
 {
-	return arg1 == arg2;
+	int16		arg1 = PG_GETARG_INT16(0);
+	int32		arg2 = PG_GETARG_INT32(1);
+
+	PG_RETURN_BOOL(arg1 == arg2);
 }
 
-bool
-int24ne(int32 arg1, int32 arg2)
+Datum
+int24ne(PG_FUNCTION_ARGS)
 {
-	return arg1 != arg2;
+	int16		arg1 = PG_GETARG_INT16(0);
+	int32		arg2 = PG_GETARG_INT32(1);
+
+	PG_RETURN_BOOL(arg1 != arg2);
 }
 
-bool
-int24lt(int32 arg1, int32 arg2)
+Datum
+int24lt(PG_FUNCTION_ARGS)
 {
-	return arg1 < arg2;
+	int16		arg1 = PG_GETARG_INT16(0);
+	int32		arg2 = PG_GETARG_INT32(1);
+
+	PG_RETURN_BOOL(arg1 < arg2);
 }
 
-bool
-int24le(int32 arg1, int32 arg2)
+Datum
+int24le(PG_FUNCTION_ARGS)
 {
-	return arg1 <= arg2;
+	int16		arg1 = PG_GETARG_INT16(0);
+	int32		arg2 = PG_GETARG_INT32(1);
+
+	PG_RETURN_BOOL(arg1 <= arg2);
 }
 
-bool
-int24gt(int32 arg1, int32 arg2)
+Datum
+int24gt(PG_FUNCTION_ARGS)
 {
-	return arg1 > arg2;
+	int16		arg1 = PG_GETARG_INT16(0);
+	int32		arg2 = PG_GETARG_INT32(1);
+
+	PG_RETURN_BOOL(arg1 > arg2);
 }
 
-bool
-int24ge(int32 arg1, int32 arg2)
+Datum
+int24ge(PG_FUNCTION_ARGS)
 {
-	return arg1 >= arg2;
+	int16		arg1 = PG_GETARG_INT16(0);
+	int32		arg2 = PG_GETARG_INT32(1);
+
+	PG_RETURN_BOOL(arg1 >= arg2);
 }
 
-bool
-int42eq(int32 arg1, int32 arg2)
+Datum
+int42eq(PG_FUNCTION_ARGS)
 {
-	return arg1 == arg2;
+	int32		arg1 = PG_GETARG_INT32(0);
+	int16		arg2 = PG_GETARG_INT16(1);
+
+	PG_RETURN_BOOL(arg1 == arg2);
 }
 
-bool
-int42ne(int32 arg1, int32 arg2)
+Datum
+int42ne(PG_FUNCTION_ARGS)
 {
-	return arg1 != arg2;
+	int32		arg1 = PG_GETARG_INT32(0);
+	int16		arg2 = PG_GETARG_INT16(1);
+
+	PG_RETURN_BOOL(arg1 != arg2);
 }
 
-bool
-int42lt(int32 arg1, int32 arg2)
+Datum
+int42lt(PG_FUNCTION_ARGS)
 {
-	return arg1 < arg2;
+	int32		arg1 = PG_GETARG_INT32(0);
+	int16		arg2 = PG_GETARG_INT16(1);
+
+	PG_RETURN_BOOL(arg1 < arg2);
 }
 
-bool
-int42le(int32 arg1, int32 arg2)
+Datum
+int42le(PG_FUNCTION_ARGS)
 {
-	return arg1 <= arg2;
+	int32		arg1 = PG_GETARG_INT32(0);
+	int16		arg2 = PG_GETARG_INT16(1);
+
+	PG_RETURN_BOOL(arg1 <= arg2);
 }
 
-bool
-int42gt(int32 arg1, int32 arg2)
+Datum
+int42gt(PG_FUNCTION_ARGS)
 {
-	return arg1 > arg2;
+	int32		arg1 = PG_GETARG_INT32(0);
+	int16		arg2 = PG_GETARG_INT16(1);
+
+	PG_RETURN_BOOL(arg1 > arg2);
 }
 
-bool
-int42ge(int32 arg1, int32 arg2)
+Datum
+int42ge(PG_FUNCTION_ARGS)
 {
-	return arg1 >= arg2;
+	int32		arg1 = PG_GETARG_INT32(0);
+	int16		arg2 = PG_GETARG_INT16(1);
+
+	PG_RETURN_BOOL(arg1 >= arg2);
 }
 
 /*
@@ -513,159 +556,226 @@ int42ge(int32 arg1, int32 arg2)
  *		int[24]mul		- returns arg1 * arg2
  *		int[24]div		- returns arg1 / arg2
  */
-int32
-int4um(int32 arg)
+
+Datum
+int4um(PG_FUNCTION_ARGS)
 {
-	return -arg;
+	int32		arg = PG_GETARG_INT32(0);
+
+	PG_RETURN_INT32(-arg);
 }
 
-int32
-int4pl(int32 arg1, int32 arg2)
+Datum
+int4pl(PG_FUNCTION_ARGS)
 {
-	return arg1 + arg2;
+	int32		arg1 = PG_GETARG_INT32(0);
+	int32		arg2 = PG_GETARG_INT32(1);
+
+	PG_RETURN_INT32(arg1 + arg2);
 }
 
-int32
-int4mi(int32 arg1, int32 arg2)
+Datum
+int4mi(PG_FUNCTION_ARGS)
 {
-	return arg1 - arg2;
+	int32		arg1 = PG_GETARG_INT32(0);
+	int32		arg2 = PG_GETARG_INT32(1);
+
+	PG_RETURN_INT32(arg1 - arg2);
 }
 
-int32
-int4mul(int32 arg1, int32 arg2)
+Datum
+int4mul(PG_FUNCTION_ARGS)
 {
-	return arg1 * arg2;
+	int32		arg1 = PG_GETARG_INT32(0);
+	int32		arg2 = PG_GETARG_INT32(1);
+
+	PG_RETURN_INT32(arg1 * arg2);
 }
 
-int32
-int4div(int32 arg1, int32 arg2)
+Datum
+int4div(PG_FUNCTION_ARGS)
 {
-	return arg1 / arg2;
+	int32		arg1 = PG_GETARG_INT32(0);
+	int32		arg2 = PG_GETARG_INT32(1);
+
+	PG_RETURN_INT32(arg1 / arg2);
 }
 
-int32
-int4inc(int32 arg)
+Datum
+int4inc(PG_FUNCTION_ARGS)
 {
-	return arg + (int32) 1;
+	int32		arg = PG_GETARG_INT32(0);
+
+	PG_RETURN_INT32(arg + 1);
 }
 
-int16
-int2um(int16 arg)
+Datum
+int2um(PG_FUNCTION_ARGS)
 {
-	return -arg;
+	int16		arg = PG_GETARG_INT16(0);
+
+	PG_RETURN_INT16(-arg);
 }
 
-int16
-int2pl(int16 arg1, int16 arg2)
+Datum
+int2pl(PG_FUNCTION_ARGS)
 {
-	return arg1 + arg2;
+	int16		arg1 = PG_GETARG_INT16(0);
+	int16		arg2 = PG_GETARG_INT16(1);
+
+	PG_RETURN_INT16(arg1 + arg2);
 }
 
-int16
-int2mi(int16 arg1, int16 arg2)
+Datum
+int2mi(PG_FUNCTION_ARGS)
 {
-	return arg1 - arg2;
+	int16		arg1 = PG_GETARG_INT16(0);
+	int16		arg2 = PG_GETARG_INT16(1);
+
+	PG_RETURN_INT16(arg1 - arg2);
 }
 
-int16
-int2mul(int16 arg1, int16 arg2)
+Datum
+int2mul(PG_FUNCTION_ARGS)
 {
-	return arg1 * arg2;
+	int16		arg1 = PG_GETARG_INT16(0);
+	int16		arg2 = PG_GETARG_INT16(1);
+
+	PG_RETURN_INT16(arg1 * arg2);
 }
 
-int16
-int2div(int16 arg1, int16 arg2)
+Datum
+int2div(PG_FUNCTION_ARGS)
 {
-	return arg1 / arg2;
+	int16		arg1 = PG_GETARG_INT16(0);
+	int16		arg2 = PG_GETARG_INT16(1);
+
+	PG_RETURN_INT16(arg1 / arg2);
 }
 
-int16
-int2inc(int16 arg)
+Datum
+int2inc(PG_FUNCTION_ARGS)
 {
-	return arg + (int16) 1;
+	int16		arg = PG_GETARG_INT16(0);
+
+	PG_RETURN_INT16(arg + 1);
 }
 
-int32
-int24pl(int32 arg1, int32 arg2)
+Datum
+int24pl(PG_FUNCTION_ARGS)
 {
-	return arg1 + arg2;
+	int16		arg1 = PG_GETARG_INT16(0);
+	int32		arg2 = PG_GETARG_INT32(1);
+
+	PG_RETURN_INT32(arg1 + arg2);
 }
 
-int32
-int24mi(int32 arg1, int32 arg2)
+Datum
+int24mi(PG_FUNCTION_ARGS)
 {
-	return arg1 - arg2;
+	int16		arg1 = PG_GETARG_INT16(0);
+	int32		arg2 = PG_GETARG_INT32(1);
+
+	PG_RETURN_INT32(arg1 - arg2);
 }
 
-int32
-int24mul(int32 arg1, int32 arg2)
+Datum
+int24mul(PG_FUNCTION_ARGS)
 {
-	return arg1 * arg2;
+	int16		arg1 = PG_GETARG_INT16(0);
+	int32		arg2 = PG_GETARG_INT32(1);
+
+	PG_RETURN_INT32(arg1 * arg2);
 }
 
-int32
-int24div(int32 arg1, int32 arg2)
+Datum
+int24div(PG_FUNCTION_ARGS)
 {
-	return arg1 / arg2;
+	int16		arg1 = PG_GETARG_INT16(0);
+	int32		arg2 = PG_GETARG_INT32(1);
+
+	PG_RETURN_INT32(arg1 / arg2);
 }
 
-int32
-int42pl(int32 arg1, int32 arg2)
+Datum
+int42pl(PG_FUNCTION_ARGS)
 {
-	return arg1 + arg2;
+	int32		arg1 = PG_GETARG_INT32(0);
+	int16		arg2 = PG_GETARG_INT16(1);
+
+	PG_RETURN_INT32(arg1 + arg2);
 }
 
-int32
-int42mi(int32 arg1, int32 arg2)
+Datum
+int42mi(PG_FUNCTION_ARGS)
 {
-	return arg1 - arg2;
+	int32		arg1 = PG_GETARG_INT32(0);
+	int16		arg2 = PG_GETARG_INT16(1);
+
+	PG_RETURN_INT32(arg1 - arg2);
 }
 
-int32
-int42mul(int32 arg1, int32 arg2)
+Datum
+int42mul(PG_FUNCTION_ARGS)
 {
-	return arg1 * arg2;
+	int32		arg1 = PG_GETARG_INT32(0);
+	int16		arg2 = PG_GETARG_INT16(1);
+
+	PG_RETURN_INT32(arg1 * arg2);
 }
 
-int32
-int42div(int32 arg1, int32 arg2)
+Datum
+int42div(PG_FUNCTION_ARGS)
 {
-	return arg1 / arg2;
+	int32		arg1 = PG_GETARG_INT32(0);
+	int16		arg2 = PG_GETARG_INT16(1);
+
+	PG_RETURN_INT32(arg1 / arg2);
 }
 
-/*
- *		int[24]mod		- returns arg1 mod arg2
- */
-int32
-int4mod(int32 arg1, int32 arg2)
+Datum
+int4mod(PG_FUNCTION_ARGS)
 {
-	return arg1 % arg2;
+	int32		arg1 = PG_GETARG_INT32(0);
+	int32		arg2 = PG_GETARG_INT32(1);
+
+	PG_RETURN_INT32(arg1 % arg2);
 }
 
-int32
-int2mod(int16 arg1, int16 arg2)
+Datum
+int2mod(PG_FUNCTION_ARGS)
 {
-	return arg1 % arg2;
+	int16		arg1 = PG_GETARG_INT16(0);
+	int16		arg2 = PG_GETARG_INT16(1);
+
+	PG_RETURN_INT16(arg1 % arg2);
 }
 
-int32
-int24mod(int32 arg1, int32 arg2)
+Datum
+int24mod(PG_FUNCTION_ARGS)
 {
-	return arg1 % arg2;
+	int16		arg1 = PG_GETARG_INT16(0);
+	int32		arg2 = PG_GETARG_INT32(1);
+
+	PG_RETURN_INT32(arg1 % arg2);
 }
 
-int32
-int42mod(int32 arg1, int32 arg2)
+Datum
+int42mod(PG_FUNCTION_ARGS)
 {
-	return arg1 % arg2;
+	int32		arg1 = PG_GETARG_INT32(0);
+	int16		arg2 = PG_GETARG_INT16(1);
+
+	PG_RETURN_INT32(arg1 % arg2);
 }
 
 /* int[24]fac()
  * Factorial
  */
-int32
-int4fac(int32 arg1)
+Datum
+int4fac(PG_FUNCTION_ARGS)
 {
+	int32		arg1 = PG_GETARG_INT32(0);
 	int32		result;
 
 	if (arg1 < 1)
@@ -673,12 +783,13 @@ int4fac(int32 arg1)
 	else
 		for (result = 1; arg1 > 0; --arg1)
 			result *= arg1;
-	return result;
+	PG_RETURN_INT32(result);
 }
 
-int32
-int2fac(int16 arg1)
+Datum
+int2fac(PG_FUNCTION_ARGS)
 {
+	int16		arg1 = PG_GETARG_INT16(0);
 	int32		result;
 
 	if (arg1 < 1)
@@ -686,44 +797,60 @@ int2fac(int16 arg1)
 	else
 		for (result = 1; arg1 > 0; --arg1)
 			result *= arg1;
-	return result;
+	PG_RETURN_INT32(result);
 }
 
 /* int[24]abs()
  * Absolute value
  */
-int32
-int4abs(int32 arg1)
+Datum
+int4abs(PG_FUNCTION_ARGS)
 {
-	return ((arg1 < 0) ? -arg1 : arg1);
+	int32		arg1 = PG_GETARG_INT32(0);
+
+	PG_RETURN_INT32((arg1 < 0) ? -arg1 : arg1);
 }
 
-int16
-int2abs(int16 arg1)
+Datum
+int2abs(PG_FUNCTION_ARGS)
 {
-	return ((arg1 < 0) ? -arg1 : arg1);
+	int16		arg1 = PG_GETARG_INT16(0);
+
+	PG_RETURN_INT16((arg1 < 0) ? -arg1 : arg1);
 }
 
-int16
-int2larger(int16 arg1, int16 arg2)
+Datum
+int2larger(PG_FUNCTION_ARGS)
 {
-	return (arg1 > arg2) ? arg1 : arg2;
+	int16		arg1 = PG_GETARG_INT16(0);
+	int16		arg2 = PG_GETARG_INT16(1);
+
+	PG_RETURN_INT16((arg1 > arg2) ? arg1 : arg2);
 }
 
-int16
-int2smaller(int16 arg1, int16 arg2)
+Datum
+int2smaller(PG_FUNCTION_ARGS)
 {
-	return (arg1 < arg2) ? arg1 : arg2;
+	int16		arg1 = PG_GETARG_INT16(0);
+	int16		arg2 = PG_GETARG_INT16(1);
+
+	PG_RETURN_INT16((arg1 < arg2) ? arg1 : arg2);
 }
 
-int32
-int4larger(int32 arg1, int32 arg2)
+Datum
+int4larger(PG_FUNCTION_ARGS)
 {
-	return (arg1 > arg2) ? arg1 : arg2;
+	int32		arg1 = PG_GETARG_INT32(0);
+	int32		arg2 = PG_GETARG_INT32(1);
+
+	PG_RETURN_INT32((arg1 > arg2) ? arg1 : arg2);
 }
 
-int32
-int4smaller(int32 arg1, int32 arg2)
+Datum
+int4smaller(PG_FUNCTION_ARGS)
 {
-	return (arg1 < arg2) ? arg1 : arg2;
+	int32		arg1 = PG_GETARG_INT32(0);
+	int32		arg2 = PG_GETARG_INT32(1);
+
+	PG_RETURN_INT32((arg1 < arg2) ? arg1 : arg2);
 }
diff --git a/src/backend/utils/adt/misc.c b/src/backend/utils/adt/misc.c
index 00af6350de..7e3b8b167b 100644
--- a/src/backend/utils/adt/misc.c
+++ b/src/backend/utils/adt/misc.c
@@ -8,44 +8,39 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/misc.c,v 1.18 2000/01/26 05:57:14 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/misc.c,v 1.19 2000/06/05 07:28:52 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
 #include <sys/types.h>
 #include <sys/file.h>
 #include <time.h>
+
 #include "postgres.h"
+
 #include "utils/builtins.h"
 
-/*-------------------------------------------------------------------------
+
+/*
  * Check if data is Null
  */
-bool
-nullvalue(Datum value, bool *isNull)
+Datum
+nullvalue(PG_FUNCTION_ARGS)
 {
-	if (*isNull)
-	{
-		*isNull = false;
-		return true;
-	}
-	return false;
-
+	if (PG_ARGISNULL(0))
+		PG_RETURN_BOOL(true);
+	PG_RETURN_BOOL(false);
 }
 
-/*----------------------------------------------------------------------*
- *	   check if data is not Null										*
- *--------------------------------------------------------------------- */
-bool
-nonnullvalue(Datum value, bool *isNull)
+/*
+ * Check if data is not Null
+ */
+Datum
+nonnullvalue(PG_FUNCTION_ARGS)
 {
-	if (*isNull)
-	{
-		*isNull = false;
-		return false;
-	}
-	return true;
-
+	if (PG_ARGISNULL(0))
+		PG_RETURN_BOOL(false);
+	PG_RETURN_BOOL(true);
 }
 
 /*
@@ -63,13 +58,18 @@ nonnullvalue(Datum value, bool *isNull)
 
 static bool random_initialized = false;
 
-bool
-oidrand(Oid o, int32 X)
+Datum
+oidrand(PG_FUNCTION_ARGS)
 {
+	/* XXX seems like we ought to be using the oid for something? */
+#ifdef NOT_USED
+	Oid			o = PG_GETARG_OID(0);
+#endif
+	int32		X = PG_GETARG_INT32(1);
 	bool		result;
 
 	if (X == 0)
-		return true;
+		PG_RETURN_BOOL(true);
 
 	/*
 	 * We do this because the cancel key is actually a random, so we don't
@@ -83,26 +83,29 @@ oidrand(Oid o, int32 X)
 	}
 
 	result = (random() % X == 0);
-	return result;
+	PG_RETURN_BOOL(result);
 }
 
 /*
    oidsrand(int32 X) -
 	  seeds the random number generator
-	  always return true
+	  always returns true
 */
-bool
-oidsrand(int32 X)
+Datum
+oidsrand(PG_FUNCTION_ARGS)
 {
+	int32		X = PG_GETARG_INT32(0);
+
 	srand(X);
 	random_initialized = true;
-	return true;
+	PG_RETURN_BOOL(true);
 }
 
 
-
-int32
-userfntest(int i)
+Datum
+userfntest(PG_FUNCTION_ARGS)
 {
-	return i;
+	int32		i = PG_GETARG_INT32(0);
+
+	PG_RETURN_INT32(i);
 }
diff --git a/src/backend/utils/adt/numeric.c b/src/backend/utils/adt/numeric.c
index 36e333e121..500cb151ac 100644
--- a/src/backend/utils/adt/numeric.c
+++ b/src/backend/utils/adt/numeric.c
@@ -5,7 +5,7 @@
  *
  *	1998 Jan Wieck
  *
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/numeric.c,v 1.27 2000/04/12 17:15:50 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/numeric.c,v 1.28 2000/06/05 07:28:52 tgl Exp $
  *
  * ----------
  */
@@ -33,6 +33,9 @@
  * Local definitions
  * ----------
  */
+#define PG_GETARG_NUMERIC(n)  ((Numeric) DatumGetPointer(fcinfo->arg[n]))
+#define PG_RETURN_NUMERIC(x)  return PointerGetDatum(x)
+
 #ifndef MIN
 #define MIN(a,b) (((a)<(b)) ? (a) : (b))
 #endif
@@ -1714,7 +1717,8 @@ int4_numeric(int32 val)
 
 	init_var(&result);
 
-	tmp = int4out(val);
+	tmp = DatumGetCString(DirectFunctionCall1(int4out,
+											  Int32GetDatum(val)));
 	set_var_from_str(tmp, &result);
 	res = make_result(&result);
 
@@ -1730,7 +1734,7 @@ numeric_int4(Numeric num)
 {
 	NumericVar	x;
 	char	   *str;
-	int32		result;
+	Datum		result;
 
 	if (num == NULL)
 		return 0;
@@ -1749,7 +1753,7 @@ numeric_int4(Numeric num)
 
 	free_var(&x);
 
-	result = int4in(str);
+	result = DirectFunctionCall1(int4in, CStringGetDatum(str));
 	pfree(str);
 
 	return result;
@@ -1807,35 +1811,35 @@ numeric_int8(Numeric num)
 }
 
 
-Numeric
-int2_numeric(int16 val)
+Datum
+int2_numeric(PG_FUNCTION_ARGS)
 {
+	int16		val = PG_GETARG_INT16(0);
 	Numeric		res;
 	NumericVar	result;
 	char	   *tmp;
 
 	init_var(&result);
 
-	tmp = int2out(val);
+	tmp = DatumGetCString(DirectFunctionCall1(int2out,
+											  Int16GetDatum(val)));
 	set_var_from_str(tmp, &result);
 	res = make_result(&result);
 
 	free_var(&result);
 	pfree(tmp);
 
-	return res;
+	PG_RETURN_NUMERIC(res);
 }
 
 
-int16
-numeric_int2(Numeric num)
+Datum
+numeric_int2(PG_FUNCTION_ARGS)
 {
+	Numeric		num = PG_GETARG_NUMERIC(0);
 	NumericVar	x;
 	char	   *str;
-	int16		result;
-
-	if (num == NULL)
-		return 0;
+	Datum		result;
 
 	if (NUMERIC_IS_NAN(num))
 		elog(ERROR, "Cannot convert NaN to int2");
@@ -1851,7 +1855,7 @@ numeric_int2(Numeric num)
 
 	free_var(&x);
 
-	result = int2in(str);
+	result = DirectFunctionCall1(int2in, CStringGetDatum(str));
 	pfree(str);
 
 	return result;
diff --git a/src/backend/utils/adt/oid.c b/src/backend/utils/adt/oid.c
index 96640af91e..2f1651378c 100644
--- a/src/backend/utils/adt/oid.c
+++ b/src/backend/utils/adt/oid.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/oid.c,v 1.34 2000/04/12 17:15:51 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/oid.c,v 1.35 2000/06/05 07:28:52 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -26,17 +26,15 @@
  *		oidvectorin			- converts "num num ..." to internal form
  *
  *		Note:
- *				Fills any nonexistent digits with NULL oids.
+ *				Fills any unsupplied positions with InvalidOid.
  */
-Oid *
-oidvectorin(char *oidString)
+Datum
+oidvectorin(PG_FUNCTION_ARGS)
 {
+	char	   *oidString = PG_GETARG_CSTRING(0);
 	Oid		   *result;
 	int			slot;
 
-	if (oidString == NULL)
-		return NULL;
-
 	result = (Oid *) palloc(sizeof(Oid[INDEX_MAX_KEYS]));
 
 	for (slot = 0; *oidString && slot < INDEX_MAX_KEYS; slot++)
@@ -53,30 +51,23 @@ oidvectorin(char *oidString)
 	if (*oidString)
 		elog(ERROR, "oidvector value has too many values");
 	while (slot < INDEX_MAX_KEYS)
-		result[slot++] = 0;
+		result[slot++] = InvalidOid;
 
-	return result;
+	PG_RETURN_POINTER(result);
 }
 
 /*
  *		oidvectorout - converts internal form to "num num ..."
  */
-char *
-oidvectorout(Oid *oidArray)
+Datum
+oidvectorout(PG_FUNCTION_ARGS)
 {
+	Oid		   *oidArray = (Oid *) PG_GETARG_POINTER(0);
 	int			num,
 				maxnum;
 	char	   *rp;
 	char	   *result;
 
-	if (oidArray == NULL)
-	{
-		result = (char *) palloc(2);
-		result[0] = '-';
-		result[1] = '\0';
-		return result;
-	}
-
 	/* find last non-zero value in vector */
 	for (maxnum = INDEX_MAX_KEYS - 1; maxnum >= 0; maxnum--)
 		if (oidArray[maxnum] != 0)
@@ -93,147 +84,177 @@ oidvectorout(Oid *oidArray)
 			;
 	}
 	*rp = '\0';
-	return result;
+	PG_RETURN_CSTRING(result);
 }
 
-Oid
-oidin(char *s)
+Datum
+oidin(PG_FUNCTION_ARGS)
 {
-	return int4in(s);
+	char	   *s = PG_GETARG_CSTRING(0);
+
+	/* XXX should use an unsigned-int conversion here */
+	return DirectFunctionCall1(int4in, CStringGetDatum(s));
 }
 
-char *
-oidout(Oid o)
+Datum
+oidout(PG_FUNCTION_ARGS)
 {
-	return int4out(o);
+	Oid			o = PG_GETARG_OID(0);
+
+	/* XXX should use an unsigned-int conversion here */
+	return DirectFunctionCall1(int4out, ObjectIdGetDatum(o));
 }
 
 /*****************************************************************************
  *	 PUBLIC ROUTINES														 *
  *****************************************************************************/
 
-/*
- * If you change this function, change heap_keytest()
- * because we have hardcoded this in there as an optimization
- */
-bool
-oideq(Oid arg1, Oid arg2)
+Datum
+oideq(PG_FUNCTION_ARGS)
 {
-	return arg1 == arg2;
+	Oid			arg1 = PG_GETARG_OID(0);
+	Oid			arg2 = PG_GETARG_OID(1);
+
+	PG_RETURN_BOOL(arg1 == arg2);
 }
 
-bool
-oidne(Oid arg1, Oid arg2)
+Datum
+oidne(PG_FUNCTION_ARGS)
 {
-	return arg1 != arg2;
+	Oid			arg1 = PG_GETARG_OID(0);
+	Oid			arg2 = PG_GETARG_OID(1);
+
+	PG_RETURN_BOOL(arg1 != arg2);
 }
 
-bool
-oidvectoreq(Oid *arg1, Oid *arg2)
+Datum
+oidvectoreq(PG_FUNCTION_ARGS)
 {
-	return (bool) (memcmp(arg1, arg2, INDEX_MAX_KEYS * sizeof(Oid)) == 0);
+	Oid			*arg1 = (Oid *) PG_GETARG_POINTER(0);
+	Oid			*arg2 = (Oid *) PG_GETARG_POINTER(1);
+
+	PG_RETURN_BOOL(memcmp(arg1, arg2, INDEX_MAX_KEYS * sizeof(Oid)) == 0);
 }
 
-bool
-oidvectorne(Oid *arg1, Oid *arg2)
+Datum
+oidvectorne(PG_FUNCTION_ARGS)
 {
-	return (bool) (memcmp(arg1, arg2, INDEX_MAX_KEYS * sizeof(Oid)) != 0);
+	Oid			*arg1 = (Oid *) PG_GETARG_POINTER(0);
+	Oid			*arg2 = (Oid *) PG_GETARG_POINTER(1);
+
+	PG_RETURN_BOOL(memcmp(arg1, arg2, INDEX_MAX_KEYS * sizeof(Oid)) != 0);
 }
 
-bool
-oidvectorlt(Oid *arg1, Oid *arg2)
+Datum
+oidvectorlt(PG_FUNCTION_ARGS)
 {
+	Oid			*arg1 = (Oid *) PG_GETARG_POINTER(0);
+	Oid			*arg2 = (Oid *) PG_GETARG_POINTER(1);
 	int			i;
 
 	for (i = 0; i < INDEX_MAX_KEYS; i++)
-		if (!int4eq(arg1[i], arg2[i]))
-			return int4lt(arg1[i], arg2[i]);
-	return false;
+		if (arg1[i] != arg2[i])
+			PG_RETURN_BOOL(arg1[i] < arg2[i]);
+	PG_RETURN_BOOL(false);
 }
 
-bool
-oidvectorle(Oid *arg1, Oid *arg2)
+Datum
+oidvectorle(PG_FUNCTION_ARGS)
 {
+	Oid			*arg1 = (Oid *) PG_GETARG_POINTER(0);
+	Oid			*arg2 = (Oid *) PG_GETARG_POINTER(1);
 	int			i;
 
 	for (i = 0; i < INDEX_MAX_KEYS; i++)
-		if (!int4eq(arg1[i], arg2[i]))
-			return int4le(arg1[i], arg2[i]);
-	return true;
+		if (arg1[i] != arg2[i])
+			PG_RETURN_BOOL(arg1[i] <= arg2[i]);
+	PG_RETURN_BOOL(true);
 }
 
-bool
-oidvectorge(Oid *arg1, Oid *arg2)
+Datum
+oidvectorge(PG_FUNCTION_ARGS)
 {
+	Oid			*arg1 = (Oid *) PG_GETARG_POINTER(0);
+	Oid			*arg2 = (Oid *) PG_GETARG_POINTER(1);
 	int			i;
 
 	for (i = 0; i < INDEX_MAX_KEYS; i++)
-		if (!int4eq(arg1[i], arg2[i]))
-			return int4ge(arg1[i], arg2[i]);
-	return true;
+		if (arg1[i] != arg2[i])
+			PG_RETURN_BOOL(arg1[i] >= arg2[i]);
+	PG_RETURN_BOOL(true);
 }
 
-bool
-oidvectorgt(Oid *arg1, Oid *arg2)
+Datum
+oidvectorgt(PG_FUNCTION_ARGS)
 {
+	Oid			*arg1 = (Oid *) PG_GETARG_POINTER(0);
+	Oid			*arg2 = (Oid *) PG_GETARG_POINTER(1);
 	int			i;
 
 	for (i = 0; i < INDEX_MAX_KEYS; i++)
-		if (!int4eq(arg1[i], arg2[i]))
-			return int4gt(arg1[i], arg2[i]);
-	return false;
+		if (arg1[i] != arg2[i])
+			PG_RETURN_BOOL(arg1[i] > arg2[i]);
+	PG_RETURN_BOOL(false);
 }
 
-bool
-oideqint4(Oid arg1, int32 arg2)
+Datum
+oideqint4(PG_FUNCTION_ARGS)
 {
-/* oid is unsigned, but int4 is signed */
-	return arg2 >= 0 && arg1 == arg2;
+	Oid			arg1 = PG_GETARG_OID(0);
+	int32		arg2 = PG_GETARG_INT32(1);
+
+	/* oid is unsigned, but int4 is signed */
+	PG_RETURN_BOOL(arg2 >= 0 && arg1 == arg2);
 }
 
-bool
-int4eqoid(int32 arg1, Oid arg2)
+Datum
+int4eqoid(PG_FUNCTION_ARGS)
 {
-/* oid is unsigned, but int4 is signed */
-	return arg1 >= 0 && arg1 == arg2;
+	int32		arg1 = PG_GETARG_INT32(0);
+	Oid			arg2 = PG_GETARG_OID(1);
+
+	/* oid is unsigned, but int4 is signed */
+	PG_RETURN_BOOL(arg1 >= 0 && arg1 == arg2);
 }
 
-text *
-oid_text(Oid oid)
+Datum
+oid_text(PG_FUNCTION_ARGS)
 {
+	Oid			oid = PG_GETARG_OID(0);
 	text	   *result;
-
 	int			len;
 	char	   *str;
 
-	str = oidout(oid);
-	len = (strlen(str) + VARHDRSZ);
+	str = DatumGetCString(DirectFunctionCall1(oidout,
+											  ObjectIdGetDatum(oid)));
+	len = strlen(str) + VARHDRSZ;
 
-	result = palloc(len);
+	result = (text *) palloc(len);
 
 	VARSIZE(result) = len;
-	memmove(VARDATA(result), str, (len - VARHDRSZ));
+	memcpy(VARDATA(result), str, (len - VARHDRSZ));
 	pfree(str);
 
-	return result;
-}	/* oid_text() */
+	PG_RETURN_TEXT_P(result);
+}
 
-Oid
-text_oid(text *string)
+Datum
+text_oid(PG_FUNCTION_ARGS)
 {
+	text	   *string = PG_GETARG_TEXT_P(0);
 	Oid			result;
-
 	int			len;
 	char	   *str;
 
 	len = (VARSIZE(string) - VARHDRSZ);
 
 	str = palloc(len + 1);
-	memmove(str, VARDATA(string), len);
+	memcpy(str, VARDATA(string), len);
 	*(str + len) = '\0';
 
-	result = oidin(str);
+	result = DatumGetObjectId(DirectFunctionCall1(oidin,
+												  CStringGetDatum(str)));
 	pfree(str);
 
-	return result;
-}	/* oid_text() */
+	PG_RETURN_OID(result);
+}
diff --git a/src/backend/utils/adt/regproc.c b/src/backend/utils/adt/regproc.c
index 6db76ac8c5..c5fbeadff6 100644
--- a/src/backend/utils/adt/regproc.c
+++ b/src/backend/utils/adt/regproc.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/regproc.c,v 1.55 2000/05/28 17:56:05 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/regproc.c,v 1.56 2000/06/05 07:28:52 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -34,17 +34,16 @@
  *
  *		proid of '-' signifies unknown, for consistency with regprocout
  */
-int32
-regprocin(char *pro_name_or_oid)
+Datum
+regprocin(PG_FUNCTION_ARGS)
 {
-	HeapTuple	proctup = NULL;
+	char	   *pro_name_or_oid = PG_GETARG_CSTRING(0);
+	HeapTuple	proctup;
 	HeapTupleData tuple;
 	RegProcedure result = InvalidOid;
 
-	if (pro_name_or_oid == NULL)
-		return InvalidOid;
 	if (pro_name_or_oid[0] == '-' && pro_name_or_oid[1] == '\0')
-		return InvalidOid;
+		PG_RETURN_OID(InvalidOid);
 
 	if (!IsIgnoringSystemIndexes())
 	{
@@ -57,7 +56,8 @@ regprocin(char *pro_name_or_oid)
 			pro_name_or_oid[0] <= '9')
 		{
 			proctup = SearchSysCacheTuple(PROCOID,
-								ObjectIdGetDatum(oidin(pro_name_or_oid)),
+										  DirectFunctionCall1(oidin,
+											CStringGetDatum(pro_name_or_oid)),
 										  0, 0, 0);
 			if (HeapTupleIsValid(proctup))
 				result = (RegProcedure) proctup->t_data->t_oid;
@@ -78,7 +78,7 @@ regprocin(char *pro_name_or_oid)
 								   (bits16) 0x0,
 								   (AttrNumber) 1,
 								   (RegProcedure) F_NAMEEQ,
-								   PointerGetDatum(pro_name_or_oid));
+								   CStringGetDatum(pro_name_or_oid));
 
 			hdesc = heap_openr(ProcedureRelationName, AccessShareLock);
 			idesc = index_openr(ProcedureNameIndex);
@@ -125,7 +125,7 @@ regprocin(char *pro_name_or_oid)
 							   (bits16) 0,
 							   (AttrNumber) 1,
 							   (RegProcedure) F_NAMEEQ,
-							   (Datum) pro_name_or_oid);
+							   CStringGetDatum(pro_name_or_oid));
 
 		procscan = heap_beginscan(proc, 0, SnapshotNow, 1, &key);
 		if (!HeapScanIsValid(procscan))
@@ -133,7 +133,7 @@ regprocin(char *pro_name_or_oid)
 			heap_close(proc, AccessShareLock);
 			elog(ERROR, "regprocin: could not begin scan of %s",
 				 ProcedureRelationName);
-			return 0;
+			PG_RETURN_OID(InvalidOid);
 		}
 		proctup = heap_getnext(procscan, 0);
 		if (HeapTupleIsValid(proctup))
@@ -143,24 +143,25 @@ regprocin(char *pro_name_or_oid)
 												 RelationGetDescr(proc),
 												 &isnull);
 			if (isnull)
-				elog(FATAL, "regprocin: null procedure %s", pro_name_or_oid);
+				elog(ERROR, "regprocin: null procedure %s", pro_name_or_oid);
 		}
 		else
-			result = (RegProcedure) 0;
+			elog(ERROR, "No procedure with name %s", pro_name_or_oid);
 
 		heap_endscan(procscan);
 		heap_close(proc, AccessShareLock);
 	}
 
-	return (int32) result;
+	PG_RETURN_OID(result);
 }
 
 /*
  *		regprocout		- converts proid to "pro_name"
  */
-char *
-regprocout(RegProcedure proid)
+Datum
+regprocout(PG_FUNCTION_ARGS)
 {
+	RegProcedure proid = PG_GETARG_OID(0);
 	HeapTuple	proctup;
 	char	   *result;
 
@@ -170,7 +171,7 @@ regprocout(RegProcedure proid)
 	{
 		result[0] = '-';
 		result[1] = '\0';
-		return result;
+		PG_RETURN_CSTRING(result);
 	}
 
 	if (!IsBootstrapProcessingMode())
@@ -203,7 +204,7 @@ regprocout(RegProcedure proid)
 							   (bits16) 0,
 							   (AttrNumber) ObjectIdAttributeNumber,
 							   (RegProcedure) F_INT4EQ,
-							   (Datum) proid);
+							   ObjectIdGetDatum(proid));
 
 		procscan = heap_beginscan(proc, 0, SnapshotNow, 1, &key);
 		if (!HeapScanIsValid(procscan))
@@ -211,7 +212,6 @@ regprocout(RegProcedure proid)
 			heap_close(proc, AccessShareLock);
 			elog(ERROR, "regprocout: could not begin scan of %s",
 				 ProcedureRelationName);
-			return 0;
 		}
 		proctup = heap_getnext(procscan, 0);
 		if (HeapTupleIsValid(proctup))
@@ -224,7 +224,7 @@ regprocout(RegProcedure proid)
 			if (!isnull)
 				StrNCpy(result, s, NAMEDATALEN);
 			else
-				elog(FATAL, "regprocout: null procedure %u", proid);
+				elog(ERROR, "regprocout: null procedure %u", proid);
 		}
 		else
 		{
@@ -235,7 +235,7 @@ regprocout(RegProcedure proid)
 		heap_close(proc, AccessShareLock);
 	}
 
-	return result;
+	PG_RETURN_CSTRING(result);
 }
 
 /*
@@ -245,21 +245,15 @@ regprocout(RegProcedure proid)
  * OIDs are significant in the input vector, so that trailing InvalidOid
  * argument types can be recognized.
  */
-text *
-oidvectortypes(Oid *oidArray)
+Datum
+oidvectortypes(PG_FUNCTION_ARGS)
 {
+	Oid		   *oidArray = (Oid *) PG_GETARG_POINTER(0);
 	HeapTuple	typetup;
 	text	   *result;
 	int			numargs,
 				num;
 
-	if (oidArray == NULL)
-	{
-		result = (text *) palloc(VARHDRSZ);
-		VARSIZE(result) = 0;
-		return result;
-	}
-
 	/* Try to guess how many args there are :-( */
 	numargs = 0;
 	for (num = 0; num < FUNC_MAX_ARGS; num++)
@@ -289,7 +283,7 @@ oidvectortypes(Oid *oidArray)
 			strcat(VARDATA(result), "- ");
 	}
 	VARSIZE(result) = strlen(VARDATA(result)) + VARHDRSZ;
-	return result;
+	PG_RETURN_TEXT_P(result);
 }
 
 
@@ -302,10 +296,12 @@ oidvectortypes(Oid *oidArray)
  * Define RegprocToOid() as a macro in builtins.h.
  * Referenced in pg_proc.h. - tgl 97/04/26
  */
-Oid
-regproctooid(RegProcedure rp)
+Datum
+regproctooid(PG_FUNCTION_ARGS)
 {
-	return (Oid) rp;
+	RegProcedure rp = PG_GETARG_OID(0);
+
+	PG_RETURN_OID((Oid) rp);
 }
 
 /* (see int.c for comparison/operation routines) */
diff --git a/src/backend/utils/adt/selfuncs.c b/src/backend/utils/adt/selfuncs.c
index 611f57f9ac..fb1a77cfbd 100644
--- a/src/backend/utils/adt/selfuncs.c
+++ b/src/backend/utils/adt/selfuncs.c
@@ -15,7 +15,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/selfuncs.c,v 1.68 2000/05/30 04:24:51 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/selfuncs.c,v 1.69 2000/06/05 07:28:52 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -44,9 +44,6 @@
 /* N is not a valid var/constant or relation id */
 #define NONVALUE(N)		((N) == 0)
 
-/* are we looking at a functional index selectivity request? */
-#define FunctionalSelectivity(nIndKeys,attNum) ((attNum)==InvalidAttrNumber)
-
 /* default selectivity estimate for equalities such as "A = b" */
 #define DEFAULT_EQ_SEL	0.01
 
@@ -106,18 +103,18 @@ static Datum string_to_datum(const char *str, Oid datatype);
  * of the given constant "value" may be different from the type of the
  * attribute.
  */
-float64
-eqsel(Oid opid,
-	  Oid relid,
-	  AttrNumber attno,
-	  Datum value,
-	  int32 flag)
+Datum
+eqsel(PG_FUNCTION_ARGS)
 {
-	float64		result;
+	Oid			opid = PG_GETARG_OID(0);
+	Oid			relid = PG_GETARG_OID(1);
+	AttrNumber	attno = PG_GETARG_INT16(2);
+	Datum		value = PG_GETARG_DATUM(3);
+	int32		flag = PG_GETARG_INT32(4);
+	float8		result;
 
-	result = (float64) palloc(sizeof(float64data));
 	if (NONVALUE(attno) || NONVALUE(relid))
-		*result = DEFAULT_EQ_SEL;
+		result = DEFAULT_EQ_SEL;
 	else
 	{
 		Oid			typid;
@@ -239,9 +236,9 @@ eqsel(Oid opid,
 			selec = get_attdisbursion(relid, attno, 0.01);
 		}
 
-		*result = (float64data) selec;
+		result = (float8) selec;
 	}
-	return result;
+	PG_RETURN_FLOAT8(result);
 }
 
 /*
@@ -251,18 +248,14 @@ eqsel(Oid opid,
  * but have comparable selectivity behavior.  See above comments
  * for eqsel().
  */
-float64
-neqsel(Oid opid,
-	   Oid relid,
-	   AttrNumber attno,
-	   Datum value,
-	   int32 flag)
+Datum
+neqsel(PG_FUNCTION_ARGS)
 {
-	float64		result;
+	float8		result;
 
-	result = eqsel(opid, relid, attno, value, flag);
-	*result = 1.0 - *result;
-	return result;
+	result = DatumGetFloat8(eqsel(fcinfo));
+	result = 1.0 - result;
+	PG_RETURN_FLOAT8(result);
 }
 
 /*
@@ -272,18 +265,18 @@ neqsel(Oid opid,
  * convert_to_scalar().  If it is applied to some other datatype,
  * it will return a default estimate.
  */
-float64
-scalarltsel(Oid opid,
-			Oid relid,
-			AttrNumber attno,
-			Datum value,
-			int32 flag)
+Datum
+scalarltsel(PG_FUNCTION_ARGS)
 {
-	float64		result;
+	Oid			opid = PG_GETARG_OID(0);
+	Oid			relid = PG_GETARG_OID(1);
+	AttrNumber	attno = PG_GETARG_INT16(2);
+	Datum		value = PG_GETARG_DATUM(3);
+	int32		flag = PG_GETARG_INT32(4);
+	float8		result;
 
-	result = (float64) palloc(sizeof(float64data));
 	if (!(flag & SEL_CONSTANT) || NONVALUE(attno) || NONVALUE(relid))
-		*result = DEFAULT_INEQ_SEL;
+		result = DEFAULT_INEQ_SEL;
 	else
 	{
 		HeapTuple	oprtuple;
@@ -322,8 +315,7 @@ scalarltsel(Oid opid,
 							  &loval, &hival))
 		{
 			/* no stats available, so default result */
-			*result = DEFAULT_INEQ_SEL;
-			return result;
+			PG_RETURN_FLOAT8(DEFAULT_INEQ_SEL);
 		}
 
 		/* Convert the values to a uniform comparison scale. */
@@ -344,8 +336,7 @@ scalarltsel(Oid opid,
 				pfree(DatumGetPointer(hival));
 				pfree(DatumGetPointer(loval));
 			}
-			*result = DEFAULT_INEQ_SEL;
-			return result;
+			PG_RETURN_FLOAT8(DEFAULT_INEQ_SEL);
 		}
 
 		/* release temp storage if needed */
@@ -364,7 +355,7 @@ scalarltsel(Oid opid,
 			 * point the constant is on.  But it seems better to assume
 			 * that the stats are wrong and return a default...
 			 */
-			*result = DEFAULT_INEQ_SEL;
+			result = DEFAULT_INEQ_SEL;
 		}
 		else if (val < low || val > high)
 		{
@@ -375,9 +366,9 @@ scalarltsel(Oid opid,
 			 * chance the stats are out of date.
 			 */
 			if (flag & SEL_RIGHT)
-				*result = (val < low) ? 0.001 : 0.999;
+				result = (val < low) ? 0.001 : 0.999;
 			else
-				*result = (val < low) ? 0.999 : 0.001;
+				result = (val < low) ? 0.999 : 0.001;
 		}
 		else
 		{
@@ -386,10 +377,10 @@ scalarltsel(Oid opid,
 				numerator = val - low;
 			else
 				numerator = high - val;
-			*result = numerator / denominator;
+			result = numerator / denominator;
 		}
 	}
-	return result;
+	PG_RETURN_FLOAT8(result);
 }
 
 /*
@@ -397,42 +388,37 @@ scalarltsel(Oid opid,
  *
  * See above comments for scalarltsel.
  */
-float64
-scalargtsel(Oid opid,
-			Oid relid,
-			AttrNumber attno,
-			Datum value,
-			int32 flag)
+Datum
+scalargtsel(PG_FUNCTION_ARGS)
 {
-	float64		result;
+	float8		result;
 
 	/*
 	 * Compute selectivity of "<", then invert --- but only if we were
 	 * able to produce a non-default estimate.
 	 */
-	result = scalarltsel(opid, relid, attno, value, flag);
-	if (*result != DEFAULT_INEQ_SEL)
-		*result = 1.0 - *result;
-	return result;
+	result = DatumGetFloat8(scalarltsel(fcinfo));
+	if (result != DEFAULT_INEQ_SEL)
+		result = 1.0 - result;
+	PG_RETURN_FLOAT8(result);
 }
 
 /*
  * patternsel			- Generic code for pattern-match selectivity.
  */
-static float64
-patternsel(Oid opid,
-		   Pattern_Type ptype,
-		   Oid relid,
-		   AttrNumber attno,
-		   Datum value,
-		   int32 flag)
+static Datum
+patternsel(PG_FUNCTION_ARGS, Pattern_Type ptype)
 {
-	float64		result;
+	Oid			opid = PG_GETARG_OID(0);
+	Oid			relid = PG_GETARG_OID(1);
+	AttrNumber	attno = PG_GETARG_INT16(2);
+	Datum		value = PG_GETARG_DATUM(3);
+	int32		flag = PG_GETARG_INT32(4);
+	float8		result;
 
-	result = (float64) palloc(sizeof(float64data));
 	/* Must have a constant for the pattern, or cannot learn anything */
 	if ((flag & (SEL_CONSTANT | SEL_RIGHT)) != (SEL_CONSTANT | SEL_RIGHT))
-		*result = DEFAULT_MATCH_SEL;
+		result = DEFAULT_MATCH_SEL;
 	else
 	{
 		HeapTuple	oprtuple;
@@ -469,7 +455,12 @@ patternsel(Oid opid,
 			if (eqopr == InvalidOid)
 				elog(ERROR, "patternsel: no = operator for type %u", ltype);
 			eqcon = string_to_datum(prefix, ltype);
-			result = eqsel(eqopr, relid, attno, eqcon, SEL_CONSTANT|SEL_RIGHT);
+			result = DatumGetFloat8(DirectFunctionCall5(eqsel,
+									ObjectIdGetDatum(eqopr),
+									ObjectIdGetDatum(relid),
+									Int16GetDatum(attno),
+									eqcon,
+									Int32GetDatum(SEL_CONSTANT|SEL_RIGHT)));
 			pfree(DatumGetPointer(eqcon));
 		}
 		else
@@ -494,125 +485,103 @@ patternsel(Oid opid,
 				selec = 0.0;
 			else if (selec > 1.0)
 				selec = 1.0;
-			*result = (float64data) selec;
+			result = (float8) selec;
 		}
 		if (prefix)
 			pfree(prefix);
 		pfree(patt);
 	}
-	return result;
+	PG_RETURN_FLOAT8(result);
 }
 
 /*
  *		regexeqsel		- Selectivity of regular-expression pattern match.
  */
-float64
-regexeqsel(Oid opid,
-		   Oid relid,
-		   AttrNumber attno,
-		   Datum value,
-		   int32 flag)
+Datum
+regexeqsel(PG_FUNCTION_ARGS)
 {
-	return patternsel(opid, Pattern_Type_Regex, relid, attno, value, flag);
+	return patternsel(fcinfo, Pattern_Type_Regex);
 }
 
 /*
  *		icregexeqsel	- Selectivity of case-insensitive regex match.
  */
-float64
-icregexeqsel(Oid opid,
-			 Oid relid,
-			 AttrNumber attno,
-			 Datum value,
-			 int32 flag)
+Datum
+icregexeqsel(PG_FUNCTION_ARGS)
 {
-	return patternsel(opid, Pattern_Type_Regex_IC, relid, attno, value, flag);
+	return patternsel(fcinfo, Pattern_Type_Regex_IC);
 }
 
 /*
  *		likesel			- Selectivity of LIKE pattern match.
  */
-float64
-likesel(Oid opid,
-		Oid relid,
-		AttrNumber attno,
-		Datum value,
-		int32 flag)
+Datum
+likesel(PG_FUNCTION_ARGS)
 {
-	return patternsel(opid, Pattern_Type_Like, relid, attno, value, flag);
+	return patternsel(fcinfo, Pattern_Type_Like);
 }
 
 /*
  *		regexnesel		- Selectivity of regular-expression pattern non-match.
  */
-float64
-regexnesel(Oid opid,
-		   Oid relid,
-		   AttrNumber attno,
-		   Datum value,
-		   int32 flag)
+Datum
+regexnesel(PG_FUNCTION_ARGS)
 {
-	float64		result;
+	float8		result;
 
-	result = patternsel(opid, Pattern_Type_Regex, relid, attno, value, flag);
-	*result = 1.0 - *result;
-	return result;
+	result = DatumGetFloat8(patternsel(fcinfo, Pattern_Type_Regex));
+	result = 1.0 - result;
+	PG_RETURN_FLOAT8(result);
 }
 
 /*
  *		icregexnesel	- Selectivity of case-insensitive regex non-match.
  */
-float64
-icregexnesel(Oid opid,
-			 Oid relid,
-			 AttrNumber attno,
-			 Datum value,
-			 int32 flag)
+Datum
+icregexnesel(PG_FUNCTION_ARGS)
 {
-	float64		result;
+	float8		result;
 
-	result = patternsel(opid, Pattern_Type_Regex_IC, relid, attno, value, flag);
-	*result = 1.0 - *result;
-	return result;
+	result = DatumGetFloat8(patternsel(fcinfo, Pattern_Type_Regex_IC));
+	result = 1.0 - result;
+	PG_RETURN_FLOAT8(result);
 }
 
 /*
  *		nlikesel		- Selectivity of LIKE pattern non-match.
  */
-float64
-nlikesel(Oid opid,
-		 Oid relid,
-		 AttrNumber attno,
-		 Datum value,
-		 int32 flag)
+Datum
+nlikesel(PG_FUNCTION_ARGS)
 {
-	float64		result;
+	float8		result;
 
-	result = patternsel(opid, Pattern_Type_Like, relid, attno, value, flag);
-	*result = 1.0 - *result;
-	return result;
+	result = DatumGetFloat8(patternsel(fcinfo, Pattern_Type_Like));
+	result = 1.0 - result;
+	PG_RETURN_FLOAT8(result);
 }
 
 /*
  *		eqjoinsel		- Join selectivity of "="
  */
-float64
-eqjoinsel(Oid opid,
-		  Oid relid1,
-		  AttrNumber attno1,
-		  Oid relid2,
-		  AttrNumber attno2)
+Datum
+eqjoinsel(PG_FUNCTION_ARGS)
 {
-	float64		result;
-	float64data num1,
+#ifdef NOT_USED
+	Oid			opid = PG_GETARG_OID(0);
+#endif
+	Oid			relid1 = PG_GETARG_OID(1);
+	AttrNumber	attno1 = PG_GETARG_INT16(2);
+	Oid			relid2 = PG_GETARG_OID(3);
+	AttrNumber	attno2 = PG_GETARG_INT16(4);
+	float8		result;
+	float8		num1,
 				num2,
 				min;
 	bool		unknown1 = NONVALUE(relid1) || NONVALUE(attno1);
 	bool		unknown2 = NONVALUE(relid2) || NONVALUE(attno2);
 
-	result = (float64) palloc(sizeof(float64data));
 	if (unknown1 && unknown2)
-		*result = DEFAULT_EQ_SEL;
+		result = DEFAULT_EQ_SEL;
 	else
 	{
 		num1 = unknown1 ? 1.0 : get_attdisbursion(relid1, attno1, 0.01);
@@ -637,162 +606,106 @@ eqjoinsel(Oid opid,
 		 * about applying the operator to the most common values?
 		 */
 		min = (num1 < num2) ? num1 : num2;
-		*result = min;
+		result = min;
 	}
-	return result;
+	PG_RETURN_FLOAT8(result);
 }
 
 /*
  *		neqjoinsel		- Join selectivity of "!="
  */
-float64
-neqjoinsel(Oid opid,
-		   Oid relid1,
-		   AttrNumber attno1,
-		   Oid relid2,
-		   AttrNumber attno2)
+Datum
+neqjoinsel(PG_FUNCTION_ARGS)
 {
-	float64		result;
+	float8		result;
 
-	result = eqjoinsel(opid, relid1, attno1, relid2, attno2);
-	*result = 1.0 - *result;
-	return result;
+	result = DatumGetFloat8(eqjoinsel(fcinfo));
+	result = 1.0 - result;
+	PG_RETURN_FLOAT8(result);
 }
 
 /*
  *		scalarltjoinsel - Join selectivity of "<" and "<=" for scalars
  */
-float64
-scalarltjoinsel(Oid opid,
-				Oid relid1,
-				AttrNumber attno1,
-				Oid relid2,
-				AttrNumber attno2)
+Datum
+scalarltjoinsel(PG_FUNCTION_ARGS)
 {
-	float64		result;
-
-	result = (float64) palloc(sizeof(float64data));
-	*result = DEFAULT_INEQ_SEL;
-	return result;
+	PG_RETURN_FLOAT8(DEFAULT_INEQ_SEL);
 }
 
 /*
  *		scalargtjoinsel - Join selectivity of ">" and ">=" for scalars
  */
-float64
-scalargtjoinsel(Oid opid,
-				Oid relid1,
-				AttrNumber attno1,
-				Oid relid2,
-				AttrNumber attno2)
+Datum
+scalargtjoinsel(PG_FUNCTION_ARGS)
 {
-	float64		result;
-
-	result = (float64) palloc(sizeof(float64data));
-	*result = DEFAULT_INEQ_SEL;
-	return result;
+	PG_RETURN_FLOAT8(DEFAULT_INEQ_SEL);
 }
 
 /*
  *		regexeqjoinsel	- Join selectivity of regular-expression pattern match.
  */
-float64
-regexeqjoinsel(Oid opid,
-			   Oid relid1,
-			   AttrNumber attno1,
-			   Oid relid2,
-			   AttrNumber attno2)
+Datum
+regexeqjoinsel(PG_FUNCTION_ARGS)
 {
-	float64		result;
-
-	result = (float64) palloc(sizeof(float64data));
-	*result = DEFAULT_MATCH_SEL;
-	return result;
+	PG_RETURN_FLOAT8(DEFAULT_MATCH_SEL);
 }
 
 /*
  *		icregexeqjoinsel	- Join selectivity of case-insensitive regex match.
  */
-float64
-icregexeqjoinsel(Oid opid,
-				 Oid relid1,
-				 AttrNumber attno1,
-				 Oid relid2,
-				 AttrNumber attno2)
+Datum
+icregexeqjoinsel(PG_FUNCTION_ARGS)
 {
-	float64		result;
-
-	result = (float64) palloc(sizeof(float64data));
-	*result = DEFAULT_MATCH_SEL;
-	return result;
+	PG_RETURN_FLOAT8(DEFAULT_MATCH_SEL);
 }
 
 /*
  *		likejoinsel			- Join selectivity of LIKE pattern match.
  */
-float64
-likejoinsel(Oid opid,
-			Oid relid1,
-			AttrNumber attno1,
-			Oid relid2,
-			AttrNumber attno2)
+Datum
+likejoinsel(PG_FUNCTION_ARGS)
 {
-	float64		result;
-
-	result = (float64) palloc(sizeof(float64data));
-	*result = DEFAULT_MATCH_SEL;
-	return result;
+	PG_RETURN_FLOAT8(DEFAULT_MATCH_SEL);
 }
 
 /*
  *		regexnejoinsel	- Join selectivity of regex non-match.
  */
-float64
-regexnejoinsel(Oid opid,
-			   Oid relid1,
-			   AttrNumber attno1,
-			   Oid relid2,
-			   AttrNumber attno2)
+Datum
+regexnejoinsel(PG_FUNCTION_ARGS)
 {
-	float64		result;
+	float8		result;
 
-	result = regexeqjoinsel(opid, relid1, attno1, relid2, attno2);
-	*result = 1.0 - *result;
-	return result;
+	result = DatumGetFloat8(regexeqjoinsel(fcinfo));
+	result = 1.0 - result;
+	PG_RETURN_FLOAT8(result);
 }
 
 /*
  *		icregexnejoinsel	- Join selectivity of case-insensitive regex non-match.
  */
-float64
-icregexnejoinsel(Oid opid,
-				 Oid relid1,
-				 AttrNumber attno1,
-				 Oid relid2,
-				 AttrNumber attno2)
+Datum
+icregexnejoinsel(PG_FUNCTION_ARGS)
 {
-	float64		result;
+	float8		result;
 
-	result = icregexeqjoinsel(opid, relid1, attno1, relid2, attno2);
-	*result = 1.0 - *result;
-	return result;
+	result = DatumGetFloat8(icregexeqjoinsel(fcinfo));
+	result = 1.0 - result;
+	PG_RETURN_FLOAT8(result);
 }
 
 /*
  *		nlikejoinsel		- Join selectivity of LIKE pattern non-match.
  */
-float64
-nlikejoinsel(Oid opid,
-			 Oid relid1,
-			 AttrNumber attno1,
-			 Oid relid2,
-			 AttrNumber attno2)
+Datum
+nlikejoinsel(PG_FUNCTION_ARGS)
 {
-	float64		result;
+	float8		result;
 
-	result = likejoinsel(opid, relid1, attno1, relid2, attno2);
-	*result = 1.0 - *result;
-	return result;
+	result = DatumGetFloat8(likejoinsel(fcinfo));
+	result = 1.0 - result;
+	PG_RETURN_FLOAT8(result);
 }
 
 
@@ -1563,8 +1476,12 @@ prefix_selectivity(char *prefix,
 			 datatype);
 	prefixcon = string_to_datum(prefix, datatype);
 	/* Assume scalargtsel is appropriate for all supported types */
-	prefixsel = * scalargtsel(cmpopr, relid, attno,
-							  prefixcon, SEL_CONSTANT|SEL_RIGHT);
+	prefixsel = DatumGetFloat8(DirectFunctionCall5(scalargtsel,
+							   ObjectIdGetDatum(cmpopr),
+							   ObjectIdGetDatum(relid),
+							   Int16GetDatum(attno),
+							   prefixcon,
+							   Int32GetDatum(SEL_CONSTANT|SEL_RIGHT)));
 	pfree(DatumGetPointer(prefixcon));
 
 	/*
@@ -1582,8 +1499,12 @@ prefix_selectivity(char *prefix,
 				 datatype);
 		prefixcon = string_to_datum(greaterstr, datatype);
 		/* Assume scalarltsel is appropriate for all supported types */
-		topsel = * scalarltsel(cmpopr, relid, attno,
-							   prefixcon, SEL_CONSTANT|SEL_RIGHT);
+		topsel = DatumGetFloat8(DirectFunctionCall5(scalarltsel,
+								ObjectIdGetDatum(cmpopr),
+								ObjectIdGetDatum(relid),
+								Int16GetDatum(attno),
+								prefixcon,
+								Int32GetDatum(SEL_CONSTANT|SEL_RIGHT)));
 		pfree(DatumGetPointer(prefixcon));
 		pfree(greaterstr);
 
@@ -1966,13 +1887,16 @@ string_to_datum(const char *str, Oid datatype)
  *-------------------------------------------------------------------------
  */
 
-static void
-genericcostestimate(Query *root, RelOptInfo *rel,
-					IndexOptInfo *index, List *indexQuals,
-					Cost *indexStartupCost,
-					Cost *indexTotalCost,
-					Selectivity *indexSelectivity)
+static Datum
+genericcostestimate(PG_FUNCTION_ARGS)
 {
+	Query	   *root = (Query *) PG_GETARG_POINTER(0);
+	RelOptInfo *rel = (RelOptInfo *) PG_GETARG_POINTER(1);
+	IndexOptInfo *index = (IndexOptInfo *) PG_GETARG_POINTER(2);
+	List	   *indexQuals = (List *) PG_GETARG_POINTER(3);
+	Cost	   *indexStartupCost = (Cost *) PG_GETARG_POINTER(4);
+	Cost	   *indexTotalCost = (Cost *) PG_GETARG_POINTER(5);
+	Selectivity *indexSelectivity = (Selectivity *) PG_GETARG_POINTER(6);
 	double		numIndexTuples;
 	double		numIndexPages;
 
@@ -2007,52 +1931,35 @@ genericcostestimate(Query *root, RelOptInfo *rel,
 	*indexStartupCost = 0;
 	*indexTotalCost = numIndexPages +
 		(cpu_index_tuple_cost + cost_qual_eval(indexQuals)) * numIndexTuples;
+
+	/* No real return value ... */
+	PG_RETURN_POINTER(NULL);
 }
 
 /*
  * For first cut, just use generic function for all index types.
  */
 
-void
-btcostestimate(Query *root, RelOptInfo *rel,
-			   IndexOptInfo *index, List *indexQuals,
-			   Cost *indexStartupCost,
-			   Cost *indexTotalCost,
-			   Selectivity *indexSelectivity)
+Datum
+btcostestimate(PG_FUNCTION_ARGS)
 {
-	genericcostestimate(root, rel, index, indexQuals,
-					 indexStartupCost, indexTotalCost, indexSelectivity);
+	return genericcostestimate(fcinfo);
 }
 
-void
-rtcostestimate(Query *root, RelOptInfo *rel,
-			   IndexOptInfo *index, List *indexQuals,
-			   Cost *indexStartupCost,
-			   Cost *indexTotalCost,
-			   Selectivity *indexSelectivity)
+Datum
+rtcostestimate(PG_FUNCTION_ARGS)
 {
-	genericcostestimate(root, rel, index, indexQuals,
-					 indexStartupCost, indexTotalCost, indexSelectivity);
+	return genericcostestimate(fcinfo);
 }
 
-void
-hashcostestimate(Query *root, RelOptInfo *rel,
-				 IndexOptInfo *index, List *indexQuals,
-				 Cost *indexStartupCost,
-				 Cost *indexTotalCost,
-				 Selectivity *indexSelectivity)
+Datum
+hashcostestimate(PG_FUNCTION_ARGS)
 {
-	genericcostestimate(root, rel, index, indexQuals,
-					 indexStartupCost, indexTotalCost, indexSelectivity);
+	return genericcostestimate(fcinfo);
 }
 
-void
-gistcostestimate(Query *root, RelOptInfo *rel,
-				 IndexOptInfo *index, List *indexQuals,
-				 Cost *indexStartupCost,
-				 Cost *indexTotalCost,
-				 Selectivity *indexSelectivity)
+Datum
+gistcostestimate(PG_FUNCTION_ARGS)
 {
-	genericcostestimate(root, rel, index, indexQuals,
-					 indexStartupCost, indexTotalCost, indexSelectivity);
+	return genericcostestimate(fcinfo);
 }
diff --git a/src/backend/utils/adt/varchar.c b/src/backend/utils/adt/varchar.c
index f98de78878..781d6591b3 100644
--- a/src/backend/utils/adt/varchar.c
+++ b/src/backend/utils/adt/varchar.c
@@ -1,19 +1,20 @@
 /*-------------------------------------------------------------------------
  *
  * varchar.c
- *	  Functions for the built-in type char() and varchar().
+ *	  Functions for the built-in types char(n) and varchar(n).
  *
  * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/varchar.c,v 1.62 2000/05/30 00:49:53 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/varchar.c,v 1.63 2000/06/05 07:28:52 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
 
 #include "postgres.h"
+
 #include "catalog/pg_type.h"
 #include "utils/builtins.h"
 #include "utils/fmgroids.h"
@@ -22,9 +23,10 @@
 #include "mb/pg_wchar.h"
 #endif
 
-#ifdef CYR_RECODE
-char	   *convertstr(char *, int, int);
 
+#ifdef CYR_RECODE
+/* XXX no points for style --- this is actually in utils/init/miscinit.c */
+extern char *convertstr(char *, int, int);
 #endif
 
 
@@ -34,7 +36,7 @@ char	   *convertstr(char *, int, int);
  * VARCHAR is for storing string whose length is at most the length specified
  * at CREATE TABLE time.
  *
- * It's hard to implement these types because we cannot figure out what
+ * It's hard to implement these types because we cannot figure out
  * the length of the type from the type itself. I change (hopefully all) the
  * fmgr calls that invoke input functions of a data type to supply the
  * length also. (eg. in INSERTs, we have the tupleDescriptor which contains
@@ -44,8 +46,9 @@ char	   *convertstr(char *, int, int);
  * must be null-terminated.
  *
  * We actually implement this as a varlena so that we don't have to pass in
- * the length for the comparison functions. (The difference between "text"
- * is that we truncate and possibly blank-pad the string at insertion time.)
+ * the length for the comparison functions. (The difference between these
+ * types and "text" is that we truncate and possibly blank-pad the string
+ * at insertion time.)
  *
  *															  - ay 6/95
  */
@@ -231,28 +234,33 @@ _bpchar(ArrayType *v, int32 len)
 
 /* bpchar_char()
  * Convert bpchar(1) to char.
+ *
+ * If input is multiple chars, only the first is returned.
  */
-int32
-bpchar_char(char *s)
+Datum
+bpchar_char(PG_FUNCTION_ARGS)
 {
-	return (int32) *VARDATA(s);
-}	/* bpchar_char() */
+	struct varlena *s = PG_GETARG_BPCHAR_P(0);
+
+	PG_RETURN_CHAR(*VARDATA(s));
+}
 
 /* char_bpchar()
  * Convert char to bpchar(1).
  */
-char *
-char_bpchar(int32 c)
+Datum
+char_bpchar(PG_FUNCTION_ARGS)
 {
-	char	   *result;
+	char		c = PG_GETARG_CHAR(0);
+	struct varlena *result;
 
-	result = palloc(VARHDRSZ + 1);
+	result = (struct varlena *) palloc(VARHDRSZ + 1);
 
 	VARSIZE(result) = VARHDRSZ + 1;
-	*(VARDATA(result)) = (char) c;
+	*(VARDATA(result)) = c;
 
-	return result;
-}	/* char_bpchar() */
+	PG_RETURN_BPCHAR_P(result);
+}
 
 
 /* bpchar_name()
diff --git a/src/backend/utils/cache/catcache.c b/src/backend/utils/cache/catcache.c
index e5fb546ca7..428110aa36 100644
--- a/src/backend/utils/cache/catcache.c
+++ b/src/backend/utils/cache/catcache.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/cache/catcache.c,v 1.64 2000/05/28 17:56:06 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/cache/catcache.c,v 1.65 2000/06/05 07:28:53 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -35,7 +35,7 @@ static Index CatalogCacheComputeTupleHashIndex(struct catcache * cacheInOutP,
 								  HeapTuple tuple);
 static void CatalogCacheInitializeCache(struct catcache * cache,
 							Relation relation);
-static uint32 cc_hashname(NameData *n);
+static Datum cc_hashname(PG_FUNCTION_ARGS);
 
 /* ----------------
  *		variables, macros and other stuff
@@ -87,38 +87,38 @@ static const Oid eqproc[] = {
  * ----------------------------------------------------------------
  */
 
-static CCHashFunc
+static PGFunction
 GetCCHashFunc(Oid keytype)
 {
 	switch (keytype)
 	{
-			case BOOLOID:
-			case CHAROID:
-			return (CCHashFunc) hashchar;
+		case BOOLOID:
+		case CHAROID:
+			return hashchar;
 		case NAMEOID:
-			return (CCHashFunc) cc_hashname;
+			return cc_hashname;
 		case INT2OID:
-			return (CCHashFunc) hashint2;
+			return hashint2;
 		case INT2VECTOROID:
-			return (CCHashFunc) hashint2vector;
+			return hashint2vector;
 		case INT4OID:
-			return (CCHashFunc) hashint4;
+			return hashint4;
 		case TEXTOID:
-			return (CCHashFunc) hashtext;
+			return hashtext;
 		case REGPROCOID:
 		case OIDOID:
-			return (CCHashFunc) hashoid;
+			return hashoid;
 		case OIDVECTOROID:
-			return (CCHashFunc) hashoidvector;
+			return hashoidvector;
 		default:
 			elog(FATAL, "GetCCHashFunc: type %u unsupported as catcache key",
 				 keytype);
-			return NULL;
+			return (PGFunction) NULL;
 	}
 }
 
-static uint32
-cc_hashname(NameData *n)
+static Datum
+cc_hashname(PG_FUNCTION_ARGS)
 {
 
 	/*
@@ -129,9 +129,9 @@ cc_hashname(NameData *n)
 	 */
 	NameData	my_n;
 
-	namestrcpy(&my_n, NameStr(*n));
+	namestrcpy(&my_n, NameStr(* PG_GETARG_NAME(0)));
 
-	return hashname(&my_n);
+	return DirectFunctionCall1(hashname, NameGetDatum(&my_n));
 }
 
 
@@ -320,19 +320,23 @@ CatalogCacheComputeHashIndex(struct catcache * cacheInP)
 	{
 		case 4:
 			hashIndex ^=
-				(*cacheInP->cc_hashfunc[3]) (cacheInP->cc_skey[3].sk_argument) << 9;
+				DatumGetUInt32(DirectFunctionCall1(cacheInP->cc_hashfunc[3],
+							   cacheInP->cc_skey[3].sk_argument)) << 9;
 			/* FALLTHROUGH */
 		case 3:
 			hashIndex ^=
-				(*cacheInP->cc_hashfunc[2]) (cacheInP->cc_skey[2].sk_argument) << 6;
+				DatumGetUInt32(DirectFunctionCall1(cacheInP->cc_hashfunc[2],
+							   cacheInP->cc_skey[2].sk_argument)) << 6;
 			/* FALLTHROUGH */
 		case 2:
 			hashIndex ^=
-				(*cacheInP->cc_hashfunc[1]) (cacheInP->cc_skey[1].sk_argument) << 3;
+				DatumGetUInt32(DirectFunctionCall1(cacheInP->cc_hashfunc[1],
+							   cacheInP->cc_skey[1].sk_argument)) << 3;
 			/* FALLTHROUGH */
 		case 1:
 			hashIndex ^=
-				(*cacheInP->cc_hashfunc[0]) (cacheInP->cc_skey[0].sk_argument);
+				DatumGetUInt32(DirectFunctionCall1(cacheInP->cc_hashfunc[0],
+							   cacheInP->cc_skey[0].sk_argument));
 			break;
 		default:
 			elog(FATAL, "CCComputeHashIndex: %d cc_nkeys", cacheInP->cc_nkeys);
diff --git a/src/backend/utils/fmgr/fmgr.c b/src/backend/utils/fmgr/fmgr.c
index 713d714bb7..489d8c260f 100644
--- a/src/backend/utils/fmgr/fmgr.c
+++ b/src/backend/utils/fmgr/fmgr.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/fmgr/fmgr.c,v 1.42 2000/05/30 04:24:53 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/fmgr/fmgr.c,v 1.43 2000/06/05 07:28:55 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -21,6 +21,27 @@
 #include "utils/fmgrtab.h"
 #include "utils/syscache.h"
 
+/*
+ * Declaration for old-style function pointer type.  This is now used only
+ * in fmgr_oldstyle() and is no longer exported.
+ *
+ * The m68k SVR4 ABI defines that pointers are returned in %a0 instead of
+ * %d0. So if a function pointer is declared to return a pointer, the
+ * compiler may look only into %a0, but if the called function was declared
+ * to return an integer type, it puts its value only into %d0. So the
+ * caller doesn't pink up the correct return value. The solution is to
+ * declare the function pointer to return int, so the compiler picks up the
+ * return value from %d0. (Functions returning pointers put their value
+ * *additionally* into %d0 for compatibility.) The price is that there are
+ * some warnings about int->pointer conversions...
+ */
+#if defined(__mc68000__) && defined(__ELF__)
+typedef int32 ((*func_ptr) ());
+#else
+typedef char *((*func_ptr) ());
+#endif
+
+
 static Datum fmgr_oldstyle(PG_FUNCTION_ARGS);
 static Datum fmgr_untrusted(PG_FUNCTION_ARGS);
 static Datum fmgr_sql(PG_FUNCTION_ARGS);
@@ -377,7 +398,7 @@ fmgr_oldstyle(PG_FUNCTION_ARGS)
 		default:
 			/*
 			 * Increasing FUNC_MAX_ARGS doesn't automatically add cases
-			 * to the above code, so give the actual value in this error
+			 * to the above code, so mention the actual value in this error
 			 * not FUNC_MAX_ARGS.  You could add cases to the above if you
 			 * needed to support old-style functions with many arguments,
 			 * but making 'em be new-style is probably a better idea.
@@ -420,100 +441,6 @@ fmgr_sql(PG_FUNCTION_ARGS)
 	return 0;					/* keep compiler happy */
 }
 
-#if 0
-
-/*
- * Interface routine for functions using fmgr_faddr
- */
-FmgrInfo        *fmgr_pl_finfo;	/* should GO AWAY */
-
-char *
-fmgr_faddr_link(char *arg0, ...)
-{
-	FunctionCallInfoData	fcinfo;
-	int						n_arguments;
-	Datum					result;
-
-	MemSet(&fcinfo, 0, sizeof(fcinfo));
-	/* We rely on fmgr_faddr macro to have set back-link to FmgrInfo (ugh) */
-    fcinfo.flinfo = fmgr_pl_finfo;
-	fcinfo.nargs = fcinfo.flinfo->fn_nargs;
-	n_arguments = fcinfo.nargs;
-
-	if (n_arguments > 0)
-	{
-		fcinfo.arg[0] = (Datum) arg0;
-		if (n_arguments > 1)
-		{
-			va_list		pvar;
-			int			i;
-
-			if (n_arguments > FUNC_MAX_ARGS)
-				elog(ERROR, "fmgr_faddr_link: function %u: too many arguments (%d > %d)",
-					 fcinfo.flinfo->fn_oid, n_arguments, FUNC_MAX_ARGS);
-			va_start(pvar, arg0);
-			for (i = 1; i < n_arguments; i++)
-				fcinfo.arg[i] = (Datum) va_arg(pvar, char *);
-			va_end(pvar);
-		}
-	}
-
-	result = FunctionCallInvoke(&fcinfo);
-
-	/* Check for null result, since caller is clearly not expecting one */
-	if (fcinfo.isnull)
-		elog(ERROR, "fmgr_faddr_link: function %u returned NULL",
-			 fcinfo.flinfo->fn_oid);
-
-	return (char *) result;
-}
-
-/*
- *		fmgr			- return the value of a function call
- *
- * This is essentially fmgr_info plus call the function.
- */
-char *
-fmgr(Oid procedureId,...)
-{
-	FmgrInfo				flinfo;
-	FunctionCallInfoData	fcinfo;
-	int						n_arguments;
-	Datum					result;
-
-	fmgr_info(procedureId, &flinfo);
-
-	MemSet(&fcinfo, 0, sizeof(fcinfo));
-    fcinfo.flinfo = &flinfo;
-	fcinfo.nargs = flinfo.fn_nargs;
-	n_arguments = fcinfo.nargs;
-
-	if (n_arguments > 0)
-	{
-		va_list		pvar;
-		int			i;
-
-		if (n_arguments > FUNC_MAX_ARGS)
-			elog(ERROR, "fmgr: function %u: too many arguments (%d > %d)",
-				 flinfo.fn_oid, n_arguments, FUNC_MAX_ARGS);
-		va_start(pvar, procedureId);
-		for (i = 0; i < n_arguments; i++)
-			fcinfo.arg[i] = (Datum) va_arg(pvar, char *);
-		va_end(pvar);
-	}
-
-	result = FunctionCallInvoke(&fcinfo);
-
-	/* Check for null result, since caller is clearly not expecting one */
-	if (fcinfo.isnull)
-		elog(ERROR, "fmgr: function %u returned NULL",
-			 flinfo.fn_oid);
-
-	return (char *) result;
-}
-
-#endif
-
 
 /*-------------------------------------------------------------------------
  *		Support routines for callers of fmgr-compatible functions
@@ -1267,6 +1194,57 @@ OidFunctionCall9(Oid functionId, Datum arg1, Datum arg2,
 }
 
 
+/*
+ * !!! OLD INTERFACE !!!
+ *
+ * fmgr() is the only remaining vestige of the old-style caller support
+ * functions.  It's no longer used anywhere in the Postgres distribution,
+ * but we should leave it around for a release or two to ease the transition
+ * for user-supplied C functions.  OidFunctionCallN() replaces it for new
+ * code.
+ *
+ * DEPRECATED, DO NOT USE IN NEW CODE
+ */
+char *
+fmgr(Oid procedureId,...)
+{
+	FmgrInfo				flinfo;
+	FunctionCallInfoData	fcinfo;
+	int						n_arguments;
+	Datum					result;
+
+	fmgr_info(procedureId, &flinfo);
+
+	MemSet(&fcinfo, 0, sizeof(fcinfo));
+    fcinfo.flinfo = &flinfo;
+	fcinfo.nargs = flinfo.fn_nargs;
+	n_arguments = fcinfo.nargs;
+
+	if (n_arguments > 0)
+	{
+		va_list		pvar;
+		int			i;
+
+		if (n_arguments > FUNC_MAX_ARGS)
+			elog(ERROR, "fmgr: function %u: too many arguments (%d > %d)",
+				 flinfo.fn_oid, n_arguments, FUNC_MAX_ARGS);
+		va_start(pvar, procedureId);
+		for (i = 0; i < n_arguments; i++)
+			fcinfo.arg[i] = (Datum) va_arg(pvar, char *);
+		va_end(pvar);
+	}
+
+	result = FunctionCallInvoke(&fcinfo);
+
+	/* Check for null result, since caller is clearly not expecting one */
+	if (fcinfo.isnull)
+		elog(ERROR, "fmgr: function %u returned NULL",
+			 flinfo.fn_oid);
+
+	return (char *) result;
+}
+
+
 /*-------------------------------------------------------------------------
  *		Support routines for standard pass-by-reference datatypes
  *
diff --git a/src/include/access/hash.h b/src/include/access/hash.h
index 7b9445ec69..06c0fda959 100644
--- a/src/include/access/hash.h
+++ b/src/include/access/hash.h
@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: hash.h,v 1.31 2000/02/21 03:36:51 tgl Exp $
+ * $Id: hash.h,v 1.32 2000/06/05 07:28:57 tgl Exp $
  *
  * NOTES
  *		modeled after Margo Seltzer's hash implementation for unix.
@@ -21,7 +21,7 @@
 #include "access/itup.h"
 #include "access/relscan.h"
 #include "access/sdir.h"
-#include "utils/int8.h"
+#include "fmgr.h"
 
 /*
  * An overflow page is a spare page allocated for storing data whose
@@ -262,18 +262,24 @@ extern void hashmarkpos(IndexScanDesc scan);
 extern void hashrestrpos(IndexScanDesc scan);
 extern void hashdelete(Relation rel, ItemPointer tid);
 
-/* hashfunc.c */
-extern uint32 hashint2(int16 key);
-extern uint32 hashint4(uint32 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 hashtext(struct varlena * key);
-extern uint32 hashname(NameData *n);
+/*
+ * Datatype-specific hash functions in hashfunc.c.
+ *
+ * NOTE: some of these are also used by catcache operations, without
+ * any direct connection to hash indexes.
+ */
+extern Datum hashint2(PG_FUNCTION_ARGS);
+extern Datum hashint4(PG_FUNCTION_ARGS);
+extern Datum hashint8(PG_FUNCTION_ARGS);
+extern Datum hashfloat4(PG_FUNCTION_ARGS);
+extern Datum hashfloat8(PG_FUNCTION_ARGS);
+extern Datum hashoid(PG_FUNCTION_ARGS);
+extern Datum hashoidvector(PG_FUNCTION_ARGS);
+extern Datum hashint2vector(PG_FUNCTION_ARGS);
+extern Datum hashchar(PG_FUNCTION_ARGS);
+extern Datum hashtext(PG_FUNCTION_ARGS);
+extern Datum hashname(PG_FUNCTION_ARGS);
+
 
 /* private routines */
 
diff --git a/src/include/access/xact.h b/src/include/access/xact.h
index 89a478ea0e..787b4402d2 100644
--- a/src/include/access/xact.h
+++ b/src/include/access/xact.h
@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: xact.h,v 1.24 2000/01/26 05:57:51 momjian Exp $
+ * $Id: xact.h,v 1.25 2000/06/05 07:28:57 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -115,9 +115,9 @@ extern void AbortOutOfAnyTransaction(void);
 extern TransactionId DisabledTransactionId;
 
 /* defined in xid.c */
-extern TransactionId xidin(char *representation);
-extern char *xidout(TransactionId transactionId);
-extern bool xideq(TransactionId xid1, TransactionId xid2);
+extern Datum xidin(PG_FUNCTION_ARGS);
+extern Datum xidout(PG_FUNCTION_ARGS);
+extern Datum xideq(PG_FUNCTION_ARGS);
 extern void TransactionIdAdd(TransactionId *xid, int value);
 
 #endif	 /* XACT_H */
diff --git a/src/include/catalog/catversion.h b/src/include/catalog/catversion.h
index 74b712dca9..c1d6747467 100644
--- a/src/include/catalog/catversion.h
+++ b/src/include/catalog/catversion.h
@@ -37,7 +37,7 @@
  * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: catversion.h,v 1.23 2000/05/29 01:59:10 tgl Exp $
+ * $Id: catversion.h,v 1.24 2000/06/05 07:28:58 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -53,6 +53,6 @@
  */
 
 /*							yyyymmddN */
-#define CATALOG_VERSION_NO	200005282
+#define CATALOG_VERSION_NO	200006021
 
 #endif
diff --git a/src/include/catalog/pg_operator.h b/src/include/catalog/pg_operator.h
index 538d009525..06bb7546cd 100644
--- a/src/include/catalog/pg_operator.h
+++ b/src/include/catalog/pg_operator.h
@@ -8,7 +8,7 @@
  * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: pg_operator.h,v 1.75 2000/04/12 17:16:29 momjian Exp $
+ * $Id: pg_operator.h,v 1.76 2000/06/05 07:28:59 tgl Exp $
  *
  * NOTES
  *	  the genbki.sh script reads this file and generates .bki
@@ -711,17 +711,17 @@ DATA(insert OID = 1763 (  "@"	   PGUID 0 l t f	0 1700 1700    0	0 0 0 numeric_ab
 /* LZTEXT type */
 DATA(insert OID = 1657 (  "="	 PGUID 0 b t f 1625 1625   16 1657 1658 1659 1659 lztext_eq eqsel eqjoinsel ));
 DATA(insert OID = 1658 (  "<>"		 PGUID 0 b t f 1625 1625   16 1658 1657 0 0 lztext_ne neqsel neqjoinsel ));
-DATA(insert OID = 1659 (  "<"	 PGUID 0 b t f 1625 1625   16 1661 1662 0 0 lztext_lt intltsel intltjoinsel ));
-DATA(insert OID = 1660 (  "<="		 PGUID 0 b t f 1625 1625   16 1662 1661 0 0 lztext_le intltsel intltjoinsel ));
-DATA(insert OID = 1661 (  ">"	 PGUID 0 b t f 1625 1625   16 1659 1660 0 0 lztext_gt intgtsel intgtjoinsel ));
-DATA(insert OID = 1662 (  ">="		 PGUID 0 b t f 1625 1625   16 1660 1659 0 0 lztext_ge intgtsel intgtjoinsel ));
+DATA(insert OID = 1659 (  "<"	 PGUID 0 b t f 1625 1625   16 1661 1662 0 0 lztext_lt scalarltsel scalarltjoinsel ));
+DATA(insert OID = 1660 (  "<="		 PGUID 0 b t f 1625 1625   16 1662 1661 0 0 lztext_le scalarltsel scalarltjoinsel ));
+DATA(insert OID = 1661 (  ">"	 PGUID 0 b t f 1625 1625   16 1659 1660 0 0 lztext_gt scalargtsel scalargtjoinsel ));
+DATA(insert OID = 1662 (  ">="		 PGUID 0 b t f 1625 1625   16 1660 1659 0 0 lztext_ge scalargtsel scalargtjoinsel ));
 
 DATA(insert OID = 1784 (  "="	  PGUID 0 b t f 1560 1560	16 1784 1785 1786 1786 biteq eqsel eqjoinsel ));
 DATA(insert OID = 1785 (  "<>"	  PGUID 0 b t f 1560 1560	16 1785 1784	0	 0 bitne neqsel neqjoinsel ));
-DATA(insert OID = 1786 (  "<"	  PGUID 0 b t f 1560 1560	16 1787 1789	0	 0 bitlt intltsel intltjoinsel ));
-DATA(insert OID = 1787 (  ">"	  PGUID 0 b t f 1560 1560	16 1786 1788	0	 0 bitgt intgtsel intgtjoinsel ));
-DATA(insert OID = 1788 (  "<="	  PGUID 0 b t f 1560 1560	16 1789 1787	0	 0 bitle intltsel intltjoinsel ));
-DATA(insert OID = 1789 (  ">="	  PGUID 0 b t f 1560 1560	16 1788 1786	0	 0 bitge intgtsel intgtjoinsel ));
+DATA(insert OID = 1786 (  "<"	  PGUID 0 b t f 1560 1560	16 1787 1789	0	 0 bitlt scalarltsel scalarltjoinsel ));
+DATA(insert OID = 1787 (  ">"	  PGUID 0 b t f 1560 1560	16 1786 1788	0	 0 bitgt scalargtsel scalargtjoinsel ));
+DATA(insert OID = 1788 (  "<="	  PGUID 0 b t f 1560 1560	16 1789 1787	0	 0 bitle scalarltsel scalarltjoinsel ));
+DATA(insert OID = 1789 (  ">="	  PGUID 0 b t f 1560 1560	16 1788 1786	0	 0 bitge scalargtsel scalargtjoinsel ));
 DATA(insert OID = 1790 (  "<=>"   PGUID 0 b t f 1560 1560	23	  0    0	0	 0 bitcmp - - ));
 DATA(insert OID = 1791 (  "&"	  PGUID 0 b t f 1560 1560 1560	  0    0	0	 0 bitand - - ));
 DATA(insert OID = 1792 (  "|"	  PGUID 0 b t f 1560 1560 1560	  0    0	0	 0 bitor - - ));
@@ -733,10 +733,10 @@ DATA(insert OID = 1797 (  "||"	  PGUID 0 b t f 1560 1560 1560	  0    0	0	 0 bitc
 
 DATA(insert OID = 1804 (  "="	  PGUID 0 b t f 1562 1562	16 1804 1805 1806 1806 varbiteq eqsel eqjoinsel ));
 DATA(insert OID = 1805 (  "<>"	  PGUID 0 b t f 1562 1562	16 1805 1804	0	 0 varbitne neqsel neqjoinsel ));
-DATA(insert OID = 1806 (  "<"	  PGUID 0 b t f 1562 1562	16 1807 1809	0	 0 varbitlt intltsel intltjoinsel ));
-DATA(insert OID = 1807 (  ">"	  PGUID 0 b t f 1562 1562	16 1806 1808	0	 0 varbitgt intgtsel intgtjoinsel ));
-DATA(insert OID = 1808 (  "<="	  PGUID 0 b t f 1562 1562	16 1809 1807	0	 0 varbitle intltsel intltjoinsel ));
-DATA(insert OID = 1809 (  ">="	  PGUID 0 b t f 1562 1562	16 1808 1806	0	 0 varbitge intgtsel intgtjoinsel ));
+DATA(insert OID = 1806 (  "<"	  PGUID 0 b t f 1562 1562	16 1807 1809	0	 0 varbitlt scalarltsel scalarltjoinsel ));
+DATA(insert OID = 1807 (  ">"	  PGUID 0 b t f 1562 1562	16 1806 1808	0	 0 varbitgt scalargtsel scalargtjoinsel ));
+DATA(insert OID = 1808 (  "<="	  PGUID 0 b t f 1562 1562	16 1809 1807	0	 0 varbitle scalarltsel scalarltjoinsel ));
+DATA(insert OID = 1809 (  ">="	  PGUID 0 b t f 1562 1562	16 1808 1806	0	 0 varbitge scalargtsel scalargtjoinsel ));
 DATA(insert OID = 1810 (  "<=>"   PGUID 0 b t f 1562 1562	23	  0    0	0	 0 varbitcmp - - ));
 DATA(insert OID = 1811 (  "&"	  PGUID 0 b t f 1562 1562 1562	  0    0	0	 0 varbitand - - ));
 DATA(insert OID = 1812 (  "|"	  PGUID 0 b t f 1562 1562 1562	  0    0	0	 0 varbitor - - ));
diff --git a/src/include/catalog/pg_proc.h b/src/include/catalog/pg_proc.h
index 76f52eef69..9d09aa8b7a 100644
--- a/src/include/catalog/pg_proc.h
+++ b/src/include/catalog/pg_proc.h
@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: pg_proc.h,v 1.135 2000/05/29 01:59:10 tgl Exp $
+ * $Id: pg_proc.h,v 1.136 2000/06/05 07:28:59 tgl Exp $
  *
  * NOTES
  *	  The script catalog/genbki.sh reads this file and generates .bki
@@ -97,37 +97,37 @@ typedef FormData_pg_proc *Form_pg_proc;
 
 /* OIDS 1 - 99 */
 
-DATA(insert OID = 1242 (  boolin		   PGUID 11 f t t t 1 f 16 "0" 100 0 0  100  boolin - ));
+DATA(insert OID = 1242 (  boolin		   PGUID 12 f t t t 1 f 16 "0" 100 0 0  100  boolin - ));
 DESCR("(internal)");
-DATA(insert OID = 1243 (  boolout		   PGUID 11 f t t t 1 f 23 "0" 100 0 0 100  boolout - ));
+DATA(insert OID = 1243 (  boolout		   PGUID 12 f t t t 1 f 23 "0" 100 0 0 100  boolout - ));
 DESCR("(internal)");
 DATA(insert OID = 1244 (  byteain		   PGUID 11 f t t t 1 f 17 "0" 100 0 0 100  byteain - ));
 DESCR("(internal)");
 DATA(insert OID =  31 (  byteaout		   PGUID 11 f t t t 1 f 23 "0" 100 0 0 100  byteaout - ));
 DESCR("(internal)");
-DATA(insert OID = 1245 (  charin		   PGUID 11 f t t t 1 f 18 "0" 100 0 0 100  charin - ));
+DATA(insert OID = 1245 (  charin		   PGUID 12 f t t t 1 f 18 "0" 100 0 0 100  charin - ));
 DESCR("(internal)");
-DATA(insert OID =  33 (  charout		   PGUID 11 f t t t 1 f 23 "0" 100 0 0 100  charout - ));
+DATA(insert OID =  33 (  charout		   PGUID 12 f t t t 1 f 23 "0" 100 0 0 100  charout - ));
 DESCR("(internal)");
 DATA(insert OID =  34 (  namein			   PGUID 11 f t t t 1 f 19 "0" 100 0 0 100  namein - ));
 DESCR("(internal)");
 DATA(insert OID =  35 (  nameout		   PGUID 11 f t t t 1 f 23 "0" 100 0 0 100  nameout - ));
 DESCR("(internal)");
-DATA(insert OID =  38 (  int2in			   PGUID 11 f t t t 1 f 21 "0" 100 0 0 100  int2in - ));
+DATA(insert OID =  38 (  int2in			   PGUID 12 f t t t 1 f 21 "0" 100 0 0 100  int2in - ));
 DESCR("(internal)");
-DATA(insert OID =  39 (  int2out		   PGUID 11 f t t t 1 f 23 "0" 100 0 0 100  int2out - ));
+DATA(insert OID =  39 (  int2out		   PGUID 12 f t t t 1 f 23 "0" 100 0 0 100  int2out - ));
 DESCR("(internal)");
-DATA(insert OID =  40 (  int2vectorin	   PGUID 11 f t t t 1 f 22 "0" 100 0 0 100  int2vectorin - ));
+DATA(insert OID =  40 (  int2vectorin	   PGUID 12 f t t t 1 f 22 "0" 100 0 0 100  int2vectorin - ));
 DESCR("(internal)");
-DATA(insert OID =  41 (  int2vectorout	   PGUID 11 f t t t 1 f 23 "0" 100 0 0 100  int2vectorout - ));
+DATA(insert OID =  41 (  int2vectorout	   PGUID 12 f t t t 1 f 23 "0" 100 0 0 100  int2vectorout - ));
 DESCR("(internal)");
-DATA(insert OID =  42 (  int4in			   PGUID 11 f t t t 1 f 23 "0" 100 0 0 100  int4in - ));
+DATA(insert OID =  42 (  int4in			   PGUID 12 f t t t 1 f 23 "0" 100 0 0 100  int4in - ));
 DESCR("(internal)");
-DATA(insert OID =  43 (  int4out		   PGUID 11 f t t t 1 f 19 "0" 100 0 0 100  int4out - ));
+DATA(insert OID =  43 (  int4out		   PGUID 12 f t t t 1 f 23 "0" 100 0 0 100  int4out - ));
 DESCR("(internal)");
-DATA(insert OID =  44 (  regprocin		   PGUID 11 f t f t 1 f 24 "0" 100 0 0 100  regprocin - ));
+DATA(insert OID =  44 (  regprocin		   PGUID 12 f t f t 1 f 24 "0" 100 0 0 100  regprocin - ));
 DESCR("(internal)");
-DATA(insert OID =  45 (  regprocout		   PGUID 11 f t f t 1 f 23 "0" 100 0 0 100  regprocout - ));
+DATA(insert OID =  45 (  regprocout		   PGUID 12 f t f t 1 f 23 "0" 100 0 0 100  regprocout - ));
 DESCR("(internal)");
 DATA(insert OID =  46 (  textin			   PGUID 11 f t t t 1 f 25 "0" 100 0 0 100  textin - ));
 DESCR("(internal)");
@@ -137,59 +137,59 @@ DATA(insert OID =  48 (  tidin			   PGUID 11 f t t t 1 f 27 "0" 100 0 0 100  tid
 DESCR("(internal)");
 DATA(insert OID =  49 (  tidout			   PGUID 11 f t t t 1 f 23 "0" 100 0 0 100  tidout - ));
 DESCR("(internal)");
-DATA(insert OID =  50 (  xidin			   PGUID 11 f t t t 1 f 28 "0" 100 0 0 100  xidin - ));
+DATA(insert OID =  50 (  xidin			   PGUID 12 f t t t 1 f 28 "0" 100 0 0 100  xidin - ));
 DESCR("(internal)");
-DATA(insert OID =  51 (  xidout			   PGUID 11 f t t t 1 f 23 "0" 100 0 0 100  xidout - ));
+DATA(insert OID =  51 (  xidout			   PGUID 12 f t t t 1 f 23 "0" 100 0 0 100  xidout - ));
 DESCR("(internal)");
-DATA(insert OID =  52 (  cidin			   PGUID 11 f t t t 1 f 29 "0" 100 0 0 100  cidin - ));
+DATA(insert OID =  52 (  cidin			   PGUID 12 f t t t 1 f 29 "0" 100 0 0 100  cidin - ));
 DESCR("(internal)");
-DATA(insert OID =  53 (  cidout			   PGUID 11 f t t t 1 f 23 "0" 100 0 0 100  cidout - ));
+DATA(insert OID =  53 (  cidout			   PGUID 12 f t t t 1 f 23 "0" 100 0 0 100  cidout - ));
 DESCR("(internal)");
-DATA(insert OID =  54 (  oidvectorin	   PGUID 11 f t t t 1 f 30 "0" 100 0 0 100  oidvectorin - ));
+DATA(insert OID =  54 (  oidvectorin	   PGUID 12 f t t t 1 f 30 "0" 100 0 0 100  oidvectorin - ));
 DESCR("(internal)");
-DATA(insert OID =  55 (  oidvectorout	   PGUID 11 f t t t 1 f 23 "0" 100 0 0 100  oidvectorout - ));
+DATA(insert OID =  55 (  oidvectorout	   PGUID 12 f t t t 1 f 23 "0" 100 0 0 100  oidvectorout - ));
 DESCR("(internal)");
-DATA(insert OID =  56 (  boollt			   PGUID 11 f t t t 2 f 16 "16 16" 100 0 0 100  boollt - ));
+DATA(insert OID =  56 (  boollt			   PGUID 12 f t t t 2 f 16 "16 16" 100 0 0 100  boollt - ));
 DESCR("less-than");
-DATA(insert OID =  57 (  boolgt			   PGUID 11 f t t t 2 f 16 "16 16" 100 0 0 100  boolgt - ));
+DATA(insert OID =  57 (  boolgt			   PGUID 12 f t t t 2 f 16 "16 16" 100 0 0 100  boolgt - ));
 DESCR("greater-than");
-DATA(insert OID =  60 (  booleq			   PGUID 11 f t t t 2 f 16 "16 16" 100 0 0 100  booleq - ));
+DATA(insert OID =  60 (  booleq			   PGUID 12 f t t t 2 f 16 "16 16" 100 0 0 100  booleq - ));
 DESCR("equal");
-DATA(insert OID =  61 (  chareq			   PGUID 11 f t t t 2 f 16 "18 18" 100 0 0 100  chareq - ));
+DATA(insert OID =  61 (  chareq			   PGUID 12 f t t t 2 f 16 "18 18" 100 0 0 100  chareq - ));
 DESCR("equal");
 DATA(insert OID =  62 (  nameeq			   PGUID 11 f t t t 2 f 16 "19 19" 100 0 0 100  nameeq - ));
 DESCR("equal");
-DATA(insert OID =  63 (  int2eq			   PGUID 11 f t t t 2 f 16 "21 21" 100 0 0 100  int2eq - ));
+DATA(insert OID =  63 (  int2eq			   PGUID 12 f t t t 2 f 16 "21 21" 100 0 0 100  int2eq - ));
 DESCR("equal");
-DATA(insert OID =  64 (  int2lt			   PGUID 11 f t t t 2 f 16 "21 21" 100 0 0 100  int2lt - ));
+DATA(insert OID =  64 (  int2lt			   PGUID 12 f t t t 2 f 16 "21 21" 100 0 0 100  int2lt - ));
 DESCR("less-than");
-DATA(insert OID =  65 (  int4eq			   PGUID 11 f t t t 2 f 16 "23 23" 100 0 0 100  int4eq - ));
+DATA(insert OID =  65 (  int4eq			   PGUID 12 f t t t 2 f 16 "23 23" 100 0 0 100  int4eq - ));
 DESCR("equal");
-DATA(insert OID =  66 (  int4lt			   PGUID 11 f t t t 2 f 16 "23 23" 100 0 0 100  int4lt - ));
+DATA(insert OID =  66 (  int4lt			   PGUID 12 f t t t 2 f 16 "23 23" 100 0 0 100  int4lt - ));
 DESCR("less-than");
 DATA(insert OID =  67 (  texteq			   PGUID 11 f t t t 2 f 16 "25 25" 100 0 0 0	texteq - ));
 DESCR("equal");
-DATA(insert OID =  68 (  xideq			   PGUID 11 f t t t 2 f 16 "28 28" 100 0 0 100  xideq - ));
+DATA(insert OID =  68 (  xideq			   PGUID 12 f t t t 2 f 16 "28 28" 100 0 0 100  xideq - ));
 DESCR("equal");
-DATA(insert OID =  69 (  cideq			   PGUID 11 f t t t 2 f 16 "29 29" 100 0 0 100  cideq - ));
+DATA(insert OID =  69 (  cideq			   PGUID 12 f t t t 2 f 16 "29 29" 100 0 0 100  cideq - ));
 DESCR("equal");
-DATA(insert OID =  70 (  charne			   PGUID 11 f t t t 2 f 16 "18 18" 100 0 0 100  charne - ));
+DATA(insert OID =  70 (  charne			   PGUID 12 f t t t 2 f 16 "18 18" 100 0 0 100  charne - ));
 DESCR("not equal");
-DATA(insert OID = 1246 (  charlt		   PGUID 11 f t t t 2 f 16 "18 18" 100 0 0 100  charlt - ));
+DATA(insert OID = 1246 (  charlt		   PGUID 12 f t t t 2 f 16 "18 18" 100 0 0 100  charlt - ));
 DESCR("less-than");
-DATA(insert OID =  72 (  charle			   PGUID 11 f t t t 2 f 16 "18 18" 100 0 0 100  charle - ));
+DATA(insert OID =  72 (  charle			   PGUID 12 f t t t 2 f 16 "18 18" 100 0 0 100  charle - ));
 DESCR("less-than-or-equal");
-DATA(insert OID =  73 (  chargt			   PGUID 11 f t t t 2 f 16 "18 18" 100 0 0 100  chargt - ));
+DATA(insert OID =  73 (  chargt			   PGUID 12 f t t t 2 f 16 "18 18" 100 0 0 100  chargt - ));
 DESCR("greater-than");
-DATA(insert OID =  74 (  charge			   PGUID 11 f t t t 2 f 16 "18 18" 100 0 0 100  charge - ));
+DATA(insert OID =  74 (  charge			   PGUID 12 f t t t 2 f 16 "18 18" 100 0 0 100  charge - ));
 DESCR("greater-than-or-equal");
-DATA(insert OID = 1248 (  charpl		   PGUID 11 f t t t 2 f 18 "18 18" 100 0 0 100  charpl - ));
-DESCR("addition");
-DATA(insert OID = 1250 (  charmi		   PGUID 11 f t t t 2 f 18 "18 18" 100 0 0 100  charmi - ));
+DATA(insert OID = 1248 (  charpl		   PGUID 12 f t t t 2 f 18 "18 18" 100 0 0 100  charpl - ));
+DESCR("add");
+DATA(insert OID = 1250 (  charmi		   PGUID 12 f t t t 2 f 18 "18 18" 100 0 0 100  charmi - ));
 DESCR("subtract");
-DATA(insert OID =  77 (  charmul		   PGUID 11 f t t t 2 f 18 "18 18" 100 0 0 100  charmul - ));
+DATA(insert OID =  77 (  charmul		   PGUID 12 f t t t 2 f 18 "18 18" 100 0 0 100  charmul - ));
 DESCR("multiply");
-DATA(insert OID =  78 (  chardiv		   PGUID 11 f t t t 2 f 18 "18 18" 100 0 0 100  chardiv - ));
+DATA(insert OID =  78 (  chardiv		   PGUID 12 f t t t 2 f 18 "18 18" 100 0 0 100  chardiv - ));
 DESCR("divide");
 
 DATA(insert OID =  79 (  nameregexeq	   PGUID 11 f t t t 2 f 16 "19 25" 100 0 0 100  nameregexeq - ));
@@ -205,42 +205,42 @@ DESCR("length");
 DATA(insert OID = 1258 (  textcat		   PGUID 11 f t t t 2 f 25 "25 25" 100 0 1 0	textcat - ));
 DESCR("concatenate");
 
-DATA(insert OID =  84 (  boolne			   PGUID 11 f t t t 2 f 16 "16 16" 100 0 0 100  boolne - ));
+DATA(insert OID =  84 (  boolne			   PGUID 12 f t t t 2 f 16 "16 16" 100 0 0 100  boolne - ));
 DESCR("not equal");
 DATA(insert OID =  89 (  version		   PGUID 11 f t f t 0 f 25 "" 100 0 0 100 version - ));
 DESCR("PostgreSQL version string");
 
-DATA(insert OID = 1265 (  rtcostestimate   PGUID 11 f t f t 7 f 0 "0 0 0 0 0 0 0" 100 0 0 100  rtcostestimate - ));
+DATA(insert OID = 1265 (  rtcostestimate   PGUID 12 f t f t 7 f 0 "0 0 0 0 0 0 0" 100 0 0 100  rtcostestimate - ));
 DESCR("r-tree cost estimator");
-DATA(insert OID = 1268 (  btcostestimate   PGUID 11 f t f t 7 f 0 "0 0 0 0 0 0 0" 100 0 0 100  btcostestimate - ));
+DATA(insert OID = 1268 (  btcostestimate   PGUID 12 f t f t 7 f 0 "0 0 0 0 0 0 0" 100 0 0 100  btcostestimate - ));
 DESCR("btree cost estimator");
 
 /* OIDS 100 - 199 */
 
 DATA(insert OID = 100 (  int8fac		   PGUID 11 f t t t 1 f 20 "20" 100 0 0 100  int8fac - ));
 DESCR("factorial");
-DATA(insert OID = 101 (  eqsel			   PGUID 11 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100  eqsel - ));
+DATA(insert OID = 101 (  eqsel			   PGUID 12 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100  eqsel - ));
 DESCR("restriction selectivity of = and related operators");
-DATA(insert OID = 102 (  neqsel			   PGUID 11 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100  neqsel - ));
+DATA(insert OID = 102 (  neqsel			   PGUID 12 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100  neqsel - ));
 DESCR("restriction selectivity of <> and related operators");
-DATA(insert OID = 103 (  scalarltsel	   PGUID 11 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100  scalarltsel - ));
+DATA(insert OID = 103 (  scalarltsel	   PGUID 12 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100  scalarltsel - ));
 DESCR("restriction selectivity of < and related operators on scalar datatypes");
-DATA(insert OID = 104 (  scalargtsel	   PGUID 11 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100  scalargtsel - ));
+DATA(insert OID = 104 (  scalargtsel	   PGUID 12 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100  scalargtsel - ));
 DESCR("restriction selectivity of > and related operators on scalar datatypes");
-DATA(insert OID = 105 (  eqjoinsel		   PGUID 11 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100	eqjoinsel - ));
+DATA(insert OID = 105 (  eqjoinsel		   PGUID 12 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100	eqjoinsel - ));
 DESCR("join selectivity of = and related operators");
-DATA(insert OID = 106 (  neqjoinsel		   PGUID 11 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100	neqjoinsel - ));
+DATA(insert OID = 106 (  neqjoinsel		   PGUID 12 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100	neqjoinsel - ));
 DESCR("join selectivity of <> and related operators");
-DATA(insert OID = 107 (  scalarltjoinsel   PGUID 11 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100	scalarltjoinsel - ));
+DATA(insert OID = 107 (  scalarltjoinsel   PGUID 12 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100	scalarltjoinsel - ));
 DESCR("join selectivity of < and related operators on scalar datatypes");
-DATA(insert OID = 108 (  scalargtjoinsel   PGUID 11 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100	scalargtjoinsel - ));
+DATA(insert OID = 108 (  scalargtjoinsel   PGUID 12 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100	scalargtjoinsel - ));
 DESCR("join selectivity of > and related operators on scalar datatypes");
 
-DATA(insert OID = 112 (  text			   PGUID 11 f t t t 1 f  25 "23" 100 0 0 100	int4_text - ));
+DATA(insert OID = 112 (  text			   PGUID 12 f t t t 1 f  25 "23" 100 0 0 100	int4_text - ));
 DESCR("convert int4 to text");
-DATA(insert OID = 113 (  text			   PGUID 11 f t t t 1 f  25 "21" 100 0 0 100	int2_text - ));
+DATA(insert OID = 113 (  text			   PGUID 12 f t t t 1 f  25 "21" 100 0 0 100	int2_text - ));
 DESCR("convert int2 to text");
-DATA(insert OID = 114 (  text			   PGUID 11 f t t t 1 f  25 "26" 100 0 0 100	oid_text - ));
+DATA(insert OID = 114 (  text			   PGUID 12 f t t t 1 f  25 "26" 100 0 0 100	oid_text - ));
 DESCR("convert oid to text");
 
 DATA(insert OID = 115 (  box_above		   PGUID 11 f t t t 2 f  16 "603 603" 100 1 0 100  box_above - ));
@@ -292,99 +292,99 @@ DATA(insert OID = 137 (  on_ppath		   PGUID 11 f t t t 2 f 16 "600 602" 100 0 1
 DESCR("contained in");
 DATA(insert OID = 138 (  box_center		   PGUID 11 f t t t 1 f 600 "603" 100 1 0 100  box_center - ));
 DESCR("center of");
-DATA(insert OID = 139 (  areasel		   PGUID 11 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100  areasel - ));
+DATA(insert OID = 139 (  areasel		   PGUID 12 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100  areasel - ));
 DESCR("restriction selectivity for area-comparison operators");
-DATA(insert OID = 140 (  areajoinsel	   PGUID 11 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100	areajoinsel - ));
+DATA(insert OID = 140 (  areajoinsel	   PGUID 12 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100	areajoinsel - ));
 DESCR("join selectivity for area-comparison operators");
-DATA(insert OID = 141 (  int4mul		   PGUID 11 f t t t 2 f 23 "23 23" 100 0 0 100  int4mul - ));
+DATA(insert OID = 141 (  int4mul		   PGUID 12 f t t t 2 f 23 "23 23" 100 0 0 100  int4mul - ));
 DESCR("multiply");
-DATA(insert OID = 142 (  int4fac		   PGUID 11 f t t t 1 f 23 "23" 100 0 0 100  int4fac - ));
+DATA(insert OID = 142 (  int4fac		   PGUID 12 f t t t 1 f 23 "23" 100 0 0 100  int4fac - ));
 DESCR("factorial");
 DATA(insert OID = 143 (  pointdist		   PGUID 11 f t t t 2 f 23 "600 600" 100 0 0 100	pointdist - ));
 DESCR("");
-DATA(insert OID = 144 (  int4ne			   PGUID 11 f t t t 2 f 16 "23 23" 100 0 0 100  int4ne - ));
+DATA(insert OID = 144 (  int4ne			   PGUID 12 f t t t 2 f 16 "23 23" 100 0 0 100  int4ne - ));
 DESCR("not equal");
-DATA(insert OID = 145 (  int2ne			   PGUID 11 f t t t 2 f 16 "21 21" 100 0 0 100  int2ne - ));
+DATA(insert OID = 145 (  int2ne			   PGUID 12 f t t t 2 f 16 "21 21" 100 0 0 100  int2ne - ));
 DESCR("not equal");
-DATA(insert OID = 146 (  int2gt			   PGUID 11 f t t t 2 f 16 "21 21" 100 0 0 100  int2gt - ));
+DATA(insert OID = 146 (  int2gt			   PGUID 12 f t t t 2 f 16 "21 21" 100 0 0 100  int2gt - ));
 DESCR("greater-than");
-DATA(insert OID = 147 (  int4gt			   PGUID 11 f t t t 2 f 16 "23 23" 100 0 0 100  int4gt - ));
+DATA(insert OID = 147 (  int4gt			   PGUID 12 f t t t 2 f 16 "23 23" 100 0 0 100  int4gt - ));
 DESCR("greater-than");
-DATA(insert OID = 148 (  int2le			   PGUID 11 f t t t 2 f 16 "21 21" 100 0 0 100  int2le - ));
+DATA(insert OID = 148 (  int2le			   PGUID 12 f t t t 2 f 16 "21 21" 100 0 0 100  int2le - ));
 DESCR("less-than-or-equal");
-DATA(insert OID = 149 (  int4le			   PGUID 11 f t t t 2 f 16 "23 23" 100 0 0 100  int4le - ));
+DATA(insert OID = 149 (  int4le			   PGUID 12 f t t t 2 f 16 "23 23" 100 0 0 100  int4le - ));
 DESCR("less-than-or-equal");
-DATA(insert OID = 150 (  int4ge			   PGUID 11 f t t t 2 f 16 "23 23" 100 0 0 100  int4ge - ));
+DATA(insert OID = 150 (  int4ge			   PGUID 12 f t t t 2 f 16 "23 23" 100 0 0 100  int4ge - ));
 DESCR("greater-than-or-equal");
-DATA(insert OID = 151 (  int2ge			   PGUID 11 f t t t 2 f 16 "21 21" 100 0 0 100  int2ge - ));
+DATA(insert OID = 151 (  int2ge			   PGUID 12 f t t t 2 f 16 "21 21" 100 0 0 100  int2ge - ));
 DESCR("greater-than-or-equal");
-DATA(insert OID = 152 (  int2mul		   PGUID 11 f t t t 2 f 21 "21 21" 100 0 0 100  int2mul - ));
+DATA(insert OID = 152 (  int2mul		   PGUID 12 f t t t 2 f 21 "21 21" 100 0 0 100  int2mul - ));
 DESCR("multiply");
-DATA(insert OID = 153 (  int2div		   PGUID 11 f t t t 2 f 21 "21 21" 100 0 0 100  int2div - ));
+DATA(insert OID = 153 (  int2div		   PGUID 12 f t t t 2 f 21 "21 21" 100 0 0 100  int2div - ));
 DESCR("divide");
-DATA(insert OID = 154 (  int4div		   PGUID 11 f t t t 2 f 23 "23 23" 100 0 0 100  int4div - ));
+DATA(insert OID = 154 (  int4div		   PGUID 12 f t t t 2 f 23 "23 23" 100 0 0 100  int4div - ));
 DESCR("divide");
-DATA(insert OID = 155 (  int2mod		   PGUID 11 f t t t 2 f 21 "21 21" 100 0 0 100  int2mod - ));
+DATA(insert OID = 155 (  int2mod		   PGUID 12 f t t t 2 f 21 "21 21" 100 0 0 100  int2mod - ));
 DESCR("modulus");
-DATA(insert OID = 156 (  int4mod		   PGUID 11 f t t t 2 f 23 "23 23" 100 0 0 100  int4mod - ));
+DATA(insert OID = 156 (  int4mod		   PGUID 12 f t t t 2 f 23 "23 23" 100 0 0 100  int4mod - ));
 DESCR("modulus");
 DATA(insert OID = 157 (  textne			   PGUID 11 f t t t 2 f 16 "25 25" 100 0 0 0	textne - ));
 DESCR("not equal");
-DATA(insert OID = 158 (  int24eq		   PGUID 11 f t t t 2 f 16 "21 23" 100 0 0 100  int24eq - ));
+DATA(insert OID = 158 (  int24eq		   PGUID 12 f t t t 2 f 16 "21 23" 100 0 0 100  int24eq - ));
 DESCR("equal");
-DATA(insert OID = 159 (  int42eq		   PGUID 11 f t t t 2 f 16 "23 21" 100 0 0 100  int42eq - ));
+DATA(insert OID = 159 (  int42eq		   PGUID 12 f t t t 2 f 16 "23 21" 100 0 0 100  int42eq - ));
 DESCR("equal");
-DATA(insert OID = 160 (  int24lt		   PGUID 11 f t t t 2 f 16 "21 23" 100 0 0 100  int24lt - ));
+DATA(insert OID = 160 (  int24lt		   PGUID 12 f t t t 2 f 16 "21 23" 100 0 0 100  int24lt - ));
 DESCR("less-than");
-DATA(insert OID = 161 (  int42lt		   PGUID 11 f t t t 2 f 16 "23 21" 100 0 0 100  int42lt - ));
+DATA(insert OID = 161 (  int42lt		   PGUID 12 f t t t 2 f 16 "23 21" 100 0 0 100  int42lt - ));
 DESCR("less-than");
-DATA(insert OID = 162 (  int24gt		   PGUID 11 f t t t 2 f 16 "21 23" 100 0 0 100  int24gt - ));
+DATA(insert OID = 162 (  int24gt		   PGUID 12 f t t t 2 f 16 "21 23" 100 0 0 100  int24gt - ));
 DESCR("greater-than");
-DATA(insert OID = 163 (  int42gt		   PGUID 11 f t t t 2 f 16 "23 21" 100 0 0 100  int42gt - ));
+DATA(insert OID = 163 (  int42gt		   PGUID 12 f t t t 2 f 16 "23 21" 100 0 0 100  int42gt - ));
 DESCR("greater-than");
-DATA(insert OID = 164 (  int24ne		   PGUID 11 f t t t 2 f 16 "21 23" 100 0 0 100  int24ne - ));
+DATA(insert OID = 164 (  int24ne		   PGUID 12 f t t t 2 f 16 "21 23" 100 0 0 100  int24ne - ));
 DESCR("not equal");
-DATA(insert OID = 165 (  int42ne		   PGUID 11 f t t t 2 f 16 "23 21" 100 0 0 100  int42ne - ));
+DATA(insert OID = 165 (  int42ne		   PGUID 12 f t t t 2 f 16 "23 21" 100 0 0 100  int42ne - ));
 DESCR("not equal");
-DATA(insert OID = 166 (  int24le		   PGUID 11 f t t t 2 f 16 "21 23" 100 0 0 100  int24le - ));
+DATA(insert OID = 166 (  int24le		   PGUID 12 f t t t 2 f 16 "21 23" 100 0 0 100  int24le - ));
 DESCR("less-than-or-equal");
-DATA(insert OID = 167 (  int42le		   PGUID 11 f t t t 2 f 16 "23 21" 100 0 0 100  int42le - ));
+DATA(insert OID = 167 (  int42le		   PGUID 12 f t t t 2 f 16 "23 21" 100 0 0 100  int42le - ));
 DESCR("less-than-or-equal");
-DATA(insert OID = 168 (  int24ge		   PGUID 11 f t t t 2 f 16 "21 23" 100 0 0 100  int24ge - ));
+DATA(insert OID = 168 (  int24ge		   PGUID 12 f t t t 2 f 16 "21 23" 100 0 0 100  int24ge - ));
 DESCR("greater-than-or-equal");
-DATA(insert OID = 169 (  int42ge		   PGUID 11 f t t t 2 f 16 "23 21" 100 0 0 100  int42ge - ));
+DATA(insert OID = 169 (  int42ge		   PGUID 12 f t t t 2 f 16 "23 21" 100 0 0 100  int42ge - ));
 DESCR("greater-than-or-equal");
-DATA(insert OID = 170 (  int24mul		   PGUID 11 f t t t 2 f 23 "21 23" 100 0 0 100  int24mul - ));
+DATA(insert OID = 170 (  int24mul		   PGUID 12 f t t t 2 f 23 "21 23" 100 0 0 100  int24mul - ));
 DESCR("multiply");
-DATA(insert OID = 171 (  int42mul		   PGUID 11 f t t t 2 f 23 "23 21" 100 0 0 100  int42mul - ));
+DATA(insert OID = 171 (  int42mul		   PGUID 12 f t t t 2 f 23 "23 21" 100 0 0 100  int42mul - ));
 DESCR("multiply");
-DATA(insert OID = 172 (  int24div		   PGUID 11 f t t t 2 f 23 "21 23" 100 0 0 100  int24div - ));
+DATA(insert OID = 172 (  int24div		   PGUID 12 f t t t 2 f 23 "21 23" 100 0 0 100  int24div - ));
 DESCR("divide");
-DATA(insert OID = 173 (  int42div		   PGUID 11 f t t t 2 f 23 "23 21" 100 0 0 100  int42div - ));
+DATA(insert OID = 173 (  int42div		   PGUID 12 f t t t 2 f 23 "23 21" 100 0 0 100  int42div - ));
 DESCR("divide");
-DATA(insert OID = 174 (  int24mod		   PGUID 11 f t t t 2 f 23 "21 23" 100 0 0 100  int24mod - ));
+DATA(insert OID = 174 (  int24mod		   PGUID 12 f t t t 2 f 23 "21 23" 100 0 0 100  int24mod - ));
 DESCR("modulus");
-DATA(insert OID = 175 (  int42mod		   PGUID 11 f t t t 2 f 23 "23 21" 100 0 0 100  int42mod - ));
+DATA(insert OID = 175 (  int42mod		   PGUID 12 f t t t 2 f 23 "23 21" 100 0 0 100  int42mod - ));
 DESCR("modulus");
-DATA(insert OID = 176 (  int2pl			   PGUID 11 f t t t 2 f 21 "21 21" 100 0 0 100  int2pl - ));
+DATA(insert OID = 176 (  int2pl			   PGUID 12 f t t t 2 f 21 "21 21" 100 0 0 100  int2pl - ));
 DESCR("addition");
-DATA(insert OID = 177 (  int4pl			   PGUID 11 f t t t 2 f 23 "23 23" 100 0 0 100  int4pl - ));
+DATA(insert OID = 177 (  int4pl			   PGUID 12 f t t t 2 f 23 "23 23" 100 0 0 100  int4pl - ));
 DESCR("addition");
-DATA(insert OID = 178 (  int24pl		   PGUID 11 f t t t 2 f 23 "21 23" 100 0 0 100  int24pl - ));
+DATA(insert OID = 178 (  int24pl		   PGUID 12 f t t t 2 f 23 "21 23" 100 0 0 100  int24pl - ));
 DESCR("addition");
-DATA(insert OID = 179 (  int42pl		   PGUID 11 f t t t 2 f 23 "23 21" 100 0 0 100  int42pl - ));
+DATA(insert OID = 179 (  int42pl		   PGUID 12 f t t t 2 f 23 "23 21" 100 0 0 100  int42pl - ));
 DESCR("addition");
-DATA(insert OID = 180 (  int2mi			   PGUID 11 f t t t 2 f 21 "21 21" 100 0 0 100  int2mi - ));
+DATA(insert OID = 180 (  int2mi			   PGUID 12 f t t t 2 f 21 "21 21" 100 0 0 100  int2mi - ));
 DESCR("subtract");
-DATA(insert OID = 181 (  int4mi			   PGUID 11 f t t t 2 f 23 "23 23" 100 0 0 100  int4mi - ));
+DATA(insert OID = 181 (  int4mi			   PGUID 12 f t t t 2 f 23 "23 23" 100 0 0 100  int4mi - ));
 DESCR("subtract");
-DATA(insert OID = 182 (  int24mi		   PGUID 11 f t t t 2 f 23 "21 23" 100 0 0 100  int24mi - ));
+DATA(insert OID = 182 (  int24mi		   PGUID 12 f t t t 2 f 23 "21 23" 100 0 0 100  int24mi - ));
 DESCR("subtract");
-DATA(insert OID = 183 (  int42mi		   PGUID 11 f t t t 2 f 23 "23 21" 100 0 0 100  int42mi - ));
+DATA(insert OID = 183 (  int42mi		   PGUID 12 f t t t 2 f 23 "23 21" 100 0 0 100  int42mi - ));
 DESCR("subtract");
-DATA(insert OID = 184 (  oideq			   PGUID 11 f t t t 2 f 16 "26 26" 100 0 0 100  oideq - ));
+DATA(insert OID = 184 (  oideq			   PGUID 12 f t t t 2 f 16 "26 26" 100 0 0 100  oideq - ));
 DESCR("equal");
-DATA(insert OID = 185 (  oidne			   PGUID 11 f t t t 2 f 16 "26 26" 100 0 0 100  oidne - ));
+DATA(insert OID = 185 (  oidne			   PGUID 12 f t t t 2 f 16 "26 26" 100 0 0 100  oidne - ));
 DESCR("not equal");
 DATA(insert OID = 186 (  box_same		   PGUID 11 f t t t 2 f 16 "603 603" 100 0 0 100	box_same - ));
 DESCR("same as");
@@ -440,9 +440,9 @@ DESCR("larger of two");
 DATA(insert OID = 211 (  float4smaller	   PGUID 11 f t t t 2 f 700 "700 700" 100 0 0 100  float4smaller - ));
 DESCR("smaller of two");
 
-DATA(insert OID = 212 (  int4um			   PGUID 11 f t t t 1 f 23 "23" 100 0 0 100  int4um - ));
+DATA(insert OID = 212 (  int4um			   PGUID 12 f t t t 1 f 23 "23" 100 0 0 100  int4um - ));
 DESCR("negate");
-DATA(insert OID = 213 (  int2um			   PGUID 11 f t t t 1 f 21 "21" 100 0 0 100  int2um - ));
+DATA(insert OID = 213 (  int2um			   PGUID 12 f t t t 1 f 21 "21" 100 0 0 100  int2um - ));
 DESCR("negate");
 
 DATA(insert OID = 214 (  float8in		   PGUID 11 f t t t 1 f 701 "0" 100 0 0 100  float8in - ));
@@ -489,13 +489,13 @@ DATA(insert OID = 233 (  dexp			   PGUID 11 f t t t 1 f 701 "701" 100 0 0 100  d
 DESCR("natural exponential (e^x)");
 DATA(insert OID = 234 (  dlog1			   PGUID 11 f t t t 1 f 701 "701" 100 0 0 100  dlog1 - ));
 DESCR("natural logarithm");
-DATA(insert OID = 235 (  float8			   PGUID 11 f t t t 1 f 701  "21" 100 0 0 100  i2tod - ));
+DATA(insert OID = 235 (  float8			   PGUID 12 f t t t 1 f 701  "21" 100 0 0 100  i2tod - ));
 DESCR("convert int2 to float8");
-DATA(insert OID = 236 (  float4			   PGUID 11 f t t t 1 f 700  "21" 100 0 0 100  i2tof - ));
+DATA(insert OID = 236 (  float4			   PGUID 12 f t t t 1 f 700  "21" 100 0 0 100  i2tof - ));
 DESCR("convert int2 to float4");
-DATA(insert OID = 237 (  int2			   PGUID 11 f t t t 1 f  21 "701" 100 0 0 100  dtoi2 - ));
+DATA(insert OID = 237 (  int2			   PGUID 12 f t t t 1 f  21 "701" 100 0 0 100  dtoi2 - ));
 DESCR("convert float8 to int2");
-DATA(insert OID = 238 (  int2			   PGUID 11 f t t t 1 f  21 "700" 100 0 0 100  ftoi2 - ));
+DATA(insert OID = 238 (  int2			   PGUID 12 f t t t 1 f  21 "700" 100 0 0 100  ftoi2 - ));
 DESCR("convert float4 to int2");
 DATA(insert OID = 239 (  line_distance	   PGUID 11 f t t t 2 f 701 "628 628" 100 0 0 100  line_distance - ));
 DESCR("distance between");
@@ -573,7 +573,7 @@ DESCR("Current date and time with microseconds");
 DATA(insert OID = 275 (  isfinite		   PGUID 11 f t f t 1 f 16 "702" 100 0 0 100	abstime_finite - ));
 DESCR("");
 
-DATA(insert OID = 276 (  int2fac		   PGUID 11 f t t t 1 f 23 "21" 100 0 0 100  int2fac - ));
+DATA(insert OID = 276 (  int2fac		   PGUID 12 f t t t 1 f 23 "21" 100 0 0 100  int2fac - ));
 DESCR("");
 
 DATA(insert OID = 277 (  inter_sl		   PGUID 11 f t t t 2 f 16 "601 628" 100 0 0 100	inter_sl - ));
@@ -656,11 +656,11 @@ DATA(insert OID = 311 (  float8			   PGUID 11 f t t t 1 f 701 "700" 100 0 0 100
 DESCR("convert float4 to float8");
 DATA(insert OID = 312 (  float4			   PGUID 11 f t t t 1 f 700 "701" 100 0 0 100  dtof - ));
 DESCR("convert float8 to float4");
-DATA(insert OID = 313 (  int4			   PGUID 11 f t t t 1 f  23  "21" 100 0 0 100  i2toi4 - ));
+DATA(insert OID = 313 (  int4			   PGUID 12 f t t t 1 f  23  "21" 100 0 0 100  i2toi4 - ));
 DESCR("convert int2 to int4");
-DATA(insert OID = 314 (  int2			   PGUID 11 f t t t 1 f  21  "23" 100 0 0 100  i4toi2 - ));
+DATA(insert OID = 314 (  int2			   PGUID 12 f t t t 1 f  21  "23" 100 0 0 100  i4toi2 - ));
 DESCR("convert int4 to int2");
-DATA(insert OID = 315 (  int2vectoreq	   PGUID 11 f t t t 2 f  16  "22 22" 100 0 0 100	int2vectoreq - ));
+DATA(insert OID = 315 (  int2vectoreq	   PGUID 12 f t t t 2 f  16  "22 22" 100 0 0 100	int2vectoreq - ));
 DESCR("equal");
 DATA(insert OID = 316 (  float8			   PGUID 11 f t t t 1 f 701  "23" 100 0 0 100  i4tod - ));
 DESCR("convert int4 to float8");
@@ -730,31 +730,31 @@ DESCR("(internal)");
 DATA(insert OID = 348 (  poly_out		   PGUID 11 f t t t 1 f 23  "0" 100 0 1 0  poly_out - ));
 DESCR("(internal)");
 
-DATA(insert OID = 350 (  btint2cmp		   PGUID 11 f t t t 2 f 23 "21 21" 100 0 0 100  btint2cmp - ));
+DATA(insert OID = 350 (  btint2cmp		   PGUID 12 f t t t 2 f 23 "21 21" 100 0 0 100  btint2cmp - ));
 DESCR("btree less-equal-greater");
-DATA(insert OID = 351 (  btint4cmp		   PGUID 11 f t t t 2 f 23 "23 23" 100 0 0 100  btint4cmp - ));
+DATA(insert OID = 351 (  btint4cmp		   PGUID 12 f t t t 2 f 23 "23 23" 100 0 0 100  btint4cmp - ));
 DESCR("btree less-equal-greater");
-DATA(insert OID = 842 (  btint8cmp		   PGUID 11 f t t t 2 f 23 "20 20" 100 0 0 100  btint8cmp - ));
+DATA(insert OID = 842 (  btint8cmp		   PGUID 12 f t t t 2 f 23 "20 20" 100 0 0 100  btint8cmp - ));
 DESCR("btree less-equal-greater");
-DATA(insert OID = 352 (  btint42cmp		   PGUID 11 f t t t 2 f 23 "23 21" 100 0 0 100  btint42cmp - ));
+DATA(insert OID = 352 (  btint42cmp		   PGUID 12 f t t t 2 f 23 "23 21" 100 0 0 100  btint42cmp - ));
 DESCR("btree less-equal-greater");
-DATA(insert OID = 353 (  btint24cmp		   PGUID 11 f t t t 2 f 23 "21 23" 100 0 0 100  btint24cmp - ));
+DATA(insert OID = 353 (  btint24cmp		   PGUID 12 f t t t 2 f 23 "21 23" 100 0 0 100  btint24cmp - ));
 DESCR("btree less-equal-greater");
-DATA(insert OID = 354 (  btfloat4cmp	   PGUID 11 f t t t 2 f 23 "700 700" 100 0 0 100	btfloat4cmp - ));
+DATA(insert OID = 354 (  btfloat4cmp	   PGUID 12 f t t t 2 f 23 "700 700" 100 0 0 100	btfloat4cmp - ));
 DESCR("btree less-equal-greater");
-DATA(insert OID = 355 (  btfloat8cmp	   PGUID 11 f t t t 2 f 23 "701 701" 100 0 0 100	btfloat8cmp - ));
+DATA(insert OID = 355 (  btfloat8cmp	   PGUID 12 f t t t 2 f 23 "701 701" 100 0 0 100	btfloat8cmp - ));
 DESCR("btree less-equal-greater");
-DATA(insert OID = 356 (  btoidcmp		   PGUID 11 f t t t 2 f 23 "26 26" 100 0 0 100  btoidcmp - ));
+DATA(insert OID = 356 (  btoidcmp		   PGUID 12 f t t t 2 f 23 "26 26" 100 0 0 100  btoidcmp - ));
 DESCR("btree less-equal-greater");
-DATA(insert OID = 404 (  btoidvectorcmp    PGUID 11 f t t t 2 f 23 "30 30" 100 0 0 100  btoidvectorcmp - ));
+DATA(insert OID = 404 (  btoidvectorcmp    PGUID 12 f t t t 2 f 23 "30 30" 100 0 0 100  btoidvectorcmp - ));
 DESCR("btree less-equal-greater");
 DATA(insert OID = 357 (  btabstimecmp	   PGUID 11 f t f t 2 f 23 "702 702" 100 0 0 100	btabstimecmp - ));
 DESCR("btree less-equal-greater");
-DATA(insert OID = 358 (  btcharcmp		   PGUID 11 f t t t 2 f 23 "18 18" 100 0 0 100  btcharcmp - ));
+DATA(insert OID = 358 (  btcharcmp		   PGUID 12 f t t t 2 f 23 "18 18" 100 0 0 100  btcharcmp - ));
 DESCR("btree less-equal-greater");
-DATA(insert OID = 359 (  btnamecmp		   PGUID 11 f t t t 2 f 23 "19 19" 100 0 0 100  btnamecmp - ));
+DATA(insert OID = 359 (  btnamecmp		   PGUID 12 f t t t 2 f 23 "19 19" 100 0 0 100  btnamecmp - ));
 DESCR("btree less-equal-greater");
-DATA(insert OID = 360 (  bttextcmp		   PGUID 11 f t t t 2 f 23 "25 25" 100 0 0 100  bttextcmp - ));
+DATA(insert OID = 360 (  bttextcmp		   PGUID 12 f t t t 2 f 23 "25 25" 100 0 0 100  bttextcmp - ));
 DESCR("btree less-equal-greater");
 
 DATA(insert OID = 361 (  lseg_distance	   PGUID 11 f t t t 2 f 701 "601 601" 100 0 0 100  lseg_distance - ));
@@ -795,7 +795,7 @@ DESCR("convert name to char()");
 DATA(insert OID =  409 (  name			   PGUID 11 f t t t 1 f	19 "1042" 100 0 0 100	bpchar_name - ));
 DESCR("convert char() to name");
 
-DATA(insert OID =  438 (  hashcostestimate PGUID 11 f t f t 7 f 0 "0 0 0 0 0 0 0" 100 0 0 100  hashcostestimate - ));
+DATA(insert OID =  438 (  hashcostestimate PGUID 12 f t f t 7 f 0 "0 0 0 0 0 0 0" 100 0 0 100  hashcostestimate - ));
 DESCR("hash index cost estimator");
 
 DATA(insert OID = 440 (  hashgettuple	   PGUID 11 f t f t 2 f 23 "0" 100 0 0 100  hashgettuple - ));
@@ -816,25 +816,25 @@ DATA(insert OID = 447 (  hashrestrpos	   PGUID 11 f t f t 1 f 23 "0" 100 0 0 100
 DESCR("hash(internal)");
 DATA(insert OID = 448 (  hashbuild		   PGUID 11 f t f t 9 f 23 "0" 100 0 0 100  hashbuild - ));
 DESCR("hash(internal)");
-DATA(insert OID = 449 (  hashint2		   PGUID 11 f t t t 1 f 23 "21" 100 0 0 100  hashint2 - ));
+DATA(insert OID = 449 (  hashint2		   PGUID 12 f t t t 1 f 23 "21" 100 0 0 100  hashint2 - ));
 DESCR("hash");
-DATA(insert OID = 450 (  hashint4		   PGUID 11 f t t t 1 f 23 "23" 100 0 0 100  hashint4 - ));
+DATA(insert OID = 450 (  hashint4		   PGUID 12 f t t t 1 f 23 "23" 100 0 0 100  hashint4 - ));
 DESCR("hash");
-DATA(insert OID = 949 (  hashint8		   PGUID 11 f t t t 1 f 23 "20" 100 0 0 100  hashint8 - ));
+DATA(insert OID = 949 (  hashint8		   PGUID 12 f t t t 1 f 23 "20" 100 0 0 100  hashint8 - ));
 DESCR("hash");
-DATA(insert OID = 451 (  hashfloat4		   PGUID 11 f t t t 1 f 23 "700" 100 0 0 100	hashfloat4 - ));
+DATA(insert OID = 451 (  hashfloat4		   PGUID 12 f t t t 1 f 23 "700" 100 0 0 100	hashfloat4 - ));
 DESCR("hash");
-DATA(insert OID = 452 (  hashfloat8		   PGUID 11 f t t t 1 f 23 "701" 100 0 0 100	hashfloat8 - ));
+DATA(insert OID = 452 (  hashfloat8		   PGUID 12 f t t t 1 f 23 "701" 100 0 0 100	hashfloat8 - ));
 DESCR("hash");
-DATA(insert OID = 453 (  hashoid		   PGUID 11 f t t t 1 f 23 "26" 100 0 0 100  hashoid - ));
+DATA(insert OID = 453 (  hashoid		   PGUID 12 f t t t 1 f 23 "26" 100 0 0 100  hashoid - ));
 DESCR("hash");
-DATA(insert OID = 454 (  hashchar		   PGUID 11 f t t t 1 f 23 "18" 100 0 0 100  hashchar - ));
+DATA(insert OID = 454 (  hashchar		   PGUID 12 f t t t 1 f 23 "18" 100 0 0 100  hashchar - ));
 DESCR("hash");
-DATA(insert OID = 455 (  hashname		   PGUID 11 f t t t 1 f 23 "19" 100 0 0 100  hashname - ));
+DATA(insert OID = 455 (  hashname		   PGUID 12 f t t t 1 f 23 "19" 100 0 0 100  hashname - ));
 DESCR("hash");
-DATA(insert OID = 456 (  hashtext		   PGUID 11 f t t t 1 f 23 "25" 100 0 0 100  hashtext - ));
+DATA(insert OID = 456 (  hashtext		   PGUID 12 f t t t 1 f 23 "25" 100 0 0 100  hashtext - ));
 DESCR("hash");
-DATA(insert OID = 457 (  hashoidvector	   PGUID 11 f t t t 1 f 23 "30" 100 0 0 100  hashoidvector - ));
+DATA(insert OID = 457 (  hashoidvector	   PGUID 12 f t t t 1 f 23 "30" 100 0 0 100  hashoidvector - ));
 DESCR("hash");
 DATA(insert OID = 458 (  text_larger	   PGUID 11 f t t t 2 f 25 "25 25" 100 0 0 100  text_larger - ));
 DESCR("larger of two");
@@ -898,9 +898,9 @@ DATA(insert OID = 1285 (  int4notin		   PGUID 11 f t f t 2 f 16 "23 0" 100 0 0 1
 DESCR("not in");
 DATA(insert OID = 1286 (  oidnotin		   PGUID 11 f t f t 2 f 16 "26 0" 100 0 0 100  oidnotin - ));
 DESCR("not in");
-DATA(insert OID = 1287 (  int44in		   PGUID 11 f t t t 1 f 22 "0" 100 0 0 100  int44in - ));
+DATA(insert OID = 1287 (  int44in		   PGUID 12 f t t t 1 f 22 "0" 100 0 0 100  int44in - ));
 DESCR("(internal)");
-DATA(insert OID = 653 (  int44out		   PGUID 11 f t t t 1 f 23 "0" 100 0 0 100  int44out - ));
+DATA(insert OID = 653 (  int44out		   PGUID 12 f t t t 1 f 23 "0" 100 0 0 100  int44out - ));
 DESCR("(internal)");
 DATA(insert OID = 655 (  namelt			   PGUID 11 f t t t 2 f 16 "19 19" 100 0 0 100  namelt - ));
 DESCR("less-than");
@@ -920,31 +920,31 @@ DESCR("truncate varchar()");
 
 DATA(insert OID = 676 (  mktinterval	   PGUID 11 f t f t 2 f 704 "702 702" 100 0 0 100 mktinterval - ));
 DESCR("convert to tinterval");
-DATA(insert OID = 619 (  oidvectorne	   PGUID 11 f t t t 2 f 16 "30 30" 100 0 0 100  oidvectorne - ));
+DATA(insert OID = 619 (  oidvectorne	   PGUID 12 f t t t 2 f 16 "30 30" 100 0 0 100  oidvectorne - ));
 DESCR("less-than");
-DATA(insert OID = 677 (  oidvectorlt	   PGUID 11 f t t t 2 f 16 "30 30" 100 0 0 100  oidvectorlt - ));
+DATA(insert OID = 677 (  oidvectorlt	   PGUID 12 f t t t 2 f 16 "30 30" 100 0 0 100  oidvectorlt - ));
 DESCR("less-than");
-DATA(insert OID = 678 (  oidvectorle	   PGUID 11 f t t t 2 f 16 "30 30" 100 0 0 100  oidvectorle - ));
+DATA(insert OID = 678 (  oidvectorle	   PGUID 12 f t t t 2 f 16 "30 30" 100 0 0 100  oidvectorle - ));
 DESCR("less-than-or-equal");
-DATA(insert OID = 679 (  oidvectoreq	   PGUID 11 f t t t 2 f 16 "30 30" 100 0 0 100  oidvectoreq - ));
+DATA(insert OID = 679 (  oidvectoreq	   PGUID 12 f t t t 2 f 16 "30 30" 100 0 0 100  oidvectoreq - ));
 DESCR("equal");
-DATA(insert OID = 680 (  oidvectorge	   PGUID 11 f t t t 2 f 16 "30 30" 100 0 0 100  oidvectorge - ));
+DATA(insert OID = 680 (  oidvectorge	   PGUID 12 f t t t 2 f 16 "30 30" 100 0 0 100  oidvectorge - ));
 DESCR("greater-than-or-equal");
-DATA(insert OID = 681 (  oidvectorgt	   PGUID 11 f t t t 2 f 16 "30 30" 100 0 0 100  oidvectorgt - ));
+DATA(insert OID = 681 (  oidvectorgt	   PGUID 12 f t t t 2 f 16 "30 30" 100 0 0 100  oidvectorgt - ));
 DESCR("greater-than");
 
 /* OIDS 700 - 799 */
 DATA(insert OID = 710 (  getpgusername	   PGUID 11 f t f t 0 f 19 "0" 100 0 0 100  getpgusername - ));
 DESCR("Return username");
-DATA(insert OID = 711 (  userfntest		   PGUID 11 f t t t 1 f 23 "23" 100 0 0 100  userfntest - ));
+DATA(insert OID = 711 (  userfntest		   PGUID 12 f t t t 1 f 23 "23" 100 0 0 100  userfntest - ));
 DESCR("");
-DATA(insert OID = 713 (  oidrand		   PGUID 11 f t f t 2 f 16 "26 23" 100 0 0 100  oidrand - ));
+DATA(insert OID = 713 (  oidrand		   PGUID 12 f t f t 2 f 16 "26 23" 100 0 0 100  oidrand - ));
 DESCR("random");
-DATA(insert OID = 715 (  oidsrand		   PGUID 11 f t f t 1 f 16 "23" 100 0 0 100  oidsrand - ));
+DATA(insert OID = 715 (  oidsrand		   PGUID 12 f t f t 1 f 16 "23" 100 0 0 100  oidsrand - ));
 DESCR("seed random number generator");
-DATA(insert OID = 716 (  oideqint4		   PGUID 11 f t t t 2 f 16 "26 23" 100 0 0 100  oideqint4 - ));
+DATA(insert OID = 716 (  oideqint4		   PGUID 12 f t t t 2 f 16 "26 23" 100 0 0 100  oideqint4 - ));
 DESCR("equal");
-DATA(insert OID = 717 (  int4eqoid		   PGUID 11 f t t t 2 f 16 "23 26" 100 0 0 100  int4eqoid - ));
+DATA(insert OID = 717 (  int4eqoid		   PGUID 12 f t t t 2 f 16 "23 26" 100 0 0 100  int4eqoid - ));
 DESCR("equal");
 
 DATA(insert OID = 720 (  octet_length	   PGUID 11 f t t t 1 f 23 "17" 100 0 0 100  byteaoctetlen - ));
@@ -1000,16 +1000,16 @@ DESCR("array");
 
 DATA(insert OID = 752 (  filename_in	   PGUID 11 f t t t 1 f 605 "0" 100 0 0 100  filename_in - ));
 DESCR("(internal)");
-DATA(insert OID = 753 (  filename_out	   PGUID 11 f t t t 2 f 19  "0 0" 100 0 0 100  filename_out - ));
+DATA(insert OID = 753 (  filename_out	   PGUID 11 f t t t 2 f 23  "0 0" 100 0 0 100  filename_out - ));
 DESCR("(internal)");
 
-DATA(insert OID = 760 (  smgrin			   PGUID 11 f t f t 1 f 210 "0" 100 0 0 100  smgrin - ));
+DATA(insert OID = 760 (  smgrin			   PGUID 12 f t f t 1 f 210 "0" 100 0 0 100  smgrin - ));
 DESCR("storage manager(internal)");
-DATA(insert OID = 761 (  smgrout		   PGUID 11 f t f t 1 f 23  "0" 100 0 0 100  smgrout - ));
+DATA(insert OID = 761 (  smgrout		   PGUID 12 f t f t 1 f 23  "0" 100 0 0 100  smgrout - ));
 DESCR("storage manager(internal)");
-DATA(insert OID = 762 (  smgreq			   PGUID 11 f t f t 2 f 16 "210 210" 100 0 0 100	smgreq - ));
+DATA(insert OID = 762 (  smgreq			   PGUID 12 f t f t 2 f 16 "210 210" 100 0 0 100	smgreq - ));
 DESCR("storage manager");
-DATA(insert OID = 763 (  smgrne			   PGUID 11 f t f t 2 f 16 "210 210" 100 0 0 100	smgrne - ));
+DATA(insert OID = 763 (  smgrne			   PGUID 12 f t f t 2 f 16 "210 210" 100 0 0 100	smgrne - ));
 DESCR("storage manager");
 
 DATA(insert OID = 764 (  lo_import		   PGUID 11 f t f t 1 f 26 "25" 100 0 0 100  lo_import - ));
@@ -1017,20 +1017,20 @@ DESCR("large object import");
 DATA(insert OID = 765 (  lo_export		   PGUID 11 f t f t 2 f 23 "26 25" 100 0 0 100  lo_export - ));
 DESCR("large object export");
 
-DATA(insert OID = 766 (  int4inc		   PGUID 11 f t t t 1 f 23 "23" 100 0 0 100  int4inc - ));
+DATA(insert OID = 766 (  int4inc		   PGUID 12 f t t t 1 f 23 "23" 100 0 0 100  int4inc - ));
 DESCR("increment");
-DATA(insert OID = 767 (  int2inc		   PGUID 11 f t t t 1 f 21 "21" 100 0 0 100  int2inc - ));
+DATA(insert OID = 767 (  int2inc		   PGUID 12 f t t t 1 f 21 "21" 100 0 0 100  int2inc - ));
 DESCR("increment");
-DATA(insert OID = 768 (  int4larger		   PGUID 11 f t t t 2 f 23 "23 23" 100 0 0 100  int4larger - ));
+DATA(insert OID = 768 (  int4larger		   PGUID 12 f t t t 2 f 23 "23 23" 100 0 0 100  int4larger - ));
 DESCR("larger of two");
-DATA(insert OID = 769 (  int4smaller	   PGUID 11 f t t t 2 f 23 "23 23" 100 0 0 100  int4smaller - ));
+DATA(insert OID = 769 (  int4smaller	   PGUID 12 f t t t 2 f 23 "23 23" 100 0 0 100  int4smaller - ));
 DESCR("smaller of two");
-DATA(insert OID = 770 (  int2larger		   PGUID 11 f t t t 2 f 21 "21 21" 100 0 0 100  int2larger - ));
+DATA(insert OID = 770 (  int2larger		   PGUID 12 f t t t 2 f 21 "21 21" 100 0 0 100  int2larger - ));
 DESCR("larger of two");
-DATA(insert OID = 771 (  int2smaller	   PGUID 11 f t t t 2 f 21 "21 21" 100 0 0 100  int2smaller - ));
+DATA(insert OID = 771 (  int2smaller	   PGUID 12 f t t t 2 f 21 "21 21" 100 0 0 100  int2smaller - ));
 DESCR("smaller of two");
 
-DATA(insert OID = 772 (  gistcostestimate  PGUID 11 f t f t 7 f 0 "0 0 0 0 0 0 0" 100 0 0 100  gistcostestimate - ));
+DATA(insert OID = 772 (  gistcostestimate  PGUID 12 f t f t 7 f 0 "0 0 0 0 0 0 0" 100 0 0 100  gistcostestimate - ));
 DESCR("gist cost estimator");
 DATA(insert OID = 774 (  gistgettuple	   PGUID 11 f t f t 2 f 23 "0" 100 0 0 100  gistgettuple - ));
 DESCR("gist(internal)");
@@ -1066,11 +1066,11 @@ DESCR("greater-than-or-equal");
 
 /* OIDS 800 - 899 */
 
-DATA(insert OID = 817 (  oid			   PGUID 11 f t t t 1 f 26 "25" 100 0 0 100  text_oid -));
+DATA(insert OID = 817 (  oid			   PGUID 12 f t t t 1 f 26 "25" 100 0 0 100  text_oid -));
 DESCR("convert text to oid");
-DATA(insert OID = 818 (  int2			   PGUID 11 f t t t 1 f 21 "25" 100 0 0 100  text_int2 -));
+DATA(insert OID = 818 (  int2			   PGUID 12 f t t t 1 f 21 "25" 100 0 0 100  text_int2 -));
 DESCR("convert text to int2");
-DATA(insert OID = 819 (  int4			   PGUID 11 f t t t 1 f 23 "25" 100 0 0 100  text_int4 -));
+DATA(insert OID = 819 (  int4			   PGUID 12 f t t t 1 f 23 "25" 100 0 0 100  text_int4 -));
 DESCR("convert text to int4");
 
 DATA(insert OID = 838 (  float8			   PGUID 11 f t t t 1 f 701 "25" 100 0 0 100	text_float8 -));
@@ -1114,22 +1114,22 @@ DESCR("matches LIKE expression");
 DATA(insert OID =  859 (  namenlike		   PGUID 11 f t t t 2 f 16 "19 25" 100 0 0 100  namenlike - ));
 DESCR("does not match LIKE expression");
 
-DATA(insert OID =  860 (  bpchar		   PGUID 11 f t t t 1 f 1042 "18" 100 0 0 100  char_bpchar - ));
+DATA(insert OID =  860 (  bpchar		   PGUID 12 f t t t 1 f 1042 "18" 100 0 0 100  char_bpchar - ));
 DESCR("convert char to char()");
-DATA(insert OID =  861 (  char			   PGUID 11 f t t t 1 f	18 "1042" 100 0 0 100  bpchar_char - ));
+DATA(insert OID =  861 (  char			   PGUID 12 f t t t 1 f	18 "1042" 100 0 0 100  bpchar_char - ));
 DESCR("convert char() to char");
 
 DATA(insert OID =  862 (  int4_mul_cash		   PGUID 11 f t t t 2 f 790 "23 790" 100 0 0 100	int4_mul_cash - ));
 DESCR("multiply");
-DATA(insert OID =  863 (  int2_mul_cash		   PGUID 11 f t t t 2 f 790 "21 790" 100 0 0 100	int2_mul_cash - ));
+DATA(insert OID =  863 (  int2_mul_cash		   PGUID 12 f t t t 2 f 790 "21 790" 100 0 0 100	int2_mul_cash - ));
 DESCR("multiply");
 DATA(insert OID =  864 (  cash_mul_int4		   PGUID 11 f t t t 2 f 790 "790 23" 100 0 0 100	cash_mul_int4 - ));
 DESCR("multiply");
 DATA(insert OID =  865 (  cash_div_int4		   PGUID 11 f t t t 2 f 790 "790 23" 100 0 0 100	cash_div_int4 - ));
 DESCR("divide");
-DATA(insert OID =  866 (  cash_mul_int2		   PGUID 11 f t t t 2 f 790 "790 21" 100 0 0 100	cash_mul_int2 - ));
+DATA(insert OID =  866 (  cash_mul_int2		   PGUID 12 f t t t 2 f 790 "790 21" 100 0 0 100	cash_mul_int2 - ));
 DESCR("multiply");
-DATA(insert OID =  867 (  cash_div_int2		   PGUID 11 f t t t 2 f 790 "790 21" 100 0 0 100	cash_div_int2 - ));
+DATA(insert OID =  867 (  cash_div_int2		   PGUID 12 f t t t 2 f 790 "790 21" 100 0 0 100	cash_div_int2 - ));
 DESCR("divide");
 
 DATA(insert OID =  886 (  cash_in		   PGUID 11 f t t t 1 f 790 "0" 100 0 0 100  cash_in - ));
@@ -1178,13 +1178,13 @@ DESCR("");
 DATA(insert OID = 939 (  revertpoly		   PGUID 11 f t f t 1 f 604 "604" 100 0 0 100  revertpoly - ));
 DESCR("");
 
-DATA(insert OID = 940 (  mod			   PGUID 11 f t t t 2 f 21 "21 21" 100 0 0 100  int2mod - ));
+DATA(insert OID = 940 (  mod			   PGUID 12 f t t t 2 f 21 "21 21" 100 0 0 100  int2mod - ));
 DESCR("modulus");
-DATA(insert OID = 941 (  mod			   PGUID 11 f t t t 2 f 23 "23 23" 100 0 0 100  int4mod - ));
+DATA(insert OID = 941 (  mod			   PGUID 12 f t t t 2 f 23 "23 23" 100 0 0 100  int4mod - ));
 DESCR("modulus");
-DATA(insert OID = 942 (  mod			   PGUID 11 f t t t 2 f 23 "21 23" 100 0 0 100  int24mod - ));
+DATA(insert OID = 942 (  mod			   PGUID 12 f t t t 2 f 23 "21 23" 100 0 0 100  int24mod - ));
 DESCR("modulus");
-DATA(insert OID = 943 (  mod			   PGUID 11 f t t t 2 f 23 "23 21" 100 0 0 100  int42mod - ));
+DATA(insert OID = 943 (  mod			   PGUID 12 f t t t 2 f 23 "23 21" 100 0 0 100  int42mod - ));
 DESCR("modulus");
 
 DATA(insert OID = 945 (  int8mod		   PGUID 11 f t t t 2 f 20 "20 20" 100 0 0 100  int8mod - ));
@@ -1192,17 +1192,17 @@ DESCR("modulus");
 DATA(insert OID = 947 (  mod			   PGUID 11 f t t t 2 f 20 "20 20" 100 0 0 100  int8mod - ));
 DESCR("modulus");
 
-DATA(insert OID = 944 (  char			   PGUID 11 f t t t 1 f 18 "25" 100 0 0 100  text_char - ));
+DATA(insert OID = 944 (  char			   PGUID 12 f t t t 1 f 18 "25" 100 0 0 100  text_char - ));
 DESCR("convert text to char");
-DATA(insert OID = 946 (  text			   PGUID 11 f t t t 1 f 25 "18" 100 0 0 100  char_text - ));
+DATA(insert OID = 946 (  text			   PGUID 12 f t t t 1 f 25 "18" 100 0 0 100  char_text - ));
 DESCR("convert char to text");
-DATA(insert OID = 948 (  varchar		   PGUID 11 f t t t 1 f 25 "1043" 100 0 0 100  bpchar_char - ));
+DATA(insert OID = 948 (  varchar		   PGUID 12 f t t t 1 f 25 "1043" 100 0 0 100  bpchar_char - ));
 DESCR("convert varchar() to text");
 
-DATA(insert OID = 950 (  istrue			   PGUID 11 f t t t 1 f 16 "16" 100 0 0 100  istrue - ));
-DESCR("");
-DATA(insert OID = 951 (  isfalse		   PGUID 11 f t t t 1 f 16 "16" 100 0 0 100  isfalse - ));
-DESCR("");
+DATA(insert OID = 950 (  istrue			   PGUID 12 f t t f 1 f 16 "16" 100 0 0 100  istrue - ));
+DESCR("bool is true (not false or unknown)");
+DATA(insert OID = 951 (  isfalse		   PGUID 12 f t t f 1 f 16 "16" 100 0 0 100  isfalse - ));
+DESCR("bool is false (not true or unknown)");
 
 DATA(insert OID = 952 (  lo_open		   PGUID 11 f t f t 2 f 23 "26 23" 100 0 0 100  lo_open - ));
 DESCR("large object open");
@@ -1232,7 +1232,7 @@ DESCR("closest point to line on box");
 
 DATA(insert OID = 964 (  lo_unlink		   PGUID 11 f t f t 1 f  23 "26" 100 0 0 100	lo_unlink - ));
 DESCR("large object unlink(delete)");
-DATA(insert OID = 972 (  regproctooid	   PGUID 11 f t t t 1 f  26 "24" 100 0 0 100	regproctooid - ));
+DATA(insert OID = 972 (  regproctooid	   PGUID 12 f t t t 1 f  26 "24" 100 0 0 100	regproctooid - ));
 DESCR("get oid for regproc");
 
 DATA(insert OID = 973 (  path_inter		   PGUID 11 f t t t 2 f  16 "602 602" 100 0 10 100  path_inter - ));
@@ -1288,9 +1288,9 @@ DESCR("equal");
 
 /* OIDS 1000 - 1999 */
 
-DATA(insert OID = 1029 (  nullvalue		   PGUID 11 f t t f 1 f 16 "0" 100 0 0 100  nullvalue - ));
+DATA(insert OID = 1029 (  nullvalue		   PGUID 12 f t t f 1 f 16 "0" 100 0 0 100  nullvalue - ));
 DESCR("(internal)");
-DATA(insert OID = 1030 (  nonnullvalue	   PGUID 11 f t t f 1 f 16 "0" 100 0 0 100  nonnullvalue - ));
+DATA(insert OID = 1030 (  nonnullvalue	   PGUID 12 f t t f 1 f 16 "0" 100 0 0 100  nonnullvalue - ));
 DESCR("(internal)");
 DATA(insert OID = 1031 (  aclitemin		   PGUID 11 f t f t 1 f 1033 "0" 100 0 0 100	aclitemin - ));
 DESCR("(internal)");
@@ -1517,9 +1517,9 @@ DESCR("matches regex., case-insensitive");
 DATA(insert OID = 1241 (  nameicregexne    PGUID 11 f t t t 2 f 16 "19 25" 100 0 0 100  nameicregexne - ));
 DESCR("does not match regex., case-insensitive");
 
-DATA(insert OID = 1251 (  int4abs		   PGUID 11 f t t t 1 f 23 "23" 100 0 0 100  int4abs - ));
+DATA(insert OID = 1251 (  int4abs		   PGUID 12 f t t t 1 f 23 "23" 100 0 0 100  int4abs - ));
 DESCR("absolute value");
-DATA(insert OID = 1253 (  int2abs		   PGUID 11 f t t t 1 f 21 "21" 100 0 0 100  int2abs - ));
+DATA(insert OID = 1253 (  int2abs		   PGUID 12 f t t t 1 f 21 "21" 100 0 0 100  int2abs - ));
 DESCR("absolute value");
 
 DATA(insert OID = 1263 (  interval		   PGUID 11 f t f t 1 f 1186 "25" 100 0 0 100  text_interval - ));
@@ -1575,13 +1575,13 @@ DESCR("current transaction time");
 
 /* OIDS 1300 - 1399 */
 
-DATA(insert OID = 1300 (  positionsel		   PGUID 11 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100  positionsel - ));
+DATA(insert OID = 1300 (  positionsel		   PGUID 12 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100  positionsel - ));
 DESCR("restriction selectivity for position-comparison operators");
-DATA(insert OID = 1301 (  positionjoinsel	   PGUID 11 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100	positionjoinsel - ));
+DATA(insert OID = 1301 (  positionjoinsel	   PGUID 12 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100	positionjoinsel - ));
 DESCR("join selectivity for position-comparison operators");
-DATA(insert OID = 1302 (  contsel		   PGUID 11 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100  contsel - ));
+DATA(insert OID = 1302 (  contsel		   PGUID 12 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100  contsel - ));
 DESCR("restriction selectivity for containment comparison operators");
-DATA(insert OID = 1303 (  contjoinsel	   PGUID 11 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100	contjoinsel - ));
+DATA(insert OID = 1303 (  contjoinsel	   PGUID 12 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100	contjoinsel - ));
 DESCR("join selectivity for containment comparison operators");
 
 DATA(insert OID = 1304 ( overlaps			 PGUID 11 f t t t 4 f 16 "1184 1184 1184 1184" 100 0 1 0	overlaps_timestamp - ));
@@ -1640,7 +1640,7 @@ DESCR("exponential");
 
 DATA(insert OID = 1348 (  obj_description	 PGUID 14 f t f t 1 f   25 "26" 100 0 0 100  "select description from pg_description where objoid = $1" - ));
 DESCR("get description for object id");
-DATA(insert OID = 1349 (  oidvectortypes	 PGUID 11 f t f t 1 f   25 "30" 100 0 0 100  oidvectortypes - ));
+DATA(insert OID = 1349 (  oidvectortypes	 PGUID 12 f t f t 1 f   25 "30" 100 0 0 100  oidvectortypes - ));
 DESCR("print type names of oidvector field");
 
 
@@ -1727,9 +1727,9 @@ DATA(insert OID = 1390 (  isfinite	   PGUID 11 f t f t 1 f	16 "1186" 100 0 0 100
 DESCR("boolean test");
 
 
-DATA(insert OID = 1391 (  factorial		   PGUID 11 f t t t 1 f 23 "21" 100 0 0 100  int2fac - ));
+DATA(insert OID = 1391 (  factorial		   PGUID 12 f t t t 1 f 23 "21" 100 0 0 100  int2fac - ));
 DESCR("factorial");
-DATA(insert OID = 1392 (  factorial		   PGUID 11 f t t t 1 f 23 "23" 100 0 0 100  int4fac - ));
+DATA(insert OID = 1392 (  factorial		   PGUID 12 f t t t 1 f 23 "23" 100 0 0 100  int4fac - ));
 DESCR("factorial");
 DATA(insert OID = 1393 (  factorial		   PGUID 11 f t t t 1 f 20 "20" 100 0 0 100  int8fac - ));
 DESCR("factorial");
@@ -1739,9 +1739,9 @@ DATA(insert OID = 1395 (  abs			   PGUID 11 f t t t 1 f 701 "701" 100 0 0 100  f
 DESCR("absolute value");
 DATA(insert OID = 1396 (  abs			   PGUID 11 f t t t 1 f 20 "20" 100 0 0 100  int8abs - ));
 DESCR("absolute value");
-DATA(insert OID = 1397 (  abs			   PGUID 11 f t t t 1 f 23 "23" 100 0 0 100  int4abs - ));
+DATA(insert OID = 1397 (  abs			   PGUID 12 f t t t 1 f 23 "23" 100 0 0 100  int4abs - ));
 DESCR("absolute value");
-DATA(insert OID = 1398 (  abs			   PGUID 11 f t t t 1 f 21 "21" 100 0 0 100  int2abs - ));
+DATA(insert OID = 1398 (  abs			   PGUID 12 f t t t 1 f 21 "21" 100 0 0 100  int2abs - ));
 DESCR("absolute value");
 
 /* OIDS 1400 - 1499 */
@@ -1783,6 +1783,11 @@ DESCR("lines horizontal?");
 DATA(insert OID = 1416 (  point				PGUID 11 f t t t 1 f 600 "718" 100 0 1 0	circle_center - ));
 DESCR("center of");
 
+DATA(insert OID = 1417 (  isnottrue			PGUID 12 f t t f 1 f 16 "16" 100 0 0 100  isnottrue - ));
+DESCR("bool is not true (ie, false or unknown)");
+DATA(insert OID = 1418 (  isnotfalse		PGUID 12 f t t f 1 f 16 "16" 100 0 0 100  isnotfalse - ));
+DESCR("bool is not false (ie, true or unknown)");
+
 DATA(insert OID = 1421 (  box				PGUID 11 f t t t 2 f 603 "600 600" 100 0 0 100  box - ));
 DESCR("convert points to box");
 DATA(insert OID = 1422 (  box_add			PGUID 11 f t t t 2 f 603 "603 600" 100 0 0 100  box_add - ));
@@ -2057,7 +2062,7 @@ DESCR("PI");
 
 DATA(insert OID = 1618 (  interval_mul		PGUID 11 f t t t 2 f 1186 "1186 701" 100 0 0 100	interval_mul - ));
 DESCR("multiply interval");
-DATA(insert OID = 1619 (  varchar			PGUID 11 f t t t 1 f 1043 "23" 100 0 0 100  int4_text - ));
+DATA(insert OID = 1619 (  varchar			PGUID 12 f t t t 1 f 1043 "23" 100 0 0 100  int4_text - ));
 DESCR("convert int4 to varchar");
 
 DATA(insert OID = 1620 (  ascii				PGUID 11 f t t t 1 f 23 "25" 100 0 0 100	ascii - ));
@@ -2308,11 +2313,11 @@ DESCR("host address");
 DATA(insert OID = 683 (  network				PGUID 11 f t t t 1 f 25 "869" 100 0 0 100  network_network - ));
 DESCR("network address");
 
-DATA(insert OID =  1691 (  boolle			   PGUID 11 f t t t 2 f 16 "16 16" 100 0 0 100  boolle - ));
+DATA(insert OID =  1691 (  boolle			   PGUID 12 f t t t 2 f 16 "16 16" 100 0 0 100  boolle - ));
 DESCR("less-than-or-equal");
-DATA(insert OID =  1692 (  boolge			   PGUID 11 f t t t 2 f 16 "16 16" 100 0 0 100  boolge - ));
+DATA(insert OID =  1692 (  boolge			   PGUID 12 f t t t 2 f 16 "16 16" 100 0 0 100  boolge - ));
 DESCR("greater-than-or-equal");
-DATA(insert OID = 1693 (  btboolcmp			   PGUID 11 f t t t 2 f 23 "16 16" 100 0 0 100  btboolcmp - ));
+DATA(insert OID = 1693 (  btboolcmp			   PGUID 12 f t t t 2 f 23 "16 16" 100 0 0 100  btboolcmp - ));
 DESCR("btree less-equal-greater");
 
 /* OID's 1700 - 1799 NUMERIC data type */
@@ -2414,9 +2419,9 @@ DATA(insert OID = 1779 ( int8					PGUID 11 f t t t 1 f 20 "1700" 100 0 0 100  nu
 DESCR("(internal)");
 DATA(insert OID = 1781 ( numeric				PGUID 11 f t t t 1 f 1700 "20" 100 0 0 100  int8_numeric - ));
 DESCR("(internal)");
-DATA(insert OID = 1782 ( numeric				PGUID 11 f t t t 1 f 1700 "21" 100 0 0 100  int2_numeric - ));
+DATA(insert OID = 1782 ( numeric				PGUID 12 f t t t 1 f 1700 "21" 100 0 0 100  int2_numeric - ));
 DESCR("(internal)");
-DATA(insert OID = 1783 ( int2					PGUID 11 f t t t 1 f 21 "1700" 100 0 0 100  numeric_int2 - ));
+DATA(insert OID = 1783 ( int2					PGUID 12 f t t t 1 f 21 "1700" 100 0 0 100  numeric_int2 - ));
 DESCR("(internal)");
 
 /* formatting */
@@ -2439,30 +2444,35 @@ DESCR("convert text to timestamp");
 DATA(insert OID = 1780 ( to_date			PGUID 11 f t f t 2 f	1082 "25 25" 100 0 0 100  to_date - ));
 DESCR("convert text to date");
 
+DATA(insert OID = 1798 (  oidin			   PGUID 12 f t t t 1 f 26 "0" 100 0 0 100  oidin - ));
+DESCR("(internal)");
+DATA(insert OID = 1799 (  oidout		   PGUID 12 f t t t 1 f 23 "0" 100 0 0 100  oidout - ));
+DESCR("(internal)");
+
 /* Selectivity estimators for LIKE and related operators */
-DATA(insert OID = 1818 ( regexeqsel			PGUID 11 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100  regexeqsel - ));
+DATA(insert OID = 1818 ( regexeqsel			PGUID 12 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100  regexeqsel - ));
 DESCR("restriction selectivity of regex match");
-DATA(insert OID = 1819 ( likesel			PGUID 11 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100  likesel - ));
+DATA(insert OID = 1819 ( likesel			PGUID 12 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100  likesel - ));
 DESCR("restriction selectivity of LIKE");
-DATA(insert OID = 1820 ( icregexeqsel		PGUID 11 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100  icregexeqsel - ));
+DATA(insert OID = 1820 ( icregexeqsel		PGUID 12 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100  icregexeqsel - ));
 DESCR("restriction selectivity of case-insensitive regex match");
-DATA(insert OID = 1821 ( regexnesel			PGUID 11 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100  regexnesel - ));
+DATA(insert OID = 1821 ( regexnesel			PGUID 12 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100  regexnesel - ));
 DESCR("restriction selectivity of regex non-match");
-DATA(insert OID = 1822 ( nlikesel			PGUID 11 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100  nlikesel - ));
+DATA(insert OID = 1822 ( nlikesel			PGUID 12 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100  nlikesel - ));
 DESCR("restriction selectivity of NOT LIKE");
-DATA(insert OID = 1823 ( icregexnesel		PGUID 11 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100  icregexnesel - ));
+DATA(insert OID = 1823 ( icregexnesel		PGUID 12 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100  icregexnesel - ));
 DESCR("restriction selectivity of case-insensitive regex non-match");
-DATA(insert OID = 1824 ( regexeqjoinsel		PGUID 11 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100	regexeqjoinsel - ));
+DATA(insert OID = 1824 ( regexeqjoinsel		PGUID 12 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100	regexeqjoinsel - ));
 DESCR("join selectivity of regex match");
-DATA(insert OID = 1825 ( likejoinsel		PGUID 11 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100	likejoinsel - ));
+DATA(insert OID = 1825 ( likejoinsel		PGUID 12 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100	likejoinsel - ));
 DESCR("join selectivity of LIKE");
-DATA(insert OID = 1826 ( icregexeqjoinsel	PGUID 11 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100	icregexeqjoinsel - ));
+DATA(insert OID = 1826 ( icregexeqjoinsel	PGUID 12 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100	icregexeqjoinsel - ));
 DESCR("join selectivity of case-insensitive regex match");
-DATA(insert OID = 1827 ( regexnejoinsel		PGUID 11 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100	regexnejoinsel - ));
+DATA(insert OID = 1827 ( regexnejoinsel		PGUID 12 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100	regexnejoinsel - ));
 DESCR("join selectivity of regex non-match");
-DATA(insert OID = 1828 ( nlikejoinsel		PGUID 11 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100	nlikejoinsel - ));
+DATA(insert OID = 1828 ( nlikejoinsel		PGUID 12 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100	nlikejoinsel - ));
 DESCR("join selectivity of NOT LIKE");
-DATA(insert OID = 1829 ( icregexnejoinsel	PGUID 11 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100	icregexnejoinsel - ));
+DATA(insert OID = 1829 ( icregexnejoinsel	PGUID 12 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100	icregexnejoinsel - ));
 DESCR("join selectivity of case-insensitive regex non-match");
 
 
diff --git a/src/include/catalog/pg_type.h b/src/include/catalog/pg_type.h
index 3f8665ebe1..ce9ba3b474 100644
--- a/src/include/catalog/pg_type.h
+++ b/src/include/catalog/pg_type.h
@@ -8,7 +8,7 @@
  * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: pg_type.h,v 1.88 2000/04/12 17:16:29 momjian Exp $
+ * $Id: pg_type.h,v 1.89 2000/06/05 07:29:01 tgl Exp $
  *
  * NOTES
  *	  the genbki.sh script reads this file and generates .bki
@@ -191,7 +191,7 @@ DATA(insert OID = 25 (	text	   PGUID -1  -1 f b t \054 0  18 textin textout text
 DESCR("variable-length string, no limit specified");
 #define TEXTOID			25
 
-DATA(insert OID = 26 (	oid		   PGUID  4  10 t b t \054 0   0 int4in int4out int4in int4out i _null_ ));
+DATA(insert OID = 26 (	oid		   PGUID  4  10 t b t \054 0   0 oidin oidout oidin oidout i _null_ ));
 DESCR("object identifier(oid), maximum 4 billion");
 #define OIDOID			26
 
@@ -214,21 +214,21 @@ DESCR("array of INDEX_MAX_KEYS oids, used in system tables");
 DATA(insert OID = 32 (	SET		   PGUID -1  -1 f b t \054 0   0 textin textout textin textout i _null_ ));
 DESCR("set of tuples");
 
-DATA(insert OID = 71 (	pg_type		 PGUID 4 4 t c t \054 1247 0 foo bar foo bar i _null_));
-DATA(insert OID = 75 (	pg_attribute PGUID 4 4 t c t \054 1249 0 foo bar foo bar i _null_));
-DATA(insert OID = 81 (	pg_proc		 PGUID 4 4 t c t \054 1255 0 foo bar foo bar i _null_));
-DATA(insert OID = 83 (	pg_class	 PGUID 4 4 t c t \054 1259 0 foo bar foo bar i _null_));
-DATA(insert OID = 86 (	pg_shadow	 PGUID 4 4 t c t \054 1260 0 foo bar foo bar i _null_));
-DATA(insert OID = 87 (	pg_group	 PGUID 4 4 t c t \054 1261 0 foo bar foo bar i _null_));
-DATA(insert OID = 88 (	pg_database  PGUID 4 4 t c t \054 1262 0 foo bar foo bar i _null_));
-DATA(insert OID = 90 (	pg_variable  PGUID 4 4 t c t \054 1264 0 foo bar foo bar i _null_));
-DATA(insert OID = 99 (	pg_log		 PGUID 4 4 t c t \054 1269 0 foo bar foo bar i _null_));
+DATA(insert OID = 71 (	pg_type		 PGUID 4 4 t c t \054 1247 0 int4in int4out int4in int4out i _null_));
+DATA(insert OID = 75 (	pg_attribute PGUID 4 4 t c t \054 1249 0 int4in int4out int4in int4out i _null_));
+DATA(insert OID = 81 (	pg_proc		 PGUID 4 4 t c t \054 1255 0 int4in int4out int4in int4out i _null_));
+DATA(insert OID = 83 (	pg_class	 PGUID 4 4 t c t \054 1259 0 int4in int4out int4in int4out i _null_));
+DATA(insert OID = 86 (	pg_shadow	 PGUID 4 4 t c t \054 1260 0 int4in int4out int4in int4out i _null_));
+DATA(insert OID = 87 (	pg_group	 PGUID 4 4 t c t \054 1261 0 int4in int4out int4in int4out i _null_));
+DATA(insert OID = 88 (	pg_database  PGUID 4 4 t c t \054 1262 0 int4in int4out int4in int4out i _null_));
+DATA(insert OID = 90 (	pg_variable  PGUID 4 4 t c t \054 1264 0 int4in int4out int4in int4out i _null_));
+DATA(insert OID = 99 (	pg_log		 PGUID 4 4 t c t \054 1269 0 int4in int4out int4in int4out i _null_));
 
 /* OIDS 100 - 199 */
 
-DATA(insert OID = 109 (  pg_attrdef  PGUID 4 4 t c t \054 1215 0 foo bar foo bar i _null_));
-DATA(insert OID = 110 (  pg_relcheck PGUID 4 4 t c t \054 1216 0 foo bar foo bar i _null_));
-DATA(insert OID = 111 (  pg_trigger  PGUID 4 4 t c t \054 1219 0 foo bar foo bar i _null_));
+DATA(insert OID = 109 (  pg_attrdef  PGUID 4 4 t c t \054 1215 0 int4in int4out int4in int4out i _null_));
+DATA(insert OID = 110 (  pg_relcheck PGUID 4 4 t c t \054 1216 0 int4in int4out int4in int4out i _null_));
+DATA(insert OID = 111 (  pg_trigger  PGUID 4 4 t c t \054 1219 0 int4in int4out int4in int4out i _null_));
 
 /* OIDS 200 - 299 */
 
diff --git a/src/include/fmgr.h b/src/include/fmgr.h
index fadb09d24e..6bbab9676c 100644
--- a/src/include/fmgr.h
+++ b/src/include/fmgr.h
@@ -11,7 +11,7 @@
  * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: fmgr.h,v 1.3 2000/05/30 04:24:56 tgl Exp $
+ * $Id: fmgr.h,v 1.4 2000/06/05 07:29:02 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -101,12 +101,15 @@ extern void fmgr_info(Oid functionId, FmgrInfo *finfo);
 
 /* Macros for fetching arguments of standard types */
 
+#define PG_GETARG_DATUM(n)   (fcinfo->arg[n])
 #define PG_GETARG_INT32(n)   DatumGetInt32(fcinfo->arg[n])
+#define PG_GETARG_UINT32(n)  DatumGetUInt32(fcinfo->arg[n])
 #define PG_GETARG_INT16(n)   DatumGetInt16(fcinfo->arg[n])
 #define PG_GETARG_CHAR(n)    DatumGetChar(fcinfo->arg[n])
 #define PG_GETARG_BOOL(n)    DatumGetBool(fcinfo->arg[n])
 #define PG_GETARG_OID(n)     DatumGetObjectId(fcinfo->arg[n])
 #define PG_GETARG_POINTER(n) DatumGetPointer(fcinfo->arg[n])
+#define PG_GETARG_CSTRING(n) DatumGetCString(fcinfo->arg[n])
 #define PG_GETARG_NAME(n)    DatumGetName(fcinfo->arg[n])
 /* these macros hide the pass-by-reference-ness of the datatype: */
 #define PG_GETARG_FLOAT4(n)  DatumGetFloat4(fcinfo->arg[n])
@@ -115,10 +118,16 @@ extern void fmgr_info(Oid functionId, FmgrInfo *finfo);
 /* use this if you want the raw, possibly-toasted input datum: */
 #define PG_GETARG_RAW_VARLENA_P(n)  ((struct varlena *) PG_GETARG_POINTER(n))
 /* use this if you want the input datum de-toasted: */
+#if 1
+/* VERY TEMPORARY until some TOAST support is committed ... */
+#define PG_GETARG_VARLENA_P(n)  PG_GETARG_RAW_VARLENA_P(n)
+#else
+/* Eventually it will look more like this... */
 #define PG_GETARG_VARLENA_P(n)  \
 	(VARATT_IS_EXTENDED(PG_GETARG_RAW_VARLENA_P(n)) ?  \
 	 (struct varlena *) heap_tuple_untoast_attr((varattrib *) PG_GETARG_RAW_VARLENA_P(n)) :  \
 	 PG_GETARG_RAW_VARLENA_P(n))
+#endif
 /* GETARG macros for varlena types will typically look like this: */
 #define PG_GETARG_TEXT_P(n) ((text *) PG_GETARG_VARLENA_P(n))
 
@@ -129,11 +138,13 @@ extern void fmgr_info(Oid functionId, FmgrInfo *finfo);
 /* Macros for returning results of standard types */
 
 #define PG_RETURN_INT32(x)   return Int32GetDatum(x)
+#define PG_RETURN_UINT32(x)  return UInt32GetDatum(x)
 #define PG_RETURN_INT16(x)   return Int16GetDatum(x)
 #define PG_RETURN_CHAR(x)    return CharGetDatum(x)
 #define PG_RETURN_BOOL(x)    return BoolGetDatum(x)
 #define PG_RETURN_OID(x)     return ObjectIdGetDatum(x)
 #define PG_RETURN_POINTER(x) return PointerGetDatum(x)
+#define PG_RETURN_CSTRING(x) return CStringGetDatum(x)
 #define PG_RETURN_NAME(x)    return NameGetDatum(x)
 /* these macros hide the pass-by-reference-ness of the datatype: */
 #define PG_RETURN_FLOAT4(x)  return Float4GetDatum(x)
@@ -242,57 +253,19 @@ extern PGFunction load_external_function(char *filename, char *funcname);
 extern void load_file(char *filename);
 
 
-/*-------------------------------------------------------------------------
- *
+/*
  * !!! OLD INTERFACE !!!
  *
- * All the definitions below here are associated with the old fmgr API.
- * They will go away as soon as we have converted all call points to use
- * the new API.  Note that old-style callee functions do not depend on
- * these definitions, so we don't need to have converted all of them before
- * dropping the old API ... just all the old-style call points.
- *
- *-------------------------------------------------------------------------
+ * fmgr() is the only remaining vestige of the old-style caller support
+ * functions.  It's no longer used anywhere in the Postgres distribution,
+ * but we should leave it around for a release or two to ease the transition
+ * for user-supplied C functions.  OidFunctionCallN() replaces it for new
+ * code.
  */
 
-/* ptr to func returning (char *) */
-#if defined(__mc68000__) && defined(__ELF__)
-/* The m68k SVR4 ABI defines that pointers are returned in %a0 instead of
- * %d0. So if a function pointer is declared to return a pointer, the
- * compiler may look only into %a0, but if the called function was declared
- * to return return an integer type, it puts its value only into %d0. So the
- * caller doesn't pink up the correct return value. The solution is to
- * declare the function pointer to return int, so the compiler picks up the
- * return value from %d0. (Functions returning pointers put their value
- * *additionally* into %d0 for compability.) The price is that there are
- * some warnings about int->pointer conversions...
- */
-typedef int32 ((*func_ptr) ());
-#else
-typedef char *((*func_ptr) ());
-#endif
-
-#if 0
-
-typedef struct {
-    char *data[FUNC_MAX_ARGS];
-} FmgrValues;
-
 /*
- * defined in fmgr.c
+ * DEPRECATED, DO NOT USE IN NEW CODE
  */
 extern char *fmgr(Oid procedureId, ... );
-extern char *fmgr_faddr_link(char *arg0, ...);
-
-/*
- *	Macros for calling through the result of fmgr_info.
- */
-
-/* We don't make this static so fmgr_faddr() macro can access it */
-extern FmgrInfo        *fmgr_pl_finfo;
-
-#define fmgr_faddr(finfo) (fmgr_pl_finfo = (finfo), (func_ptr) fmgr_faddr_link)
-
-#endif
 
 #endif	/* FMGR_H */
diff --git a/src/include/storage/smgr.h b/src/include/storage/smgr.h
index 64702ffe70..e9f8824f55 100644
--- a/src/include/storage/smgr.h
+++ b/src/include/storage/smgr.h
@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: smgr.h,v 1.20 2000/04/12 17:16:52 momjian Exp $
+ * $Id: smgr.h,v 1.21 2000/06/05 07:29:06 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -100,9 +100,9 @@ extern int	mmshutdown(void);
 extern int	MMShmemSize(void);
 
 /* smgrtype.c */
-extern char *smgrout(int2 i);
-extern int2 smgrin(char *s);
-extern bool smgreq(int2 a, int2 b);
-extern bool smgrne(int2 a, int2 b);
+extern Datum smgrout(PG_FUNCTION_ARGS);
+extern Datum smgrin(PG_FUNCTION_ARGS);
+extern Datum smgreq(PG_FUNCTION_ARGS);
+extern Datum smgrne(PG_FUNCTION_ARGS);
 
 #endif	 /* SMGR_H */
diff --git a/src/include/utils/builtins.h b/src/include/utils/builtins.h
index 051a155a83..6dc9aa8165 100644
--- a/src/include/utils/builtins.h
+++ b/src/include/utils/builtins.h
@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: builtins.h,v 1.112 2000/05/29 01:59:13 tgl Exp $
+ * $Id: builtins.h,v 1.113 2000/06/05 07:29:07 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -33,108 +33,110 @@
  *		Defined in adt/
  */
 /* bool.c */
-extern bool boolin(char *b);
-extern char *boolout(bool b);
-extern bool booleq(bool arg1, bool arg2);
-extern bool boolne(bool arg1, bool arg2);
-extern bool boollt(bool arg1, bool arg2);
-extern bool boolgt(bool arg1, bool arg2);
-extern bool boolle(bool arg1, bool arg2);
-extern bool boolge(bool arg1, bool arg2);
-extern bool istrue(bool arg1);
-extern bool isfalse(bool arg1);
+extern Datum boolin(PG_FUNCTION_ARGS);
+extern Datum boolout(PG_FUNCTION_ARGS);
+extern Datum booleq(PG_FUNCTION_ARGS);
+extern Datum boolne(PG_FUNCTION_ARGS);
+extern Datum boollt(PG_FUNCTION_ARGS);
+extern Datum boolgt(PG_FUNCTION_ARGS);
+extern Datum boolle(PG_FUNCTION_ARGS);
+extern Datum boolge(PG_FUNCTION_ARGS);
+extern Datum istrue(PG_FUNCTION_ARGS);
+extern Datum isfalse(PG_FUNCTION_ARGS);
+extern Datum isnottrue(PG_FUNCTION_ARGS);
+extern Datum isnotfalse(PG_FUNCTION_ARGS);
 
 /* char.c */
-extern int32 charin(char *ch);
-extern char *charout(int32 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 int8 text_char(text *arg1);
-extern text *char_text(int8 arg1);
+extern Datum charin(PG_FUNCTION_ARGS);
+extern Datum charout(PG_FUNCTION_ARGS);
+extern Datum chareq(PG_FUNCTION_ARGS);
+extern Datum charne(PG_FUNCTION_ARGS);
+extern Datum charlt(PG_FUNCTION_ARGS);
+extern Datum charle(PG_FUNCTION_ARGS);
+extern Datum chargt(PG_FUNCTION_ARGS);
+extern Datum charge(PG_FUNCTION_ARGS);
+extern Datum charpl(PG_FUNCTION_ARGS);
+extern Datum charmi(PG_FUNCTION_ARGS);
+extern Datum charmul(PG_FUNCTION_ARGS);
+extern Datum chardiv(PG_FUNCTION_ARGS);
+extern Datum text_char(PG_FUNCTION_ARGS);
+extern Datum char_text(PG_FUNCTION_ARGS);
+extern Datum cidin(PG_FUNCTION_ARGS);
+extern Datum cidout(PG_FUNCTION_ARGS);
+extern Datum cideq(PG_FUNCTION_ARGS);
 
 /* int.c */
-extern int32 int2in(char *num);
-extern char *int2out(int16 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 int16 text_int2(text *arg1);
-extern text *int4_text(int32 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 Datum int2in(PG_FUNCTION_ARGS);
+extern Datum int2out(PG_FUNCTION_ARGS);
+extern Datum int2vectorin(PG_FUNCTION_ARGS);
+extern Datum int2vectorout(PG_FUNCTION_ARGS);
+extern Datum int2vectoreq(PG_FUNCTION_ARGS);
+extern Datum int44in(PG_FUNCTION_ARGS);
+extern Datum int44out(PG_FUNCTION_ARGS);
+extern Datum int4in(PG_FUNCTION_ARGS);
+extern Datum int4out(PG_FUNCTION_ARGS);
+extern Datum i2toi4(PG_FUNCTION_ARGS);
+extern Datum i4toi2(PG_FUNCTION_ARGS);
+extern Datum int2_text(PG_FUNCTION_ARGS);
+extern Datum text_int2(PG_FUNCTION_ARGS);
+extern Datum int4_text(PG_FUNCTION_ARGS);
+extern Datum text_int4(PG_FUNCTION_ARGS);
+extern Datum int4eq(PG_FUNCTION_ARGS);
+extern Datum int4ne(PG_FUNCTION_ARGS);
+extern Datum int4lt(PG_FUNCTION_ARGS);
+extern Datum int4le(PG_FUNCTION_ARGS);
+extern Datum int4gt(PG_FUNCTION_ARGS);
+extern Datum int4ge(PG_FUNCTION_ARGS);
+extern Datum int2eq(PG_FUNCTION_ARGS);
+extern Datum int2ne(PG_FUNCTION_ARGS);
+extern Datum int2lt(PG_FUNCTION_ARGS);
+extern Datum int2le(PG_FUNCTION_ARGS);
+extern Datum int2gt(PG_FUNCTION_ARGS);
+extern Datum int2ge(PG_FUNCTION_ARGS);
+extern Datum int24eq(PG_FUNCTION_ARGS);
+extern Datum int24ne(PG_FUNCTION_ARGS);
+extern Datum int24lt(PG_FUNCTION_ARGS);
+extern Datum int24le(PG_FUNCTION_ARGS);
+extern Datum int24gt(PG_FUNCTION_ARGS);
+extern Datum int24ge(PG_FUNCTION_ARGS);
+extern Datum int42eq(PG_FUNCTION_ARGS);
+extern Datum int42ne(PG_FUNCTION_ARGS);
+extern Datum int42lt(PG_FUNCTION_ARGS);
+extern Datum int42le(PG_FUNCTION_ARGS);
+extern Datum int42gt(PG_FUNCTION_ARGS);
+extern Datum int42ge(PG_FUNCTION_ARGS);
+extern Datum int4um(PG_FUNCTION_ARGS);
+extern Datum int4pl(PG_FUNCTION_ARGS);
+extern Datum int4mi(PG_FUNCTION_ARGS);
+extern Datum int4mul(PG_FUNCTION_ARGS);
+extern Datum int4div(PG_FUNCTION_ARGS);
+extern Datum int4abs(PG_FUNCTION_ARGS);
+extern Datum int4inc(PG_FUNCTION_ARGS);
+extern Datum int2um(PG_FUNCTION_ARGS);
+extern Datum int2pl(PG_FUNCTION_ARGS);
+extern Datum int2mi(PG_FUNCTION_ARGS);
+extern Datum int2mul(PG_FUNCTION_ARGS);
+extern Datum int2div(PG_FUNCTION_ARGS);
+extern Datum int2abs(PG_FUNCTION_ARGS);
+extern Datum int2inc(PG_FUNCTION_ARGS);
+extern Datum int24pl(PG_FUNCTION_ARGS);
+extern Datum int24mi(PG_FUNCTION_ARGS);
+extern Datum int24mul(PG_FUNCTION_ARGS);
+extern Datum int24div(PG_FUNCTION_ARGS);
+extern Datum int42pl(PG_FUNCTION_ARGS);
+extern Datum int42mi(PG_FUNCTION_ARGS);
+extern Datum int42mul(PG_FUNCTION_ARGS);
+extern Datum int42div(PG_FUNCTION_ARGS);
+extern Datum int4mod(PG_FUNCTION_ARGS);
+extern Datum int2mod(PG_FUNCTION_ARGS);
+extern Datum int24mod(PG_FUNCTION_ARGS);
+extern Datum int42mod(PG_FUNCTION_ARGS);
+extern Datum int4fac(PG_FUNCTION_ARGS);
+extern Datum int2fac(PG_FUNCTION_ARGS);
+extern Datum int2larger(PG_FUNCTION_ARGS);
+extern Datum int2smaller(PG_FUNCTION_ARGS);
+extern Datum int4larger(PG_FUNCTION_ARGS);
+extern Datum int4smaller(PG_FUNCTION_ARGS);
 
 /* name.c */
 extern NameData *namein(const char *s);
@@ -168,20 +170,20 @@ extern void ltoa(int32 l, char *a);
  *		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 btint8cmp(int64 *a, int64 *b);
-extern int32 btint24cmp(int16 a, int32 b);
-extern int32 btint42cmp(int32 a, int16 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 Datum btboolcmp(PG_FUNCTION_ARGS);
+extern Datum btint2cmp(PG_FUNCTION_ARGS);
+extern Datum btint4cmp(PG_FUNCTION_ARGS);
+extern Datum btint8cmp(PG_FUNCTION_ARGS);
+extern Datum btint24cmp(PG_FUNCTION_ARGS);
+extern Datum btint42cmp(PG_FUNCTION_ARGS);
+extern Datum btfloat4cmp(PG_FUNCTION_ARGS);
+extern Datum btfloat8cmp(PG_FUNCTION_ARGS);
+extern Datum btoidcmp(PG_FUNCTION_ARGS);
+extern Datum btoidvectorcmp(PG_FUNCTION_ARGS);
 extern int32 btabstimecmp(AbsoluteTime a, AbsoluteTime b);
-extern int32 btcharcmp(char a, char b);
-extern int32 btnamecmp(NameData *a, NameData *b);
-extern int32 bttextcmp(struct varlena * a, struct varlena * b);
-extern int32 btboolcmp(bool a, bool b);
+extern Datum btcharcmp(PG_FUNCTION_ARGS);
+extern Datum btnamecmp(PG_FUNCTION_ARGS);
+extern Datum bttextcmp(PG_FUNCTION_ARGS);
 
 /* support routines for the rtree access method, by opclass */
 extern BOX *rt_box_union(BOX *a, BOX *b);
@@ -244,14 +246,14 @@ 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 Datum i2tod(PG_FUNCTION_ARGS);
 extern float32 dtof(float64 num);
 extern int32 dtoi4(float64 num);
-extern int16 dtoi2(float64 num);
+extern Datum dtoi2(PG_FUNCTION_ARGS);
 extern float32 i4tof(int32 num);
-extern float32 i2tof(int16 num);
+extern Datum i2tof(PG_FUNCTION_ARGS);
 extern int32 ftoi4(float32 num);
-extern int16 ftoi2(float32 num);
+extern Datum ftoi2(PG_FUNCTION_ARGS);
 extern float64 text_float8(text *str);
 extern float32 text_float4(text *str);
 extern text *float8_text(float64 num);
@@ -301,37 +303,33 @@ extern bool float84gt(float64 arg1, float32 arg2);
 extern bool float84ge(float64 arg1, float32 arg2);
 
 /* misc.c */
-extern bool nullvalue(Datum value, bool *isNull);
-extern bool nonnullvalue(Datum value, bool *isNull);
-extern bool oidrand(Oid o, int32 X);
-extern bool oidsrand(int32 X);
-extern int32 userfntest(int i);
-
-/* define macros to replace mixed-case function calls - tgl 97/04/27 */
-#define NullValue(v,b) nullvalue(v,b)
-#define NonNullValue(v,b) nonnullvalue(v,b)
+extern Datum nullvalue(PG_FUNCTION_ARGS);
+extern Datum nonnullvalue(PG_FUNCTION_ARGS);
+extern Datum oidrand(PG_FUNCTION_ARGS);
+extern Datum oidsrand(PG_FUNCTION_ARGS);
+extern Datum userfntest(PG_FUNCTION_ARGS);
 
 /* not_in.c */
 extern bool int4notin(int32 not_in_arg, char *relation_and_attr);
 extern bool oidnotin(Oid the_oid, char *compare);
 
 /* oid.c */
-extern Oid *oidvectorin(char *oidString);
-extern char *oidvectorout(Oid *oidArray);
-extern Oid	oidin(char *s);
-extern char *oidout(Oid o);
-extern bool oideq(Oid arg1, Oid arg2);
-extern bool oidne(Oid arg1, Oid arg2);
-extern bool oidvectoreq(Oid *arg1, Oid *arg2);
-extern bool oidvectorne(Oid *arg1, Oid *arg2);
-extern bool oidvectorlt(Oid *arg1, Oid *arg2);
-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 text *oid_text(Oid arg1);
-extern Oid	text_oid(text *arg1);
+extern Datum oidvectorin(PG_FUNCTION_ARGS);
+extern Datum oidvectorout(PG_FUNCTION_ARGS);
+extern Datum oidin(PG_FUNCTION_ARGS);
+extern Datum oidout(PG_FUNCTION_ARGS);
+extern Datum oideq(PG_FUNCTION_ARGS);
+extern Datum oidne(PG_FUNCTION_ARGS);
+extern Datum oidvectoreq(PG_FUNCTION_ARGS);
+extern Datum oidvectorne(PG_FUNCTION_ARGS);
+extern Datum oidvectorlt(PG_FUNCTION_ARGS);
+extern Datum oidvectorle(PG_FUNCTION_ARGS);
+extern Datum oidvectorge(PG_FUNCTION_ARGS);
+extern Datum oidvectorgt(PG_FUNCTION_ARGS);
+extern Datum oideqint4(PG_FUNCTION_ARGS);
+extern Datum int4eqoid(PG_FUNCTION_ARGS);
+extern Datum oid_text(PG_FUNCTION_ARGS);
+extern Datum text_oid(PG_FUNCTION_ARGS);
 
 /* regexp.c */
 extern bool nameregexeq(NameData *n, struct varlena * p);
@@ -345,13 +343,13 @@ extern bool texticregexne(struct varlena * s, struct varlena * p);
 
 
 /* regproc.c */
-extern int32 regprocin(char *pro_name_and_oid);
-extern char *regprocout(RegProcedure proid);
-extern text *oidvectortypes(Oid *oidArray);
-extern Oid	regproctooid(RegProcedure rp);
+extern Datum regprocin(PG_FUNCTION_ARGS);
+extern Datum regprocout(PG_FUNCTION_ARGS);
+extern Datum oidvectortypes(PG_FUNCTION_ARGS);
+extern Datum regproctooid(PG_FUNCTION_ARGS);
 
 /* define macro to replace mixed-case function call - tgl 97/04/27 */
-#define RegprocToOid(rp) regproctooid(rp)
+#define RegprocToOid(rp) ((Oid) (rp))
 
 /* ruleutils.c */
 extern text *pg_get_ruledef(NameData *rname);
@@ -362,69 +360,34 @@ extern char *deparse_expression(Node *expr, List *rangetables,
 				   bool forceprefix);
 
 /* selfuncs.c */
-extern float64 eqsel(Oid opid, Oid relid, AttrNumber attno,
-					 Datum value, int32 flag);
-extern float64 neqsel(Oid opid, Oid relid, AttrNumber attno,
-					  Datum value, int32 flag);
-extern float64 scalarltsel(Oid opid, Oid relid, AttrNumber attno,
-						   Datum value, int32 flag);
-extern float64 scalargtsel(Oid opid, Oid relid, AttrNumber attno,
-						   Datum value, int32 flag);
-extern float64 regexeqsel(Oid opid, Oid relid, AttrNumber attno,
-						  Datum value, int32 flag);
-extern float64 likesel(Oid opid, Oid relid, AttrNumber attno,
-					   Datum value, int32 flag);
-extern float64 icregexeqsel(Oid opid, Oid relid, AttrNumber attno,
-							Datum value, int32 flag);
-extern float64 regexnesel(Oid opid, Oid relid, AttrNumber attno,
-						  Datum value, int32 flag);
-extern float64 nlikesel(Oid opid, Oid relid, AttrNumber attno,
-						Datum value, int32 flag);
-extern float64 icregexnesel(Oid opid, Oid relid, AttrNumber attno,
-							Datum value, int32 flag);
-
-extern float64 eqjoinsel(Oid opid, Oid relid1, AttrNumber attno1,
-						 Oid relid2, AttrNumber attno2);
-extern float64 neqjoinsel(Oid opid, Oid relid1, AttrNumber attno1,
-						  Oid relid2, AttrNumber attno2);
-extern float64 scalarltjoinsel(Oid opid, Oid relid1, AttrNumber attno1,
-							   Oid relid2, AttrNumber attno2);
-extern float64 scalargtjoinsel(Oid opid, Oid relid1, AttrNumber attno1,
-							   Oid relid2, AttrNumber attno2);
-extern float64 regexeqjoinsel(Oid opid, Oid relid1, AttrNumber attno1,
-							  Oid relid2, AttrNumber attno2);
-extern float64 likejoinsel(Oid opid, Oid relid1, AttrNumber attno1,
-						   Oid relid2, AttrNumber attno2);
-extern float64 icregexeqjoinsel(Oid opid, Oid relid1, AttrNumber attno1,
-								Oid relid2, AttrNumber attno2);
-extern float64 regexnejoinsel(Oid opid, Oid relid1, AttrNumber attno1,
-							  Oid relid2, AttrNumber attno2);
-extern float64 nlikejoinsel(Oid opid, Oid relid1, AttrNumber attno1,
-							Oid relid2, AttrNumber attno2);
-extern float64 icregexnejoinsel(Oid opid, Oid relid1, AttrNumber attno1,
-								Oid relid2, AttrNumber attno2);
-
-extern void btcostestimate(Query *root, RelOptInfo *rel,
-			   IndexOptInfo *index, List *indexQuals,
-			   Cost *indexStartupCost,
-			   Cost *indexTotalCost,
-			   Selectivity *indexSelectivity);
-extern void rtcostestimate(Query *root, RelOptInfo *rel,
-			   IndexOptInfo *index, List *indexQuals,
-			   Cost *indexStartupCost,
-			   Cost *indexTotalCost,
-			   Selectivity *indexSelectivity);
-extern void hashcostestimate(Query *root, RelOptInfo *rel,
-				 IndexOptInfo *index, List *indexQuals,
-				 Cost *indexStartupCost,
-				 Cost *indexTotalCost,
-				 Selectivity *indexSelectivity);
-extern void gistcostestimate(Query *root, RelOptInfo *rel,
-				 IndexOptInfo *index, List *indexQuals,
-				 Cost *indexStartupCost,
-				 Cost *indexTotalCost,
-				 Selectivity *indexSelectivity);
-
+extern Datum eqsel(PG_FUNCTION_ARGS);
+extern Datum neqsel(PG_FUNCTION_ARGS);
+extern Datum scalarltsel(PG_FUNCTION_ARGS);
+extern Datum scalargtsel(PG_FUNCTION_ARGS);
+extern Datum regexeqsel(PG_FUNCTION_ARGS);
+extern Datum icregexeqsel(PG_FUNCTION_ARGS);
+extern Datum likesel(PG_FUNCTION_ARGS);
+extern Datum regexnesel(PG_FUNCTION_ARGS);
+extern Datum icregexnesel(PG_FUNCTION_ARGS);
+extern Datum nlikesel(PG_FUNCTION_ARGS);
+
+extern Datum eqjoinsel(PG_FUNCTION_ARGS);
+extern Datum neqjoinsel(PG_FUNCTION_ARGS);
+extern Datum scalarltjoinsel(PG_FUNCTION_ARGS);
+extern Datum scalargtjoinsel(PG_FUNCTION_ARGS);
+extern Datum regexeqjoinsel(PG_FUNCTION_ARGS);
+extern Datum icregexeqjoinsel(PG_FUNCTION_ARGS);
+extern Datum likejoinsel(PG_FUNCTION_ARGS);
+extern Datum regexnejoinsel(PG_FUNCTION_ARGS);
+extern Datum icregexnejoinsel(PG_FUNCTION_ARGS);
+extern Datum nlikejoinsel(PG_FUNCTION_ARGS);
+
+extern Datum btcostestimate(PG_FUNCTION_ARGS);
+extern Datum rtcostestimate(PG_FUNCTION_ARGS);
+extern Datum hashcostestimate(PG_FUNCTION_ARGS);
+extern Datum gistcostestimate(PG_FUNCTION_ARGS);
+
+/* selfuncs.c supporting routines that are also used by optimizer code */
 typedef enum
 {
 	Pattern_Type_Like, Pattern_Type_Regex, Pattern_Type_Regex_IC
@@ -452,12 +415,19 @@ extern ItemPointer currtid_byreloid(Oid relOid, ItemPointer);
 extern ItemPointer currtid_byrelname(const text *relName, ItemPointer);
 
 /* varchar.c */
+
+/* bpchar and varchar are just a varlena header and some characters */
+#define PG_GETARG_BPCHAR_P(n)  ((struct varlena *) PG_GETARG_VARLENA_P(n))
+#define PG_RETURN_BPCHAR_P(x)  PG_RETURN_POINTER(x)
+#define PG_GETARG_VARCHAR_P(n)  ((struct varlena *) PG_GETARG_VARLENA_P(n))
+#define PG_RETURN_VARCHAR_P(x)  PG_RETURN_POINTER(x)
+
 extern char *bpcharin(char *s, int dummy, int32 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 int32 bpchar_char(char *s);
+extern Datum char_bpchar(PG_FUNCTION_ARGS);
+extern Datum bpchar_char(PG_FUNCTION_ARGS);
 extern char *name_bpchar(NameData *s);
 extern NameData *bpchar_name(char *s);
 extern bool bpchareq(char *arg1, char *arg2);
@@ -616,8 +586,8 @@ extern Numeric int4_numeric(int32 val);
 extern int32 numeric_int4(Numeric num);
 extern Numeric int8_numeric(int64 *val);
 extern int64 *numeric_int8(Numeric num);
-extern Numeric int2_numeric(int16 val);
-extern int16 numeric_int2(Numeric num);
+extern Datum int2_numeric(PG_FUNCTION_ARGS);
+extern Datum numeric_int2(PG_FUNCTION_ARGS);
 extern Numeric float4_numeric(float32 val);
 extern float32 numeric_float4(Numeric num);
 extern Numeric float8_numeric(float64 val);
diff --git a/src/include/utils/cash.h b/src/include/utils/cash.h
index 0530266f7e..ab688c46f8 100644
--- a/src/include/utils/cash.h
+++ b/src/include/utils/cash.h
@@ -37,9 +37,9 @@ extern Cash *cash_mul_int4(Cash *c, int4 i);
 extern Cash *cash_div_int4(Cash *c, int4 i);
 extern Cash *int4_mul_cash(int4 i, Cash *c);
 
-extern Cash *cash_mul_int2(Cash *c, int2 s);
-extern Cash *cash_div_int2(Cash *c, int2 s);
-extern Cash *int2_mul_cash(int2 s, Cash *c);
+extern Datum cash_mul_int2(PG_FUNCTION_ARGS);
+extern Datum int2_mul_cash(PG_FUNCTION_ARGS);
+extern Datum cash_div_int2(PG_FUNCTION_ARGS);
 
 extern Cash *cashlarger(Cash *c1, Cash *c2);
 extern Cash *cashsmaller(Cash *c1, Cash *c2);
diff --git a/src/include/utils/catcache.h b/src/include/utils/catcache.h
index cf9b1efc6f..31ec660b9a 100644
--- a/src/include/utils/catcache.h
+++ b/src/include/utils/catcache.h
@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: catcache.h,v 1.21 2000/04/12 17:16:54 momjian Exp $
+ * $Id: catcache.h,v 1.22 2000/06/05 07:29:07 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -17,6 +17,7 @@
 /* #define		CACHEDEBUG		 turns DEBUG elogs on */
 
 #include "access/htup.h"
+#include "fmgr.h"
 #include "lib/dllist.h"
 
 /*
@@ -40,7 +41,6 @@ typedef struct catctup
 #define NCCBUCK 500				/* CatCache buckets */
 #define MAXTUP 300				/* Maximum # of tuples cached per cache */
 
-typedef uint32 (*CCHashFunc) (Datum);
 
 typedef struct catcache
 {
@@ -57,7 +57,7 @@ typedef struct catcache
 	short		cc_nkeys;
 	short		cc_size;
 	short		cc_key[4];		/* AttrNumber of each key */
-	CCHashFunc	cc_hashfunc[4]; /* hash function to use for each key */
+	PGFunction	cc_hashfunc[4]; /* hash function to use for each key */
 	ScanKeyData cc_skey[4];
 	struct catcache *cc_next;
 	Dllist	   *cc_lrulist;		/* LRU list, most recent first */
diff --git a/src/include/utils/geo_decls.h b/src/include/utils/geo_decls.h
index 305b482a64..0a722fe81e 100644
--- a/src/include/utils/geo_decls.h
+++ b/src/include/utils/geo_decls.h
@@ -6,7 +6,7 @@
  * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: geo_decls.h,v 1.27 2000/04/12 17:16:55 momjian Exp $
+ * $Id: geo_decls.h,v 1.28 2000/06/05 07:29:07 tgl Exp $
  *
  * NOTE
  *	  These routines do *not* use the float types from adt/.
@@ -22,6 +22,7 @@
 #define GEO_DECLS_H
 
 #include "access/attnum.h"
+#include "fmgr.h"
 
 /*--------------------------------------------------------------------
  * Useful floating point utilities and constants.
@@ -360,17 +361,11 @@ extern double *circle_area(CIRCLE *circle);
 extern double circle_dt(CIRCLE *circle1, CIRCLE *circle2);
 
 /* geo_selfuncs.c */
-extern float64 areasel(Oid opid, Oid relid, AttrNumber attno,
-		Datum value, int32 flag);
-extern float64 areajoinsel(Oid opid, Oid relid1, AttrNumber attno1,
-			Oid relid2, AttrNumber attno2);
-extern float64 positionsel(Oid opid, Oid relid, AttrNumber attno,
-			Datum value, int32 flag);
-extern float64 positionjoinsel(Oid opid, Oid relid1, AttrNumber attno1,
-				Oid relid2, AttrNumber attno2);
-extern float64 contsel(Oid opid, Oid relid, AttrNumber attno,
-		Datum value, int32 flag);
-extern float64 contjoinsel(Oid opid, Oid relid1, AttrNumber attno1,
-			Oid relid2, AttrNumber attno2);
+extern Datum areasel(PG_FUNCTION_ARGS);
+extern Datum areajoinsel(PG_FUNCTION_ARGS);
+extern Datum positionsel(PG_FUNCTION_ARGS);
+extern Datum positionjoinsel(PG_FUNCTION_ARGS);
+extern Datum contsel(PG_FUNCTION_ARGS);
+extern Datum contjoinsel(PG_FUNCTION_ARGS);
 
 #endif	 /* GEO_DECLS_H */
diff --git a/src/pl/plperl/plperl.c b/src/pl/plperl/plperl.c
index e51c950ef6..66ae44373d 100644
--- a/src/pl/plperl/plperl.c
+++ b/src/pl/plperl/plperl.c
@@ -33,7 +33,7 @@
  *	  ENHANCEMENTS, OR MODIFICATIONS.
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/pl/plperl/plperl.c,v 1.10 2000/05/30 04:24:57 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/pl/plperl/plperl.c,v 1.11 2000/06/05 07:29:11 tgl Exp $
  *
  **********************************************************************/
 
@@ -858,7 +858,8 @@ plperl_trigger_handler(PG_FUNCTION_ARGS)
 	Tcl_DStringAppendElement(&tcl_cmd, trigdata->tg_trigger->tgname);
 
 	/* The oid of the trigger relation for argument TG_relid */
-	stroid = oidout(trigdata->tg_relation->rd_id);
+	stroid = DatumGetCString(DirectFunctionCall1(oidout,
+							 ObjectIdGetDatum(trigdata->tg_relation->rd_id)));
 	Tcl_DStringAppendElement(&tcl_cmd, stroid);
 	pfree(stroid);
 
diff --git a/src/pl/plpgsql/src/gram.y b/src/pl/plpgsql/src/gram.y
index 831ad83e8c..e76ddecb3c 100644
--- a/src/pl/plpgsql/src/gram.y
+++ b/src/pl/plpgsql/src/gram.y
@@ -4,7 +4,7 @@
  *			  procedural language
  *
  * IDENTIFICATION
- *    $Header: /cvsroot/pgsql/src/pl/plpgsql/src/gram.y,v 1.9 2000/05/29 21:25:07 momjian Exp $
+ *    $Header: /cvsroot/pgsql/src/pl/plpgsql/src/gram.y,v 1.10 2000/06/05 07:29:14 tgl Exp $
  *
  *    This software is copyrighted by Jan Wieck - Hamburg.
  *
@@ -433,7 +433,7 @@ decl_atttypmod	:
 
 decl_atttypmodval	: T_NUMBER
 		    {
-		        $$ = int2in(yytext) + VARHDRSZ;
+		        $$ = pg_atoi(yytext, sizeof(int16), '\0') + VARHDRSZ;
 		    }
 		;
 
diff --git a/src/pl/tcl/pltcl.c b/src/pl/tcl/pltcl.c
index b2bceb9218..37b413da2d 100644
--- a/src/pl/tcl/pltcl.c
+++ b/src/pl/tcl/pltcl.c
@@ -31,7 +31,7 @@
  *	  ENHANCEMENTS, OR MODIFICATIONS.
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/pl/tcl/pltcl.c,v 1.25 2000/05/30 04:24:59 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/pl/tcl/pltcl.c,v 1.26 2000/06/05 07:29:13 tgl Exp $
  *
  **********************************************************************/
 
@@ -905,7 +905,8 @@ pltcl_trigger_handler(PG_FUNCTION_ARGS)
 	Tcl_DStringAppendElement(&tcl_cmd, trigdata->tg_trigger->tgname);
 
 	/* The oid of the trigger relation for argument TG_relid */
-	stroid = oidout(trigdata->tg_relation->rd_id);
+	stroid = DatumGetCString(DirectFunctionCall1(oidout,
+							 ObjectIdGetDatum(trigdata->tg_relation->rd_id)));
 	Tcl_DStringAppendElement(&tcl_cmd, stroid);
 	pfree(stroid);
 
diff --git a/src/test/regress/expected/opr_sanity.out b/src/test/regress/expected/opr_sanity.out
index 5adf28926c..974575e53b 100644
--- a/src/test/regress/expected/opr_sanity.out
+++ b/src/test/regress/expected/opr_sanity.out
@@ -46,7 +46,7 @@ WHERE p1.oid != p2.oid AND
 -----+---------+-----+---------
 (0 rows)
 
--- Considering only built-in procs (prolang = 11), look for multiple uses
+-- Considering only built-in procs (prolang = 11/12), look for multiple uses
 -- of the same internal function (ie, matching prosrc fields).  It's OK to
 -- have several entries with different pronames for the same internal function,
 -- but conflicts in the number of arguments and other critical items should
@@ -54,7 +54,9 @@ WHERE p1.oid != p2.oid AND
 SELECT p1.oid, p1.proname, p2.oid, p2.proname
 FROM pg_proc AS p1, pg_proc AS p2
 WHERE p1.oid != p2.oid AND
-    p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND
+    p1.prosrc = p2.prosrc AND
+    (p1.prolang = 11 OR p1.prolang = 12) AND
+    (p2.prolang = 11 OR p2.prolang = 12) AND
     (p1.proisinh != p2.proisinh OR
      p1.proistrusted != p2.proistrusted OR
      p1.proiscachable != p2.proiscachable OR
@@ -73,7 +75,9 @@ WHERE p1.oid != p2.oid AND
 SELECT DISTINCT p1.prorettype, p2.prorettype
 FROM pg_proc AS p1, pg_proc AS p2
 WHERE p1.oid != p2.oid AND
-    p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND
+    p1.prosrc = p2.prosrc AND
+    (p1.prolang = 11 OR p1.prolang = 12) AND
+    (p2.prolang = 11 OR p2.prolang = 12) AND
     (p1.prorettype < p2.prorettype);
  prorettype | prorettype 
 ------------+------------
@@ -84,7 +88,9 @@ WHERE p1.oid != p2.oid AND
 SELECT DISTINCT p1.proargtypes[0], p2.proargtypes[0]
 FROM pg_proc AS p1, pg_proc AS p2
 WHERE p1.oid != p2.oid AND
-    p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND
+    p1.prosrc = p2.prosrc AND
+    (p1.prolang = 11 OR p1.prolang = 12) AND
+    (p2.prolang = 11 OR p2.prolang = 12) AND
     (p1.proargtypes[0] < p2.proargtypes[0]);
  proargtypes | proargtypes 
 -------------+-------------
@@ -95,7 +101,9 @@ WHERE p1.oid != p2.oid AND
 SELECT DISTINCT p1.proargtypes[1], p2.proargtypes[1]
 FROM pg_proc AS p1, pg_proc AS p2
 WHERE p1.oid != p2.oid AND
-    p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND
+    p1.prosrc = p2.prosrc AND
+    (p1.prolang = 11 OR p1.prolang = 12) AND
+    (p2.prolang = 11 OR p2.prolang = 12) AND
     (p1.proargtypes[1] < p2.proargtypes[1]);
  proargtypes | proargtypes 
 -------------+-------------
@@ -104,7 +112,9 @@ WHERE p1.oid != p2.oid AND
 SELECT DISTINCT p1.proargtypes[2], p2.proargtypes[2]
 FROM pg_proc AS p1, pg_proc AS p2
 WHERE p1.oid != p2.oid AND
-    p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND
+    p1.prosrc = p2.prosrc AND
+    (p1.prolang = 11 OR p1.prolang = 12) AND
+    (p2.prolang = 11 OR p2.prolang = 12) AND
     (p1.proargtypes[2] < p2.proargtypes[2]);
  proargtypes | proargtypes 
 -------------+-------------
@@ -113,7 +123,9 @@ WHERE p1.oid != p2.oid AND
 SELECT DISTINCT p1.proargtypes[3], p2.proargtypes[3]
 FROM pg_proc AS p1, pg_proc AS p2
 WHERE p1.oid != p2.oid AND
-    p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND
+    p1.prosrc = p2.prosrc AND
+    (p1.prolang = 11 OR p1.prolang = 12) AND
+    (p2.prolang = 11 OR p2.prolang = 12) AND
     (p1.proargtypes[3] < p2.proargtypes[3]);
  proargtypes | proargtypes 
 -------------+-------------
@@ -122,7 +134,9 @@ WHERE p1.oid != p2.oid AND
 SELECT DISTINCT p1.proargtypes[4], p2.proargtypes[4]
 FROM pg_proc AS p1, pg_proc AS p2
 WHERE p1.oid != p2.oid AND
-    p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND
+    p1.prosrc = p2.prosrc AND
+    (p1.prolang = 11 OR p1.prolang = 12) AND
+    (p2.prolang = 11 OR p2.prolang = 12) AND
     (p1.proargtypes[4] < p2.proargtypes[4]);
  proargtypes | proargtypes 
 -------------+-------------
@@ -131,7 +145,9 @@ WHERE p1.oid != p2.oid AND
 SELECT DISTINCT p1.proargtypes[5], p2.proargtypes[5]
 FROM pg_proc AS p1, pg_proc AS p2
 WHERE p1.oid != p2.oid AND
-    p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND
+    p1.prosrc = p2.prosrc AND
+    (p1.prolang = 11 OR p1.prolang = 12) AND
+    (p2.prolang = 11 OR p2.prolang = 12) AND
     (p1.proargtypes[5] < p2.proargtypes[5]);
  proargtypes | proargtypes 
 -------------+-------------
@@ -140,7 +156,9 @@ WHERE p1.oid != p2.oid AND
 SELECT DISTINCT p1.proargtypes[6], p2.proargtypes[6]
 FROM pg_proc AS p1, pg_proc AS p2
 WHERE p1.oid != p2.oid AND
-    p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND
+    p1.prosrc = p2.prosrc AND
+    (p1.prolang = 11 OR p1.prolang = 12) AND
+    (p2.prolang = 11 OR p2.prolang = 12) AND
     (p1.proargtypes[6] < p2.proargtypes[6]);
  proargtypes | proargtypes 
 -------------+-------------
@@ -149,7 +167,9 @@ WHERE p1.oid != p2.oid AND
 SELECT DISTINCT p1.proargtypes[7], p2.proargtypes[7]
 FROM pg_proc AS p1, pg_proc AS p2
 WHERE p1.oid != p2.oid AND
-    p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND
+    p1.prosrc = p2.prosrc AND
+    (p1.prolang = 11 OR p1.prolang = 12) AND
+    (p2.prolang = 11 OR p2.prolang = 12) AND
     (p1.proargtypes[7] < p2.proargtypes[7]);
  proargtypes | proargtypes 
 -------------+-------------
diff --git a/src/test/regress/input/create_function_2.source b/src/test/regress/input/create_function_2.source
index ebc612261f..a135a8fa9c 100644
--- a/src/test/regress/input/create_function_2.source
+++ b/src/test/regress/input/create_function_2.source
@@ -35,7 +35,7 @@ CREATE FUNCTION pt_in_widget(point, widget)
 CREATE FUNCTION overpaid(emp)
    RETURNS bool
    AS '_OBJWD_/regress_DLSUFFIX_'
-   LANGUAGE 'c';
+   LANGUAGE 'newC';
 
 CREATE FUNCTION boxarea(box)
    RETURNS int4
diff --git a/src/test/regress/output/create_function_2.source b/src/test/regress/output/create_function_2.source
index 2d86915cc1..f04cf7356c 100644
--- a/src/test/regress/output/create_function_2.source
+++ b/src/test/regress/output/create_function_2.source
@@ -27,7 +27,7 @@ CREATE FUNCTION pt_in_widget(point, widget)
 CREATE FUNCTION overpaid(emp)
    RETURNS bool
    AS '_OBJWD_/regress_DLSUFFIX_'
-   LANGUAGE 'c';
+   LANGUAGE 'newC';
 CREATE FUNCTION boxarea(box)
    RETURNS int4
    AS '_OBJWD_/regress_DLSUFFIX_'
diff --git a/src/test/regress/regress.c b/src/test/regress/regress.c
index f58b0d9d8c..18fb2d1996 100644
--- a/src/test/regress/regress.c
+++ b/src/test/regress/regress.c
@@ -1,5 +1,5 @@
 /*
- * $Header: /cvsroot/pgsql/src/test/regress/regress.c,v 1.37 2000/05/29 01:59:15 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/test/regress/regress.c,v 1.38 2000/06/05 07:29:22 tgl Exp $
  */
 
 #include <float.h>				/* faked on sunos */
@@ -14,14 +14,14 @@
 #define RDELIM			')'
 #define DELIM			','
 
-typedef void *TUPLE;
+typedef TupleTableSlot *TUPLE;
 
 extern double *regress_dist_ptpath(Point *pt, PATH *path);
 extern double *regress_path_dist(PATH *p1, PATH *p2);
 extern PATH *poly2path(POLYGON *poly);
 extern Point *interpt_pp(PATH *p1, PATH *p2);
 extern void regress_lseg_construct(LSEG *lseg, Point *pt1, Point *pt2);
-extern char overpaid(TUPLE tuple);
+extern Datum overpaid(PG_FUNCTION_ARGS);
 extern int	boxarea(BOX *box);
 extern char *reverse_name(char *string);
 
@@ -176,16 +176,17 @@ Point	   *pt2;
 	lseg->m = point_sl(pt1, pt2);
 }
 
-
-char
-overpaid(tuple)
-TUPLE		tuple;
+Datum
+overpaid(PG_FUNCTION_ARGS)
 {
+	TUPLE		tuple = (TUPLE) PG_GETARG_POINTER(0);
 	bool		isnull;
 	long		salary;
 
 	salary = (long) GetAttributeByName(tuple, "salary", &isnull);
-	return salary > 699;
+	if (isnull)
+		PG_RETURN_NULL();
+	PG_RETURN_BOOL(salary > 699);
 }
 
 /* New type "widget"
@@ -395,13 +396,12 @@ funny_dup17(PG_FUNCTION_ARGS)
 
 	if (SPI_processed > 0)
 	{
-		selected = int4in(
-						  SPI_getvalue(
+		selected = DatumGetInt32(DirectFunctionCall1(int4in,
+								 CStringGetDatum(SPI_getvalue(
 									   SPI_tuptable->vals[0],
 									   SPI_tuptable->tupdesc,
 									   1
-									   )
-			);
+									   ))));
 	}
 
 	elog(NOTICE, "funny_dup17 (fired %s) on level %3d: %d/%d tuples inserted/selected",
diff --git a/src/test/regress/sql/opr_sanity.sql b/src/test/regress/sql/opr_sanity.sql
index e378171fd8..d87702f0e3 100644
--- a/src/test/regress/sql/opr_sanity.sql
+++ b/src/test/regress/sql/opr_sanity.sql
@@ -44,7 +44,7 @@ WHERE p1.oid != p2.oid AND
     p1.pronargs = p2.pronargs AND
     p1.proargtypes = p2.proargtypes;
 
--- Considering only built-in procs (prolang = 11), look for multiple uses
+-- Considering only built-in procs (prolang = 11/12), look for multiple uses
 -- of the same internal function (ie, matching prosrc fields).  It's OK to
 -- have several entries with different pronames for the same internal function,
 -- but conflicts in the number of arguments and other critical items should
@@ -53,7 +53,9 @@ WHERE p1.oid != p2.oid AND
 SELECT p1.oid, p1.proname, p2.oid, p2.proname
 FROM pg_proc AS p1, pg_proc AS p2
 WHERE p1.oid != p2.oid AND
-    p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND
+    p1.prosrc = p2.prosrc AND
+    (p1.prolang = 11 OR p1.prolang = 12) AND
+    (p2.prolang = 11 OR p2.prolang = 12) AND
     (p1.proisinh != p2.proisinh OR
      p1.proistrusted != p2.proistrusted OR
      p1.proiscachable != p2.proiscachable OR
@@ -70,55 +72,73 @@ WHERE p1.oid != p2.oid AND
 SELECT DISTINCT p1.prorettype, p2.prorettype
 FROM pg_proc AS p1, pg_proc AS p2
 WHERE p1.oid != p2.oid AND
-    p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND
+    p1.prosrc = p2.prosrc AND
+    (p1.prolang = 11 OR p1.prolang = 12) AND
+    (p2.prolang = 11 OR p2.prolang = 12) AND
     (p1.prorettype < p2.prorettype);
 
 SELECT DISTINCT p1.proargtypes[0], p2.proargtypes[0]
 FROM pg_proc AS p1, pg_proc AS p2
 WHERE p1.oid != p2.oid AND
-    p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND
+    p1.prosrc = p2.prosrc AND
+    (p1.prolang = 11 OR p1.prolang = 12) AND
+    (p2.prolang = 11 OR p2.prolang = 12) AND
     (p1.proargtypes[0] < p2.proargtypes[0]);
 
 SELECT DISTINCT p1.proargtypes[1], p2.proargtypes[1]
 FROM pg_proc AS p1, pg_proc AS p2
 WHERE p1.oid != p2.oid AND
-    p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND
+    p1.prosrc = p2.prosrc AND
+    (p1.prolang = 11 OR p1.prolang = 12) AND
+    (p2.prolang = 11 OR p2.prolang = 12) AND
     (p1.proargtypes[1] < p2.proargtypes[1]);
 
 SELECT DISTINCT p1.proargtypes[2], p2.proargtypes[2]
 FROM pg_proc AS p1, pg_proc AS p2
 WHERE p1.oid != p2.oid AND
-    p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND
+    p1.prosrc = p2.prosrc AND
+    (p1.prolang = 11 OR p1.prolang = 12) AND
+    (p2.prolang = 11 OR p2.prolang = 12) AND
     (p1.proargtypes[2] < p2.proargtypes[2]);
 
 SELECT DISTINCT p1.proargtypes[3], p2.proargtypes[3]
 FROM pg_proc AS p1, pg_proc AS p2
 WHERE p1.oid != p2.oid AND
-    p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND
+    p1.prosrc = p2.prosrc AND
+    (p1.prolang = 11 OR p1.prolang = 12) AND
+    (p2.prolang = 11 OR p2.prolang = 12) AND
     (p1.proargtypes[3] < p2.proargtypes[3]);
 
 SELECT DISTINCT p1.proargtypes[4], p2.proargtypes[4]
 FROM pg_proc AS p1, pg_proc AS p2
 WHERE p1.oid != p2.oid AND
-    p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND
+    p1.prosrc = p2.prosrc AND
+    (p1.prolang = 11 OR p1.prolang = 12) AND
+    (p2.prolang = 11 OR p2.prolang = 12) AND
     (p1.proargtypes[4] < p2.proargtypes[4]);
 
 SELECT DISTINCT p1.proargtypes[5], p2.proargtypes[5]
 FROM pg_proc AS p1, pg_proc AS p2
 WHERE p1.oid != p2.oid AND
-    p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND
+    p1.prosrc = p2.prosrc AND
+    (p1.prolang = 11 OR p1.prolang = 12) AND
+    (p2.prolang = 11 OR p2.prolang = 12) AND
     (p1.proargtypes[5] < p2.proargtypes[5]);
 
 SELECT DISTINCT p1.proargtypes[6], p2.proargtypes[6]
 FROM pg_proc AS p1, pg_proc AS p2
 WHERE p1.oid != p2.oid AND
-    p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND
+    p1.prosrc = p2.prosrc AND
+    (p1.prolang = 11 OR p1.prolang = 12) AND
+    (p2.prolang = 11 OR p2.prolang = 12) AND
     (p1.proargtypes[6] < p2.proargtypes[6]);
 
 SELECT DISTINCT p1.proargtypes[7], p2.proargtypes[7]
 FROM pg_proc AS p1, pg_proc AS p2
 WHERE p1.oid != p2.oid AND
-    p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND
+    p1.prosrc = p2.prosrc AND
+    (p1.prolang = 11 OR p1.prolang = 12) AND
+    (p2.prolang = 11 OR p2.prolang = 12) AND
     (p1.proargtypes[7] < p2.proargtypes[7]);
 
 -- **************** pg_operator ****************
-- 
2.40.0