Another batch of fmgr updates. I think I have gotten all old-style

functions that take pass-by-value datatypes.  Should be ready for
port testing ...

src/backend/access/gist/gist.c

@@ -6,7 +6,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/gist/gist.c,v 1.55 2000/05/30 04:24:28 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/gist/gist.c,v 1.56 2000/06/13 07:34:27 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -47,7 +47,6 @@ static BlockNumber gistChooseSubtree(Relation r, IndexTuple itup, int level,
 static OffsetNumber gistchoose(Relation r, Page p, IndexTuple it,
 		   GISTSTATE *giststate);
 static int	gistnospace(Page p, IndexTuple it);
-void		gistdelete(Relation r, ItemPointer tid);
 static IndexTuple gist_tuple_replacekey(Relation r, GISTENTRY entry, IndexTuple t);
 static void gistcentryinit(GISTSTATE *giststate, GISTENTRY *e, char *pr,
 			   Relation r, Page pg, OffsetNumber o, int b, bool l);
@@ -60,17 +59,20 @@ static char *int_range_out(INTRANGE *r);
 /*
 ** routine to build an index.  Basically calls insert over and over
 */
-void
-gistbuild(Relation heap,
-		  Relation index,
-		  int natts,
-		  AttrNumber *attnum,
-		  IndexStrategy istrat,
-		  uint16 pint,
-		  Datum *params,
-		  FuncIndexInfo *finfo,
-		  PredInfo *predInfo)
+Datum
+gistbuild(PG_FUNCTION_ARGS)
 {
+	Relation		heap = (Relation) PG_GETARG_POINTER(0);
+	Relation		index = (Relation) PG_GETARG_POINTER(1);
+	int32			natts = PG_GETARG_INT32(2);
+	AttrNumber	   *attnum = (AttrNumber *) PG_GETARG_POINTER(3);
+#ifdef NOT_USED
+	IndexStrategy	istrat = (IndexStrategy) PG_GETARG_POINTER(4);
+	uint16			pcount = PG_GETARG_UINT16(5);
+	Datum		   *params = (Datum *) PG_GETARG_POINTER(6);
+#endif
+	FuncIndexInfo  *finfo = (FuncIndexInfo *) PG_GETARG_POINTER(7);
+	PredInfo	   *predInfo = (PredInfo *) PG_GETARG_POINTER(8);
 	HeapScanDesc scan;
 	AttrNumber	i;
 	HeapTuple	htup;
@@ -83,12 +85,10 @@ gistbuild(Relation heap,
 	int			nb,
 				nh,
 				ni;
-
 #ifndef OMIT_PARTIAL_INDEX
 	ExprContext *econtext;
 	TupleTable	tupleTable;
 	TupleTableSlot *slot;
-
 #endif
 	Node	   *pred,
 			   *oldPred;
@@ -302,6 +302,8 @@ gistbuild(Relation heap,
 	/* be tidy */
 	pfree(nulls);
 	pfree(d);
+
+	PG_RETURN_POINTER(NULL);	/* no real return value */
 }
 
 /*
@@ -310,9 +312,16 @@ gistbuild(Relation heap,
  *	  This is the public interface routine for tuple insertion in GiSTs.
  *	  It doesn't do any work; just locks the relation and passes the buck.
  */
-InsertIndexResult
-gistinsert(Relation r, Datum *datum, char *nulls, ItemPointer ht_ctid, Relation heapRel)
+Datum
+gistinsert(PG_FUNCTION_ARGS)
 {
+	Relation		r = (Relation) PG_GETARG_POINTER(0);
+	Datum		   *datum = (Datum *) PG_GETARG_POINTER(1);
+	char		   *nulls = (char *) PG_GETARG_POINTER(2);
+	ItemPointer		ht_ctid = (ItemPointer) PG_GETARG_POINTER(3);
+#ifdef NOT_USED
+	Relation		heapRel = (Relation) PG_GETARG_POINTER(4);
+#endif
 	InsertIndexResult res;
 	IndexTuple	itup;
 	GISTSTATE	giststate;
@@ -351,7 +360,7 @@ gistinsert(Relation r, Datum *datum, char *nulls, ItemPointer ht_ctid, Relation
 	pfree(itup);
 	pfree(compvec);
 
-	return res;
+	PG_RETURN_POINTER(res);
 }
 
 /*
@@ -596,7 +605,9 @@ gistAdjustKeys(Relation r,
 
 			/* delete old tuple */
 			ItemPointerSet(&oldtid, stk->gs_blk, stk->gs_child);
-			gistdelete(r, (ItemPointer) &oldtid);
+			DirectFunctionCall2(gistdelete,
+								PointerGetDatum(r),
+								PointerGetDatum(&oldtid));
 
 			/* generate and insert new tuple */
 			tupDesc = r->rd_att;
@@ -890,7 +901,9 @@ gistintinsert(Relation r,
 
 	/* remove old left pointer, insert the 2 new entries */
 	ItemPointerSet(&ltid, stk->gs_blk, stk->gs_child);
-	gistdelete(r, (ItemPointer) &ltid);
+	DirectFunctionCall2(gistdelete,
+						PointerGetDatum(r),
+						PointerGetDatum(&ltid));
 	gistentryinserttwo(r, stk, ltup, rtup, giststate);
 }
 
@@ -1105,9 +1118,11 @@ gistfreestack(GISTSTACK *s)
 /*
 ** remove an entry from a page
 */
-void
-gistdelete(Relation r, ItemPointer tid)
+Datum
+gistdelete(PG_FUNCTION_ARGS)
 {
+	Relation		r = (Relation) PG_GETARG_POINTER(0);
+	ItemPointer		tid = (ItemPointer) PG_GETARG_POINTER(1);
 	BlockNumber blkno;
 	OffsetNumber offnum;
 	Buffer		buf;
@@ -1134,6 +1149,7 @@ gistdelete(Relation r, ItemPointer tid)
 
 	WriteBuffer(buf);
 
+	PG_RETURN_POINTER(NULL);	/* no real return value */
 }
 
 void

src/backend/access/gist/gistget.c

@@ -29,21 +29,23 @@ static bool gistindex_keytest(IndexTuple tuple, TupleDesc tupdesc,
 				  Relation r, Page p, OffsetNumber offset);
 
 
-RetrieveIndexResult
-gistgettuple(IndexScanDesc s, ScanDirection dir)
+Datum
+gistgettuple(PG_FUNCTION_ARGS)
 {
+	IndexScanDesc		s = (IndexScanDesc) PG_GETARG_POINTER(0);
+	ScanDirection		dir = (ScanDirection) PG_GETARG_INT32(1);
 	RetrieveIndexResult res;
 
 	/* if we have it cached in the scan desc, just return the value */
 	if ((res = gistscancache(s, dir)) != (RetrieveIndexResult) NULL)
-		return res;
+		PG_RETURN_POINTER(res);
 
 	/* not cached, so we'll have to do some work */
 	if (ItemPointerIsValid(&(s->currentItemData)))
 		res = gistnext(s, dir);
 	else
 		res = gistfirst(s, dir);
-	return res;
+	PG_RETURN_POINTER(res);
 }
 
 static RetrieveIndexResult

src/backend/access/gist/gistscan.c

@@ -48,12 +48,13 @@ typedef GISTScanListData *GISTScanList;
 /* pointer to list of local scans on GiSTs */
 static GISTScanList GISTScans = (GISTScanList) NULL;
 
-IndexScanDesc
-gistbeginscan(Relation r,
-			  bool fromEnd,
-			  uint16 nkeys,
-			  ScanKey key)
+Datum
+gistbeginscan(PG_FUNCTION_ARGS)
 {
+	Relation	r = (Relation) PG_GETARG_POINTER(0);
+	bool		fromEnd = PG_GETARG_BOOL(1);
+	uint16		nkeys = PG_GETARG_UINT16(2);
+	ScanKey		key = (ScanKey) PG_GETARG_POINTER(3);
 	IndexScanDesc s;
 
 	/*
@@ -65,21 +66,18 @@ gistbeginscan(Relation r,
 	s = RelationGetIndexScan(r, fromEnd, nkeys, key);
 	gistregscan(s);
 
-	return s;
+	PG_RETURN_POINTER(s);
 }
 
-void
-gistrescan(IndexScanDesc s, bool fromEnd, ScanKey key)
+Datum
+gistrescan(PG_FUNCTION_ARGS)
 {
+	IndexScanDesc	s = (IndexScanDesc) PG_GETARG_POINTER(0);
+	bool			fromEnd = PG_GETARG_BOOL(1);
+	ScanKey			key = (ScanKey) PG_GETARG_POINTER(2);
 	GISTScanOpaque p;
 	int			i;
 
-	if (!IndexScanIsValid(s))
-	{
-		elog(ERROR, "gistrescan: invalid scan.");
-		return;
-	}
-
 	/*
 	 * Clear all the pointers.
 	 */
@@ -155,11 +153,14 @@ gistrescan(IndexScanDesc s, bool fromEnd, ScanKey key)
 				s->keyData[i].sk_func = p->giststate->consistentFn;
 			}
 	}
+
+	PG_RETURN_POINTER(NULL);	/* no real return value */
 }
 
-void
-gistmarkpos(IndexScanDesc s)
+Datum
+gistmarkpos(PG_FUNCTION_ARGS)
 {
+	IndexScanDesc	s = (IndexScanDesc) PG_GETARG_POINTER(0);
 	GISTScanOpaque p;
 	GISTSTACK  *o,
 			   *n,
@@ -188,11 +189,14 @@ gistmarkpos(IndexScanDesc s)
 
 	gistfreestack(p->s_markstk);
 	p->s_markstk = o;
+
+	PG_RETURN_POINTER(NULL);	/* no real return value */
 }
 
-void
-gistrestrpos(IndexScanDesc s)
+Datum
+gistrestrpos(PG_FUNCTION_ARGS)
 {
+	IndexScanDesc	s = (IndexScanDesc) PG_GETARG_POINTER(0);
 	GISTScanOpaque p;
 	GISTSTACK  *o,
 			   *n,
@@ -221,12 +225,15 @@ gistrestrpos(IndexScanDesc s)
 
 	gistfreestack(p->s_stack);
 	p->s_stack = o;
+
+	PG_RETURN_POINTER(NULL);	/* no real return value */
 }
 
-void
-gistendscan(IndexScanDesc s)
+Datum
+gistendscan(PG_FUNCTION_ARGS)
 {
-	GISTScanOpaque p;
+	IndexScanDesc	s = (IndexScanDesc) PG_GETARG_POINTER(0);
+	GISTScanOpaque	p;
 
 	p = (GISTScanOpaque) s->opaque;
 
@@ -239,6 +246,8 @@ gistendscan(IndexScanDesc s)
 
 	gistdropscan(s);
 	/* XXX don't unset read lock -- two-phase locking */
+
+	PG_RETURN_POINTER(NULL);	/* no real return value */
 }
 
 static void

src/backend/access/hash/hash.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/hash/hash.c,v 1.37 2000/04/12 17:14:43 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/hash/hash.c,v 1.38 2000/06/13 07:34:28 tgl Exp $
  *
  * NOTES
  *	  This file contains only the public interface routines.
@@ -36,17 +36,20 @@ bool		BuildingHash = false;
  *		since the index won't be visible until this transaction commits
  *		and since building is guaranteed to be single-threaded.
  */
-void
-hashbuild(Relation heap,
-		  Relation index,
-		  int natts,
-		  AttrNumber *attnum,
-		  IndexStrategy istrat,
-		  uint16 pcount,
-		  Datum *params,
-		  FuncIndexInfo *finfo,
-		  PredInfo *predInfo)
+Datum
+hashbuild(PG_FUNCTION_ARGS)
 {
+	Relation		heap = (Relation) PG_GETARG_POINTER(0);
+	Relation		index = (Relation) PG_GETARG_POINTER(1);
+	int32			natts = PG_GETARG_INT32(2);
+	AttrNumber	   *attnum = (AttrNumber *) PG_GETARG_POINTER(3);
+#ifdef NOT_USED
+	IndexStrategy	istrat = (IndexStrategy) PG_GETARG_POINTER(4);
+	uint16			pcount = PG_GETARG_UINT16(5);
+	Datum		   *params = (Datum *) PG_GETARG_POINTER(6);
+#endif
+	FuncIndexInfo  *finfo = (FuncIndexInfo *) PG_GETARG_POINTER(7);
+	PredInfo	   *predInfo = (PredInfo *) PG_GETARG_POINTER(8);
 	HeapScanDesc hscan;
 	HeapTuple	htup;
 	IndexTuple	itup;
@@ -262,6 +265,8 @@ hashbuild(Relation heap,
 
 	/* all done */
 	BuildingHash = false;
+
+	PG_RETURN_POINTER(NULL);	/* no real return value */
 }
 
 /*
@@ -271,20 +276,26 @@ hashbuild(Relation heap,
  *	for the new tuple, put it there, and return an InsertIndexResult
  *	to the caller.
  */
-InsertIndexResult
-hashinsert(Relation rel, Datum *datum, char *nulls, ItemPointer ht_ctid, Relation heapRel)
+Datum
+hashinsert(PG_FUNCTION_ARGS)
 {
+	Relation		rel = (Relation) PG_GETARG_POINTER(0);
+	Datum		   *datum = (Datum *) PG_GETARG_POINTER(1);
+	char		   *nulls = (char *) PG_GETARG_POINTER(2);
+	ItemPointer		ht_ctid = (ItemPointer) PG_GETARG_POINTER(3);
+#ifdef NOT_USED
+	Relation		heapRel = (Relation) PG_GETARG_POINTER(4);
+#endif
+	InsertIndexResult res;
 	HashItem	hitem;
 	IndexTuple	itup;
-	InsertIndexResult res;
-
 
 	/* generate an index tuple */
 	itup = index_formtuple(RelationGetDescr(rel), datum, nulls);
 	itup->t_tid = *ht_ctid;
 
 	if (itup->t_info & INDEX_NULL_MASK)
-		return (InsertIndexResult) NULL;
+		PG_RETURN_POINTER((InsertIndexResult) NULL);
 
 	hitem = _hash_formitem(itup);
 
@@ -293,16 +304,18 @@ hashinsert(Relation rel, Datum *datum, char *nulls, ItemPointer ht_ctid, Relatio
 	pfree(hitem);
 	pfree(itup);
 
-	return res;
+	PG_RETURN_POINTER(res);
 }
 
 
 /*
  *	hashgettuple() -- Get the next tuple in the scan.
  */
-char *
-hashgettuple(IndexScanDesc scan, ScanDirection dir)
+Datum
+hashgettuple(PG_FUNCTION_ARGS)
 {
+	IndexScanDesc		scan = (IndexScanDesc) PG_GETARG_POINTER(0);
+	ScanDirection		dir = (ScanDirection) PG_GETARG_INT32(1);
 	RetrieveIndexResult res;
 
 	/*
@@ -316,19 +329,20 @@ hashgettuple(IndexScanDesc scan, ScanDirection dir)
 	else
 		res = _hash_first(scan, dir);
 
-	return (char *) res;
+	PG_RETURN_POINTER(res);
 }
 
 
 /*
  *	hashbeginscan() -- start a scan on a hash index
  */
-char *
-hashbeginscan(Relation rel,
-			  bool fromEnd,
-			  uint16 keysz,
-			  ScanKey scankey)
+Datum
+hashbeginscan(PG_FUNCTION_ARGS)
 {
+	Relation	rel = (Relation) PG_GETARG_POINTER(0);
+	bool		fromEnd = PG_GETARG_BOOL(1);
+	uint16		keysz = PG_GETARG_UINT16(2);
+	ScanKey		scankey = (ScanKey) PG_GETARG_POINTER(3);
 	IndexScanDesc scan;
 	HashScanOpaque so;
 
@@ -341,15 +355,20 @@ hashbeginscan(Relation rel,
 	/* register scan in case we change pages it's using */
 	_hash_regscan(scan);
 
-	return (char *) scan;
+	PG_RETURN_POINTER(scan);
 }
 
 /*
  *	hashrescan() -- rescan an index relation
  */
-void
-hashrescan(IndexScanDesc scan, bool fromEnd, ScanKey scankey)
+Datum
+hashrescan(PG_FUNCTION_ARGS)
 {
+	IndexScanDesc	scan = (IndexScanDesc) PG_GETARG_POINTER(0);
+#ifdef NOT_USED					/* XXX surely it's wrong to ignore this? */
+	bool			fromEnd = PG_GETARG_BOOL(1);
+#endif
+	ScanKey			scankey = (ScanKey) PG_GETARG_POINTER(2);
 	ItemPointer iptr;
 	HashScanOpaque so;
 
@@ -376,15 +395,17 @@ hashrescan(IndexScanDesc scan, bool fromEnd, ScanKey scankey)
 				scankey,
 				scan->numberOfKeys * sizeof(ScanKeyData));
 	}
+
+	PG_RETURN_POINTER(NULL);	/* no real return value */
 }
 
 /*
  *	hashendscan() -- close down a scan
  */
-void
-hashendscan(IndexScanDesc scan)
+Datum
+hashendscan(PG_FUNCTION_ARGS)
 {
-
+	IndexScanDesc	scan = (IndexScanDesc) PG_GETARG_POINTER(0);
 	ItemPointer iptr;
 	HashScanOpaque so;
 
@@ -411,26 +432,21 @@ hashendscan(IndexScanDesc scan)
 
 	/* be tidy */
 	pfree(scan->opaque);
+
+	PG_RETURN_POINTER(NULL);	/* no real return value */
 }
 
 /*
  *	hashmarkpos() -- save current scan position
  *
  */
-void
-hashmarkpos(IndexScanDesc scan)
+Datum
+hashmarkpos(PG_FUNCTION_ARGS)
 {
+	IndexScanDesc	scan = (IndexScanDesc) PG_GETARG_POINTER(0);
 	ItemPointer iptr;
 	HashScanOpaque so;
 
-	/*
-	 * see if we ever call this code. if we do, then so_mrkbuf a useful
-	 * element in the scan->opaque structure. if this procedure is never
-	 * called, so_mrkbuf should be removed from the scan->opaque
-	 * structure.
-	 */
-	elog(NOTICE, "Hashmarkpos() called.");
-
 	so = (HashScanOpaque) scan->opaque;
 
 	/* release lock on old marked data, if any */
@@ -449,25 +465,20 @@ hashmarkpos(IndexScanDesc scan)
 										 HASH_READ);
 		scan->currentMarkData = scan->currentItemData;
 	}
+
+	PG_RETURN_POINTER(NULL);	/* no real return value */
 }
 
 /*
  *	hashrestrpos() -- restore scan to last saved position
  */
-void
-hashrestrpos(IndexScanDesc scan)
+Datum
+hashrestrpos(PG_FUNCTION_ARGS)
 {
+	IndexScanDesc	scan = (IndexScanDesc) PG_GETARG_POINTER(0);
 	ItemPointer iptr;
 	HashScanOpaque so;
 
-	/*
-	 * see if we ever call this code. if we do, then so_mrkbuf a useful
-	 * element in the scan->opaque structure. if this procedure is never
-	 * called, so_mrkbuf should be removed from the scan->opaque
-	 * structure.
-	 */
-	elog(NOTICE, "Hashrestrpos() called.");
-
 	so = (HashScanOpaque) scan->opaque;
 
 	/* release lock on current data, if any */
@@ -487,15 +498,22 @@ hashrestrpos(IndexScanDesc scan)
 
 		scan->currentItemData = scan->currentMarkData;
 	}
+
+	PG_RETURN_POINTER(NULL);	/* no real return value */
 }
 
 /* stubs */
-void
-hashdelete(Relation rel, ItemPointer tid)
+Datum
+hashdelete(PG_FUNCTION_ARGS)
 {
+	Relation		rel = (Relation) PG_GETARG_POINTER(0);
+	ItemPointer		tid = (ItemPointer) PG_GETARG_POINTER(1);
+
 	/* adjust any active scans that will be affected by this deletion */
 	_hash_adjscans(rel, tid);
 
 	/* delete the data from the page */
 	_hash_pagedel(rel, tid);
+
+	PG_RETURN_POINTER(NULL);	/* no real return value */
 }

src/backend/access/index/indexam.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/index/indexam.c,v 1.44 2000/05/30 04:24:32 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/index/indexam.c,v 1.45 2000/06/13 07:34:35 tgl Exp $
  *
  * INTERFACE ROUTINES
  *		index_open		- open an index relation by relationId
@@ -195,13 +195,12 @@ index_insert(Relation relation,
 	 * ----------------
 	 */
 	specificResult = (InsertIndexResult)
-		DatumGetPointer(OidFunctionCall6(procedure,
+		DatumGetPointer(OidFunctionCall5(procedure,
 										 PointerGetDatum(relation),
 										 PointerGetDatum(datum),
 										 PointerGetDatum(nulls),
 										 PointerGetDatum(heap_t_ctid),
-										 PointerGetDatum(heapRel),
-										 PointerGetDatum(NULL)));
+										 PointerGetDatum(heapRel)));
 
 	/* must be pfree'ed */
 	return specificResult;

src/backend/access/nbtree/nbtree.c

@@ -12,7 +12,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtree.c,v 1.55 2000/05/31 00:28:14 petere Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtree.c,v 1.56 2000/06/13 07:34:38 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -42,17 +42,20 @@ static void _bt_restscan(IndexScanDesc scan);
  *		since the index won't be visible until this transaction commits
  *		and since building is guaranteed to be single-threaded.
  */
-void
-btbuild(Relation heap,
-		Relation index,
-		int natts,
-		AttrNumber *attnum,
-		IndexStrategy istrat,
-		uint16 pcount,
-		Datum *params,
-		FuncIndexInfo *finfo,
-		PredInfo *predInfo)
+Datum
+btbuild(PG_FUNCTION_ARGS)
 {
+	Relation		heap = (Relation) PG_GETARG_POINTER(0);
+	Relation		index = (Relation) PG_GETARG_POINTER(1);
+	int32			natts = PG_GETARG_INT32(2);
+	AttrNumber	   *attnum = (AttrNumber *) PG_GETARG_POINTER(3);
+#ifdef NOT_USED
+	IndexStrategy	istrat = (IndexStrategy) PG_GETARG_POINTER(4);
+	uint16			pcount = PG_GETARG_UINT16(5);
+	Datum		   *params = (Datum *) PG_GETARG_POINTER(6);
+#endif
+	FuncIndexInfo  *finfo = (FuncIndexInfo *) PG_GETARG_POINTER(7);
+	PredInfo	   *predInfo = (PredInfo *) PG_GETARG_POINTER(8);
 	HeapScanDesc hscan;
 	HeapTuple	htup;
 	IndexTuple	itup;
@@ -332,6 +335,8 @@ btbuild(Relation heap,
 
 	/* all done */
 	BuildingBtree = false;
+
+	PG_RETURN_POINTER(NULL);	/* no real return value */
 }
 
 /*
@@ -341,12 +346,17 @@ btbuild(Relation heap,
  *		new tuple, put it there, set its unique OID as appropriate, and
  *		return an InsertIndexResult to the caller.
  */
-InsertIndexResult
-btinsert(Relation rel, Datum *datum, char *nulls, ItemPointer ht_ctid, Relation heapRel)
+Datum
+btinsert(PG_FUNCTION_ARGS)
 {
+	Relation		rel = (Relation) PG_GETARG_POINTER(0);
+	Datum		   *datum = (Datum *) PG_GETARG_POINTER(1);
+	char		   *nulls = (char *) PG_GETARG_POINTER(2);
+	ItemPointer		ht_ctid = (ItemPointer) PG_GETARG_POINTER(3);
+	Relation		heapRel = (Relation) PG_GETARG_POINTER(4);
+	InsertIndexResult res;
 	BTItem		btitem;
 	IndexTuple	itup;
-	InsertIndexResult res;
 
 	/* generate an index tuple */
 	itup = index_formtuple(RelationGetDescr(rel), datum, nulls);
@@ -355,7 +365,8 @@ btinsert(Relation rel, Datum *datum, char *nulls, ItemPointer ht_ctid, Relation
 	/*
 	 * See comments in btbuild.
 	 *
-	 * if (itup->t_info & INDEX_NULL_MASK) return (InsertIndexResult) NULL;
+	 * if (itup->t_info & INDEX_NULL_MASK)
+	 *		PG_RETURN_POINTER((InsertIndexResult) NULL);
 	 */
 
 	btitem = _bt_formitem(itup);
@@ -366,15 +377,17 @@ btinsert(Relation rel, Datum *datum, char *nulls, ItemPointer ht_ctid, Relation
 	pfree(btitem);
 	pfree(itup);
 
-	return res;
+	PG_RETURN_POINTER(res);
 }
 
 /*
  *	btgettuple() -- Get the next tuple in the scan.
  */
-char *
-btgettuple(IndexScanDesc scan, ScanDirection dir)
+Datum
+btgettuple(PG_FUNCTION_ARGS)
 {
+	IndexScanDesc		scan = (IndexScanDesc) PG_GETARG_POINTER(0);
+	ScanDirection		dir = (ScanDirection) PG_GETARG_INT32(1);
 	RetrieveIndexResult res;
 
 	/*
@@ -403,18 +416,23 @@ btgettuple(IndexScanDesc scan, ScanDirection dir)
 	if (res)
 	{
 		((BTScanOpaque) scan->opaque)->curHeapIptr = res->heap_iptr;
-		LockBuffer(((BTScanOpaque) scan->opaque)->btso_curbuf, BUFFER_LOCK_UNLOCK);
+		LockBuffer(((BTScanOpaque) scan->opaque)->btso_curbuf,
+				   BUFFER_LOCK_UNLOCK);
 	}
 
-	return (char *) res;
+	PG_RETURN_POINTER(res);
 }
 
 /*
  *	btbeginscan() -- start a scan on a btree index
  */
-char *
-btbeginscan(Relation rel, bool fromEnd, uint16 keysz, ScanKey scankey)
+Datum
+btbeginscan(PG_FUNCTION_ARGS)
 {
+	Relation	rel = (Relation) PG_GETARG_POINTER(0);
+	bool		fromEnd = PG_GETARG_BOOL(1);
+	uint16		keysz = PG_GETARG_UINT16(2);
+	ScanKey		scankey = (ScanKey) PG_GETARG_POINTER(3);
 	IndexScanDesc scan;
 
 	/* get the scan */
@@ -423,15 +441,20 @@ btbeginscan(Relation rel, bool fromEnd, uint16 keysz, ScanKey scankey)
 	/* register scan in case we change pages it's using */
 	_bt_regscan(scan);
 
-	return (char *) scan;
+	PG_RETURN_POINTER(scan);
 }
 
 /*
  *	btrescan() -- rescan an index relation
  */
-void
-btrescan(IndexScanDesc scan, bool fromEnd, ScanKey scankey)
+Datum
+btrescan(PG_FUNCTION_ARGS)
 {
+	IndexScanDesc	scan = (IndexScanDesc) PG_GETARG_POINTER(0);
+#ifdef NOT_USED					/* XXX surely it's wrong to ignore this? */
+	bool			fromEnd = PG_GETARG_BOOL(1);
+#endif
+	ScanKey			scankey = (ScanKey) PG_GETARG_POINTER(2);
 	ItemPointer iptr;
 	BTScanOpaque so;
 
@@ -479,6 +502,7 @@ btrescan(IndexScanDesc scan, bool fromEnd, ScanKey scankey)
 				so->numberOfKeys * sizeof(ScanKeyData));
 	}
 
+	PG_RETURN_POINTER(NULL);	/* no real return value */
 }
 
 void
@@ -504,9 +528,10 @@ btmovescan(IndexScanDesc scan, Datum v)
 /*
  *	btendscan() -- close down a scan
  */
-void
-btendscan(IndexScanDesc scan)
+Datum
+btendscan(PG_FUNCTION_ARGS)
 {
+	IndexScanDesc	scan = (IndexScanDesc) PG_GETARG_POINTER(0);
 	ItemPointer iptr;
 	BTScanOpaque so;
 
@@ -534,14 +559,17 @@ btendscan(IndexScanDesc scan)
 	pfree(so);
 
 	_bt_dropscan(scan);
+
+	PG_RETURN_POINTER(NULL);	/* no real return value */
 }
 
 /*
  *	btmarkpos() -- save current scan position
  */
-void
-btmarkpos(IndexScanDesc scan)
+Datum
+btmarkpos(PG_FUNCTION_ARGS)
 {
+	IndexScanDesc	scan = (IndexScanDesc) PG_GETARG_POINTER(0);
 	ItemPointer iptr;
 	BTScanOpaque so;
 
@@ -563,14 +591,17 @@ btmarkpos(IndexScanDesc scan)
 		scan->currentMarkData = scan->currentItemData;
 		so->mrkHeapIptr = so->curHeapIptr;
 	}
+
+	PG_RETURN_POINTER(NULL);	/* no real return value */
 }
 
 /*
  *	btrestrpos() -- restore scan to last saved position
  */
-void
-btrestrpos(IndexScanDesc scan)
+Datum
+btrestrpos(PG_FUNCTION_ARGS)
 {
+	IndexScanDesc	scan = (IndexScanDesc) PG_GETARG_POINTER(0);
 	ItemPointer iptr;
 	BTScanOpaque so;
 
@@ -593,17 +624,24 @@ btrestrpos(IndexScanDesc scan)
 		scan->currentItemData = scan->currentMarkData;
 		so->curHeapIptr = so->mrkHeapIptr;
 	}
+
+	PG_RETURN_POINTER(NULL);	/* no real return value */
 }
 
 /* stubs */
-void
-btdelete(Relation rel, ItemPointer tid)
+Datum
+btdelete(PG_FUNCTION_ARGS)
 {
+	Relation		rel = (Relation) PG_GETARG_POINTER(0);
+	ItemPointer		tid = (ItemPointer) PG_GETARG_POINTER(1);
+
 	/* adjust any active scans that will be affected by this deletion */
 	_bt_adjscans(rel, tid);
 
 	/* delete the data from the page */
 	_bt_pagedel(rel, tid);
+
+	PG_RETURN_POINTER(NULL);	/* no real return value */
 }
 
 static void

src/backend/access/rtree/rtget.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtget.c,v 1.20 2000/01/26 05:56:00 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtget.c,v 1.21 2000/06/13 07:34:48 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -28,21 +28,23 @@ static RetrieveIndexResult rtnext(IndexScanDesc s, ScanDirection dir);
 static ItemPointer rtheapptr(Relation r, ItemPointer itemp);
 
 
-RetrieveIndexResult
-rtgettuple(IndexScanDesc s, ScanDirection dir)
+Datum
+rtgettuple(PG_FUNCTION_ARGS)
 {
+	IndexScanDesc		s = (IndexScanDesc) PG_GETARG_POINTER(0);
+	ScanDirection		dir = (ScanDirection) PG_GETARG_INT32(1);
 	RetrieveIndexResult res;
 
 	/* if we have it cached in the scan desc, just return the value */
 	if ((res = rtscancache(s, dir)) != (RetrieveIndexResult) NULL)
-		return res;
+		PG_RETURN_POINTER(res);
 
 	/* not cached, so we'll have to do some work */
 	if (ItemPointerIsValid(&(s->currentItemData)))
 		res = rtnext(s, dir);
 	else
 		res = rtfirst(s, dir);
-	return res;
+	PG_RETURN_POINTER(res);
 }
 
 static RetrieveIndexResult

src/backend/access/rtree/rtproc.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtproc.c,v 1.25 2000/01/26 05:56:00 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtproc.c,v 1.26 2000/06/13 07:34:49 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -102,13 +102,15 @@ rt_poly_union(POLYGON *a, POLYGON *b)
 	return p;
 }
 
-void
-rt_poly_size(POLYGON *a, float *size)
+Datum
+rt_poly_size(PG_FUNCTION_ARGS)
 {
+	POLYGON	   *a = PG_GETARG_POLYGON_P(0);
+	/* NB: size is an output argument */
+	float	   *size = (float *) PG_GETARG_POINTER(1);
 	double		xdim,
 				ydim;
 
-	size = (float *) palloc(sizeof(float));
 	if (a == (POLYGON *) NULL ||
 		a->boundbox.high.x <= a->boundbox.low.x ||
 		a->boundbox.high.y <= a->boundbox.low.y)
@@ -121,7 +123,7 @@ rt_poly_size(POLYGON *a, float *size)
 		*size = (float) (xdim * ydim);
 	}
 
-	return;
+	PG_RETURN_POINTER(NULL);	/* no real return value */
 }
 
 POLYGON    *

src/backend/access/rtree/rtree.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtree.c,v 1.47 2000/05/30 04:24:34 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtree.c,v 1.48 2000/06/13 07:34:49 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -59,17 +59,20 @@ static int	nospace(Page p, IndexTuple it);
 static void initRtstate(RTSTATE *rtstate, Relation index);
 
 
-void
-rtbuild(Relation heap,
-		Relation index,
-		int natts,
-		AttrNumber *attnum,
-		IndexStrategy istrat,
-		uint16 pcount,
-		Datum *params,
-		FuncIndexInfo *finfo,
-		PredInfo *predInfo)
+Datum
+rtbuild(PG_FUNCTION_ARGS)
 {
+	Relation		heap = (Relation) PG_GETARG_POINTER(0);
+	Relation		index = (Relation) PG_GETARG_POINTER(1);
+	int32			natts = PG_GETARG_INT32(2);
+	AttrNumber	   *attnum = (AttrNumber *) PG_GETARG_POINTER(3);
+#ifdef NOT_USED
+	IndexStrategy	istrat = (IndexStrategy) PG_GETARG_POINTER(4);
+	uint16			pcount = PG_GETARG_UINT16(5);
+	Datum		   *params = (Datum *) PG_GETARG_POINTER(6);
+#endif
+	FuncIndexInfo  *finfo = (FuncIndexInfo *) PG_GETARG_POINTER(7);
+	PredInfo	   *predInfo = (PredInfo *) PG_GETARG_POINTER(8);
 	HeapScanDesc scan;
 	AttrNumber	i;
 	HeapTuple	htup;
@@ -277,6 +280,8 @@ rtbuild(Relation heap,
 	/* be tidy */
 	pfree(nulls);
 	pfree(d);
+
+	PG_RETURN_POINTER(NULL);	/* no real return value */
 }
 
 /*
@@ -285,9 +290,16 @@ rtbuild(Relation heap,
  *	  This is the public interface routine for tuple insertion in rtrees.
  *	  It doesn't do any work; just locks the relation and passes the buck.
  */
-InsertIndexResult
-rtinsert(Relation r, Datum *datum, char *nulls, ItemPointer ht_ctid, Relation heapRel)
+Datum
+rtinsert(PG_FUNCTION_ARGS)
 {
+	Relation		r = (Relation) PG_GETARG_POINTER(0);
+	Datum		   *datum = (Datum *) PG_GETARG_POINTER(1);
+	char		   *nulls = (char *) PG_GETARG_POINTER(2);
+	ItemPointer		ht_ctid = (ItemPointer) PG_GETARG_POINTER(3);
+#ifdef NOT_USED
+	Relation		heapRel = (Relation) PG_GETARG_POINTER(4);
+#endif
 	InsertIndexResult res;
 	IndexTuple	itup;
 	RTSTATE		rtState;
@@ -305,7 +317,7 @@ rtinsert(Relation r, Datum *datum, char *nulls, ItemPointer ht_ctid, Relation he
 
 	res = rtdoinsert(r, itup, &rtState);
 
-	return res;
+	PG_RETURN_POINTER(res);
 }
 
 static InsertIndexResult
@@ -982,9 +994,11 @@ freestack(RTSTACK *s)
 	}
 }
 
-char *
-rtdelete(Relation r, ItemPointer tid)
+Datum
+rtdelete(PG_FUNCTION_ARGS)
 {
+	Relation		r = (Relation) PG_GETARG_POINTER(0);
+	ItemPointer		tid = (ItemPointer) PG_GETARG_POINTER(1);
 	BlockNumber blkno;
 	OffsetNumber offnum;
 	Buffer		buf;
@@ -1011,7 +1025,7 @@ rtdelete(Relation r, ItemPointer tid)
 
 	WriteBuffer(buf);
 
-	return (char *) NULL;
+	PG_RETURN_POINTER(NULL);	/* no real return value */
 }
 
 static void

src/backend/access/rtree/rtscan.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtscan.c,v 1.32 2000/04/12 17:14:51 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtscan.c,v 1.33 2000/06/13 07:34:49 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -51,12 +51,13 @@ typedef RTScanListData *RTScanList;
 /* pointer to list of local scans on rtrees */
 static RTScanList RTScans = (RTScanList) NULL;
 
-IndexScanDesc
-rtbeginscan(Relation r,
-			bool fromEnd,
-			uint16 nkeys,
-			ScanKey key)
+Datum
+rtbeginscan(PG_FUNCTION_ARGS)
 {
+	Relation	r = (Relation) PG_GETARG_POINTER(0);
+	bool		fromEnd = PG_GETARG_BOOL(1);
+	uint16		nkeys = PG_GETARG_UINT16(2);
+	ScanKey		key = (ScanKey) PG_GETARG_POINTER(3);
 	IndexScanDesc s;
 
 	/*
@@ -68,22 +69,19 @@ rtbeginscan(Relation r,
 	s = RelationGetIndexScan(r, fromEnd, nkeys, key);
 	rtregscan(s);
 
-	return s;
+	PG_RETURN_POINTER(s);
 }
 
-void
-rtrescan(IndexScanDesc s, bool fromEnd, ScanKey key)
+Datum
+rtrescan(PG_FUNCTION_ARGS)
 {
+	IndexScanDesc	s = (IndexScanDesc) PG_GETARG_POINTER(0);
+	bool			fromEnd = PG_GETARG_BOOL(1);
+	ScanKey			key = (ScanKey) PG_GETARG_POINTER(2);
 	RTreeScanOpaque p;
 	RegProcedure internal_proc;
 	int			i;
 
-	if (!IndexScanIsValid(s))
-	{
-		elog(ERROR, "rtrescan: invalid scan.");
-		return;
-	}
-
 	/*
 	 * Clear all the pointers.
 	 */
@@ -157,11 +155,14 @@ rtrescan(IndexScanDesc s, bool fromEnd, ScanKey key)
 			}
 		}
 	}
+
+	PG_RETURN_POINTER(NULL);	/* no real return value */
 }
 
-void
-rtmarkpos(IndexScanDesc s)
+Datum
+rtmarkpos(PG_FUNCTION_ARGS)
 {
+	IndexScanDesc	s = (IndexScanDesc) PG_GETARG_POINTER(0);
 	RTreeScanOpaque p;
 	RTSTACK    *o,
 			   *n,
@@ -190,11 +191,14 @@ rtmarkpos(IndexScanDesc s)
 
 	freestack(p->s_markstk);
 	p->s_markstk = o;
+
+	PG_RETURN_POINTER(NULL);	/* no real return value */
 }
 
-void
-rtrestrpos(IndexScanDesc s)
+Datum
+rtrestrpos(PG_FUNCTION_ARGS)
 {
+	IndexScanDesc	s = (IndexScanDesc) PG_GETARG_POINTER(0);
 	RTreeScanOpaque p;
 	RTSTACK    *o,
 			   *n,
@@ -223,11 +227,14 @@ rtrestrpos(IndexScanDesc s)
 
 	freestack(p->s_stack);
 	p->s_stack = o;
+
+	PG_RETURN_POINTER(NULL);	/* no real return value */
 }
 
-void
-rtendscan(IndexScanDesc s)
+Datum
+rtendscan(PG_FUNCTION_ARGS)
 {
+	IndexScanDesc	s = (IndexScanDesc) PG_GETARG_POINTER(0);
 	RTreeScanOpaque p;
 
 	p = (RTreeScanOpaque) s->opaque;
@@ -241,6 +248,8 @@ rtendscan(IndexScanDesc s)
 
 	rtdropscan(s);
 	/* XXX don't unset read lock -- two-phase locking */
+
+	PG_RETURN_POINTER(NULL);	/* no real return value */
 }
 
 static void

src/backend/catalog/pg_type.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/catalog/pg_type.c,v 1.51 2000/05/28 17:55:54 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/catalog/pg_type.c,v 1.52 2000/06/13 07:34:52 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -409,8 +409,8 @@ TypeCreate(char *typeName,
 			/*
 			 * For array types, the input procedures may take 3 args (data
 			 * value, element OID, atttypmod); the pg_proc argtype
-			 * signature is 0,0,INT4OID.  The output procedures may take 2
-			 * args (data value, element OID).
+			 * signature is 0,OIDOID,INT4OID.  The output procedures may
+			 * take 2 args (data value, element OID).
 			 */
 			if (OidIsValid(elementObjectId))
 			{
@@ -420,11 +420,13 @@ TypeCreate(char *typeName,
 				{
 					/* output proc */
 					nargs = 2;
+					argList[1] = OIDOID;
 				}
 				else
 				{
 					/* input proc */
 					nargs = 3;
+					argList[1] = OIDOID;
 					argList[2] = INT4OID;
 				}
 				tup = SearchSysCacheTuple(PROCNAME,

src/backend/executor/execQual.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.70 2000/05/28 17:55:55 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.71 2000/06/13 07:34:58 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -105,6 +105,7 @@ ExecEvalArrayRef(ArrayRef *arrayRef,
 												   econtext,
 												   isNull,
 												   isDone);
+		/* If refexpr yields NULL, result is always NULL, for now anyway */
 		if (*isNull)
 			return (Datum) NULL;
 	}
@@ -132,6 +133,7 @@ ExecEvalArrayRef(ArrayRef *arrayRef,
 											   econtext,
 											   isNull,
 											   &dummy);
+		/* If any index expr yields NULL, result is NULL */
 		if (*isNull)
 			return (Datum) NULL;
 	}
@@ -148,6 +150,7 @@ ExecEvalArrayRef(ArrayRef *arrayRef,
 												   econtext,
 												   isNull,
 												   &dummy);
+			/* If any index expr yields NULL, result is NULL */
 			if (*isNull)
 				return (Datum) NULL;
 		}
@@ -165,7 +168,7 @@ ExecEvalArrayRef(ArrayRef *arrayRef,
 											  econtext,
 											  isNull,
 											  &dummy);
-
+		/* For now, can't cope with inserting NULL into an array */
 		if (*isNull)
 			return (Datum) NULL;
 
@@ -175,30 +178,43 @@ ExecEvalArrayRef(ArrayRef *arrayRef,
 		if (array_scanner == NULL)
 			return sourceData;	/* XXX do something else? */
 
+		/*
+		 * XXX shouldn't we copy the array value before modifying it??
+		 *
+		 * Or perhaps these array routines should deliver a modified copy
+		 * instead of changing the source in-place.
+		 */
 		if (lIndex == NULL)
-			return (Datum) array_set(array_scanner, i, upper.indx,
-									 (char *) sourceData,
-									 arrayRef->refelembyval,
-									 arrayRef->refelemlength,
-									 arrayRef->refattrlength, isNull);
-		return (Datum) array_assgn(array_scanner, i, upper.indx,
-								   lower.indx,
-								   (ArrayType *) sourceData,
-								   arrayRef->refelembyval,
-								   arrayRef->refelemlength, isNull);
+			return PointerGetDatum(array_set(array_scanner, i,
+											 upper.indx,
+											 sourceData,
+											 arrayRef->refelembyval,
+											 arrayRef->refelemlength,
+											 arrayRef->refattrlength,
+											 isNull));
+		return PointerGetDatum(array_assgn(array_scanner, i,
+										   upper.indx, lower.indx,
+										   (ArrayType *) DatumGetPointer(sourceData),
+										   arrayRef->refelembyval,
+										   arrayRef->refelemlength,
+										   isNull));
 	}
 
 	execConstByVal = arrayRef->refelembyval;
 	execConstLen = arrayRef->refelemlength;
 
 	if (lIndex == NULL)
-		return (Datum) array_ref(array_scanner, i, upper.indx,
-								 arrayRef->refelembyval,
-								 arrayRef->refelemlength,
-								 arrayRef->refattrlength, isNull);
-	return (Datum) array_clip(array_scanner, i, upper.indx, lower.indx,
-							  arrayRef->refelembyval,
-							  arrayRef->refelemlength, isNull);
+		return array_ref(array_scanner, i,
+						 upper.indx,
+						 arrayRef->refelembyval,
+						 arrayRef->refelemlength,
+						 arrayRef->refattrlength,
+						 isNull);
+	return PointerGetDatum(array_clip(array_scanner, i,
+									  upper.indx, lower.indx,
+									  arrayRef->refelembyval,
+									  arrayRef->refelemlength,
+									  isNull));
 }
 
 

src/backend/parser/parse_node.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_node.c,v 1.40 2000/05/28 17:56:00 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_node.c,v 1.41 2000/06/13 07:35:01 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -450,7 +450,10 @@ make_const(Value *value)
 			}
 			else
 			{
-				val = PointerGetDatum(numeric_in(strVal(value), 0, -1));
+				val = DirectFunctionCall3(numeric_in,
+										  CStringGetDatum(strVal(value)),
+										  ObjectIdGetDatum(InvalidOid),
+										  Int32GetDatum(-1));
 
 				typeid = NUMERICOID;
 				typelen = -1;	/* variable len */

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.37 2000/06/05 07:28:51 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/cash.c,v 1.38 2000/06/13 07:35:03 tgl Exp $
  */
 
 #include <limits.h>
@@ -535,31 +535,31 @@ cash_div_flt4(Cash *c, float4 *f)
 /* cash_mul_int4()
  * Multiply cash by int4.
  */
-Cash *
-cash_mul_int4(Cash *c, int4 i)
+Datum
+cash_mul_int4(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 = ((i) * (*c));
+	Cash		c = PG_GETARG_CASH(0);
+	int32		i = PG_GETARG_INT32(1);
+	Cash		result;
 
-	return result;
-}	/* cash_mul_int4() */
+	result = c * i;
+	PG_RETURN_CASH(result);
+}
 
 
 /* int4_mul_cash()
  * Multiply int4 by cash.
  */
-Cash *
-int4_mul_cash(int4 i, Cash *c)
+Datum
+int4_mul_cash(PG_FUNCTION_ARGS)
 {
-	return cash_mul_int4(c, i);
-}	/* int4_mul_cash() */
+	int32		i = PG_GETARG_INT32(0);
+	Cash		c = PG_GETARG_CASH(1);
+	Cash		result;
+
+	result = i * c;
+	PG_RETURN_CASH(result);
+}
 
 
 /* cash_div_int4()
@@ -568,24 +568,20 @@ int4_mul_cash(int4 i, Cash *c)
  * XXX Don't know if rounding or truncating is correct behavior.
  * Round for now. - tgl 97/04/15
  */
-Cash *
-cash_div_int4(Cash *c, int4 i)
+Datum
+cash_div_int4(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);
+	int32		i = PG_GETARG_INT32(1);
+	Cash		result;
 
 	if (i == 0)
-		elog(ERROR, "cash_idiv:  divide by 0 error");
+		elog(ERROR, "cash_div_int4: divide by 0 error");
 
-	*result = rint(*c / i);
+	result = rint(c / i);
 
-	return result;
-}	/* cash_div_int4() */
+	PG_RETURN_CASH(result);
+}
 
 
 /* cash_mul_int2()

src/backend/utils/adt/chunk.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/chunk.c,v 1.26 2000/06/09 01:11:08 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/chunk.c,v 1.27 2000/06/13 07:35:03 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -517,7 +517,7 @@ _ReadChunkArray(int *st,
 										  Int32GetDatum(fp),
 										  Int32GetDatum(srcOff),
 										  Int32GetDatum(SEEK_SET))) < 0)
-		RETURN_NULL;
+		RETURN_NULL(int);
 
 	jj = n - 1;
 	for (i = 0; i < n; chunk_off[i++] = 0)
@@ -541,7 +541,7 @@ _ReadChunkArray(int *st,
 							  Int32GetDatum((int32) destfp),
 							  Int32GetDatum(bptr),
 							  Int32GetDatum(SEEK_SET))) < 0)
-				RETURN_NULL;
+				RETURN_NULL(int);
 		}
 		else
 			destfp = baseDestFp + bptr;
@@ -556,7 +556,7 @@ _ReadChunkArray(int *st,
 							  Int32GetDatum(fp),
 							  Int32GetDatum(srcOff),
 							  Int32GetDatum(SEEK_SET))) < 0)
-				RETURN_NULL;
+				RETURN_NULL(int);
 		}
 		for (i = n - 1, to_read = bsize; i >= 0;
 			 to_read *= min(C[i], array_span[i]), i--)
@@ -571,7 +571,7 @@ _ReadChunkArray(int *st,
 								  Int32GetDatum(fp),
 								  Int32GetDatum(srcOff),
 								  Int32GetDatum(SEEK_SET))) < 0)
-					RETURN_NULL;
+					RETURN_NULL(int);
 			}
 			block_seek += cdist[j];
 			bptr += adist[j] * bsize;
@@ -581,13 +581,13 @@ _ReadChunkArray(int *st,
 								  Int32GetDatum((int32) destfp),
 								  Int32GetDatum(bptr),
 								  Int32GetDatum(SEEK_SET))) < 0)
-					RETURN_NULL;
+					RETURN_NULL(int);
 			}
 			else
 				destfp = baseDestFp + bptr;
 			temp = _LOtransfer((char **) &destfp, to_read, 1, (char **) &fp, 1, isDestLO);
 			if (temp < to_read)
-				RETURN_NULL;
+				RETURN_NULL(int);
 			srcOff += to_read;
 			words_read += to_read;
 			bptr += to_read;
@@ -702,7 +702,7 @@ _ReadChunkArray1El(int *st,
 					  Int32GetDatum(fp),
 					  Int32GetDatum(srcOff),
 					  Int32GetDatum(SEEK_SET))) < 0)
-		RETURN_NULL;
+		RETURN_NULL(struct varlena *);
 #ifdef LOARRAY
 	return (struct varlena *)
 		DatumGetPointer(DirectFunctionCall2(loread,

src/backend/utils/adt/float.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/float.c,v 1.59 2000/06/08 22:37:28 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/float.c,v 1.60 2000/06/13 07:35:04 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -48,12 +48,11 @@
  */
 #include <ctype.h>
 #include <errno.h>
-
 #include <float.h>				/* faked on sunos4 */
-
 #include <math.h>
 
 #include "postgres.h"
+
 #ifdef HAVE_LIMITS_H
 #include <limits.h>
 #ifndef MAXINT
@@ -64,6 +63,7 @@
 #include <values.h>
 #endif
 #endif
+
 #include "fmgr.h"
 #include "utils/builtins.h"
 
@@ -844,15 +844,14 @@ dtoi2(PG_FUNCTION_ARGS)
 /*
  *		i4tod			- converts an int4 number to a float8 number
  */
-float64
-i4tod(int32 num)
+Datum
+i4tod(PG_FUNCTION_ARGS)
 {
-	float64		result;
-
-	result = (float64) palloc(sizeof(float64data));
+	int32		num = PG_GETARG_INT32(0);
+	float8		result;
 
-	*result = num;
-	return result;
+	result = num;
+	PG_RETURN_FLOAT8(result);
 }
 
 
@@ -909,15 +908,14 @@ ftoi2(PG_FUNCTION_ARGS)
 /*
  *		i4tof			- converts an int4 number to a float8 number
  */
-float32
-i4tof(int32 num)
+Datum
+i4tof(PG_FUNCTION_ARGS)
 {
-	float32		result;
-
-	result = (float32) palloc(sizeof(float32data));
+	int32		num = PG_GETARG_INT32(0);
+	float4		result;
 
-	*result = num;
-	return result;
+	result = num;
+	PG_RETURN_FLOAT4(result);
 }
 
 

src/backend/utils/adt/formatting.c

 /* -----------------------------------------------------------------------
  * formatting.c
  *
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/formatting.c,v 1.11 2000/06/09 03:18:34 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/formatting.c,v 1.12 2000/06/13 07:35:04 tgl Exp $
  *
  *
  *	 Portions Copyright (c) 1999-2000, PostgreSQL, Inc
@@ -3848,13 +3848,11 @@ NUM_processor(FormatNode *node, NUMDesc *Num, char *inout, char *number,
  * ----------
  */
 #define NUM_TOCHAR_prepare {							\
-	if (!PointerIsValid(fmt))					\
-		return NULL;						\
 									\
 	len = VARSIZE(fmt) - VARHDRSZ;					\
 									\
-	if (!len)							\
-		return textin("");					\
+	if (len <= 0)							\
+		return PointerGetDatum(textin(""));					\
 									\
 	result	= (text *) palloc( (len * NUM_MAX_ITEM_SIZ) + 1 + VARHDRSZ);	\
 	format	= NUM_cache(len, &Num, VARDATA(fmt), &flag);		\
@@ -3891,26 +3889,24 @@ NUM_processor(FormatNode *node, NUMDesc *Num, char *inout, char *number,
  * NUMERIC to_number() (convert string to numeric)
  * -------------------
  */
-Numeric
-numeric_to_number(text *value, text *fmt)
+Datum
+numeric_to_number(PG_FUNCTION_ARGS)
 {
+	text	   *value = PG_GETARG_TEXT_P(0);
+	text	   *fmt = PG_GETARG_TEXT_P(1);
 	NUMDesc		Num;
-	Numeric		result;
+	Datum		result;
 	FormatNode *format;
 	char	   *numstr;
 	int			flag = 0;
 	int			len = 0;
-
 	int			scale,
 				precision;
 
-	if ((!PointerIsValid(value)) || (!PointerIsValid(fmt)))
-		return NULL;
-
 	len = VARSIZE(fmt) - VARHDRSZ;
 
-	if (!len)
-		return numeric_in(NULL, 0, 0);
+	if (len <= 0)
+		PG_RETURN_NULL();
 
 	format = NUM_cache(len, &Num, VARDATA(fmt), &flag);
 
@@ -3925,7 +3921,10 @@ numeric_to_number(text *value, text *fmt)
 	if (flag)
 		pfree(format);
 
-	result = numeric_in(numstr, 0, ((precision << 16) | scale) + VARHDRSZ);
+	result = DirectFunctionCall3(numeric_in,
+								 CStringGetDatum(numstr),
+								 ObjectIdGetDatum(InvalidOid),
+								 Int32GetDatum(((precision << 16) | scale) + VARHDRSZ));
 	pfree(numstr);
 	return result;
 }
@@ -3934,9 +3933,11 @@ numeric_to_number(text *value, text *fmt)
  * NUMERIC to_char()
  * ------------------
  */
-text *
-numeric_to_char(Numeric value, text *fmt)
+Datum
+numeric_to_char(PG_FUNCTION_ARGS)
 {
+	Numeric		value = PG_GETARG_NUMERIC(0);
+	text	   *fmt = PG_GETARG_TEXT_P(1);
 	NUMDesc		Num;
 	FormatNode *format;
 	text	   *result,
@@ -3948,7 +3949,7 @@ numeric_to_char(Numeric value, text *fmt)
 	char	   *numstr,
 			   *orgnum,
 			   *p;
-	Numeric		x = NULL;
+	Numeric		x;
 
 	NUM_TOCHAR_prepare;
 
@@ -3958,10 +3959,11 @@ numeric_to_char(Numeric value, text *fmt)
 	 */
 	if (IS_ROMAN(&Num))
 	{
-		x = numeric_round(value, 0);
+		x = DatumGetNumeric(DirectFunctionCall2(numeric_round,
+												NumericGetDatum(value),
+												Int32GetDatum(0)));
 		numstr = orgnum = int_to_roman(numeric_int4(x));
 		pfree(x);
-
 	}
 	else
 	{
@@ -3969,8 +3971,10 @@ numeric_to_char(Numeric value, text *fmt)
 
 		if (IS_MULTI(&Num))
 		{
-			Numeric		a = int4_numeric(10);
-			Numeric		b = int4_numeric(Num.multi);
+			Numeric		a = DatumGetNumeric(DirectFunctionCall1(int4_numeric,
+											Int32GetDatum(10)));
+			Numeric		b = DatumGetNumeric(DirectFunctionCall1(int4_numeric,
+											Int32GetDatum(Num.multi)));
 
 			x = numeric_power(a, b);
 			val = numeric_mul(value, x);
@@ -3980,8 +3984,11 @@ numeric_to_char(Numeric value, text *fmt)
 			Num.pre += Num.multi;
 		}
 
-		x = numeric_round(val, Num.post);
-		orgnum = numeric_out(x);
+		x = DatumGetNumeric(DirectFunctionCall2(numeric_round,
+												NumericGetDatum(val),
+												Int32GetDatum(Num.post)));
+		orgnum = DatumGetCString(DirectFunctionCall1(numeric_out,
+													 NumericGetDatum(x)));
 		pfree(x);
 
 		if (*orgnum == '-')
@@ -4014,16 +4021,18 @@ numeric_to_char(Numeric value, text *fmt)
 	}
 
 	NUM_TOCHAR_finish;
-	return result;
+	PG_RETURN_TEXT_P(result);
 }
 
 /* ---------------
  * INT4 to_char()
  * ---------------
  */
-text *
-int4_to_char(int32 value, text *fmt)
+Datum
+int4_to_char(PG_FUNCTION_ARGS)
 {
+	int32		value = PG_GETARG_INT32(0);
+	text	   *fmt = PG_GETARG_TEXT_P(1);
 	NUMDesc		Num;
 	FormatNode *format;
 	text	   *result,
@@ -4044,7 +4053,6 @@ int4_to_char(int32 value, text *fmt)
 	if (IS_ROMAN(&Num))
 	{
 		numstr = orgnum = int_to_roman(value);
-
 	}
 	else
 	{
@@ -4097,16 +4105,18 @@ int4_to_char(int32 value, text *fmt)
 	}
 
 	NUM_TOCHAR_finish;
-	return result;
+	PG_RETURN_TEXT_P(result);
 }
 
 /* ---------------
  * INT8 to_char()
  * ---------------
  */
-text *
-int8_to_char(int64 *value, text *fmt)
+Datum
+int8_to_char(PG_FUNCTION_ARGS)
 {
+	int64		value = PG_GETARG_INT64(0);
+	text	   *fmt = PG_GETARG_TEXT_P(1);
 	NUMDesc		Num;
 	FormatNode *format;
 	text	   *result,
@@ -4126,8 +4136,9 @@ int8_to_char(int64 *value, text *fmt)
 	 */
 	if (IS_ROMAN(&Num))
 	{
-		numstr = orgnum = int_to_roman(int84(value));
-
+		/* Currently don't support int8 conversion to roman... */
+		numstr = orgnum = int_to_roman(DatumGetInt32(
+			DirectFunctionCall1(int84, Int64GetDatum(value))));
 	}
 	else
 	{
@@ -4135,11 +4146,15 @@ int8_to_char(int64 *value, text *fmt)
 		{
 			double		multi = pow((double) 10, (double) Num.multi);
 
-			orgnum = int8out(int8mul(value, dtoi8((float64) &multi)));
+			value = DatumGetInt64(DirectFunctionCall2(int8mul,
+								  Int64GetDatum(value),
+								  DirectFunctionCall1(dtoi8,
+													  Float8GetDatum(multi))));
 			Num.pre += Num.multi;
 		}
-		else
-			orgnum = int8out(value);
+
+		orgnum = DatumGetCString(DirectFunctionCall1(int8out,
+													 Int64GetDatum(value)));
 		len = strlen(orgnum);
 
 		if (*orgnum == '-')
@@ -4178,16 +4193,18 @@ int8_to_char(int64 *value, text *fmt)
 	}
 
 	NUM_TOCHAR_finish;
-	return result;
+	PG_RETURN_TEXT_P(result);
 }
 
 /* -----------------
  * FLOAT4 to_char()
  * -----------------
  */
-text *
-float4_to_char(float32 value, text *fmt)
+Datum
+float4_to_char(PG_FUNCTION_ARGS)
 {
+	float4		value = PG_GETARG_FLOAT4(0);
+	text	   *fmt = PG_GETARG_TEXT_P(1);
 	NUMDesc		Num;
 	FormatNode *format;
 	text	   *result,
@@ -4204,30 +4221,30 @@ float4_to_char(float32 value, text *fmt)
 
 	if (IS_ROMAN(&Num))
 	{
-		numstr = orgnum = int_to_roman((int) rint(*value));
+		numstr = orgnum = int_to_roman((int) rint(value));
 
 	}
 	else
 	{
-		float32		val = value;
+		float4		val = value;
 
 		if (IS_MULTI(&Num))
 		{
 			float		multi = pow((double) 10, (double) Num.multi);
 
-			val = float4mul(value, (float32) &multi);
+			val = value * multi;
 			Num.pre += Num.multi;
 		}
 
 		orgnum = (char *) palloc(MAXFLOATWIDTH + 1);
-		len = sprintf(orgnum, "%.0f", fabs(*val));
+		len = sprintf(orgnum, "%.0f", fabs(val));
 		if (Num.pre > len)
 			plen = Num.pre - len;
 		if (len >= FLT_DIG)
 			Num.post = 0;
 		else if (Num.post + len > FLT_DIG)
 			Num.post = FLT_DIG - len;
-		sprintf(orgnum, "%.*f", Num.post, *val);
+		sprintf(orgnum, "%.*f", Num.post, val);
 
 		if (*orgnum == '-')
 		{						/* < 0 */
@@ -4256,16 +4273,18 @@ float4_to_char(float32 value, text *fmt)
 	}
 
 	NUM_TOCHAR_finish;
-	return result;
+	PG_RETURN_TEXT_P(result);
 }
 
 /* -----------------
  * FLOAT8 to_char()
  * -----------------
  */
-text *
-float8_to_char(float64 value, text *fmt)
+Datum
+float8_to_char(PG_FUNCTION_ARGS)
 {
+	float8		value = PG_GETARG_FLOAT8(0);
+	text	   *fmt = PG_GETARG_TEXT_P(1);
 	NUMDesc		Num;
 	FormatNode *format;
 	text	   *result,
@@ -4282,29 +4301,29 @@ float8_to_char(float64 value, text *fmt)
 
 	if (IS_ROMAN(&Num))
 	{
-		numstr = orgnum = int_to_roman((int) rint(*value));
+		numstr = orgnum = int_to_roman((int) rint(value));
 
 	}
 	else
 	{
-		float64		val = value;
+		float8		val = value;
 
 		if (IS_MULTI(&Num))
 		{
 			double		multi = pow((double) 10, (double) Num.multi);
 
-			val = float8mul(value, (float64) &multi);
+			val = value * multi;
 			Num.pre += Num.multi;
 		}
 		orgnum = (char *) palloc(MAXDOUBLEWIDTH + 1);
-		len = sprintf(orgnum, "%.0f", fabs(*val));
+		len = sprintf(orgnum, "%.0f", fabs(val));
 		if (Num.pre > len)
 			plen = Num.pre - len;
 		if (len >= DBL_DIG)
 			Num.post = 0;
 		else if (Num.post + len > DBL_DIG)
 			Num.post = DBL_DIG - len;
-		sprintf(orgnum, "%.*f", Num.post, *val);
+		sprintf(orgnum, "%.*f", Num.post, val);
 
 		if (*orgnum == '-')
 		{						/* < 0 */
@@ -4333,5 +4352,5 @@ float8_to_char(float64 value, text *fmt)
 	}
 
 	NUM_TOCHAR_finish;
-	return result;
+	PG_RETURN_TEXT_P(result);
 }

src/backend/utils/adt/geo_ops.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/geo_ops.c,v 1.50 2000/04/12 17:15:50 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/geo_ops.c,v 1.51 2000/06/13 07:35:07 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -4361,22 +4361,21 @@ box_circle(BOX *box)
 }	/* box_circle() */
 
 
-POLYGON    *
-circle_poly(int npts, CIRCLE *circle)
+Datum
+circle_poly(PG_FUNCTION_ARGS)
 {
+	int32		npts = PG_GETARG_INT32(0);
+	CIRCLE	   *circle = PG_GETARG_CIRCLE_P(1);
 	POLYGON    *poly;
 	int			size;
 	int			i;
 	double		angle;
 
-	if (!PointerIsValid(circle))
-		return NULL;
-
 	if (FPzero(circle->radius) || (npts < 2))
 		elog(ERROR, "Unable to convert circle to polygon");
 
 	size = offsetof(POLYGON, p[0]) +(sizeof(poly->p[0]) * npts);
-	poly = palloc(size);
+	poly = (POLYGON *) palloc(size);
 
 	MemSet((char *) poly, 0, size);		/* zero any holes */
 	poly->size = size;
@@ -4391,7 +4390,7 @@ circle_poly(int npts, CIRCLE *circle)
 
 	make_bound_box(poly);
 
-	return poly;
+	PG_RETURN_POLYGON_P(poly);
 }
 
 /*		poly_circle		- convert polygon to circle

src/backend/utils/adt/numeric.c

@@ -5,7 +5,7 @@
  *
  *	1998 Jan Wieck
  *
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/numeric.c,v 1.28 2000/06/05 07:28:52 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/numeric.c,v 1.29 2000/06/13 07:35:07 tgl Exp $
  *
  * ----------
  */
@@ -33,9 +33,6 @@
  * 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
@@ -189,28 +186,23 @@ static void sub_abs(NumericVar *var1, NumericVar *var2, NumericVar *result);
  *	Input function for numeric data type
  * ----------
  */
-Numeric
-numeric_in(char *str, int dummy, int32 typmod)
+Datum
+numeric_in(PG_FUNCTION_ARGS)
 {
+	char	   *str = PG_GETARG_CSTRING(0);
+#ifdef NOT_USED
+	Oid			typelem = PG_GETARG_OID(1);
+#endif
+	int32		typmod = PG_GETARG_INT32(2);
 	NumericVar	value;
 	Numeric		res;
 
-	/* ----------
-	 * Check for NULL
-	 * ----------
-	 */
-	if (str == NULL)
-		return NULL;
-
-	if (strcmp(str, "NULL") == 0)
-		return NULL;
-
 	/* ----------
 	 * Check for NaN
 	 * ----------
 	 */
 	if (strcmp(str, "NaN") == 0)
-		return make_result(&const_nan);
+		PG_RETURN_NUMERIC(make_result(&const_nan));
 
 	/* ----------
 	 * Use set_var_from_str() to parse the input string
@@ -225,7 +217,7 @@ numeric_in(char *str, int dummy, int32 typmod)
 	res = make_result(&value);
 	free_var(&value);
 
-	return res;
+	PG_RETURN_NUMERIC(res);
 }
 
 
@@ -235,25 +227,19 @@ numeric_in(char *str, int dummy, int32 typmod)
  *	Output function for numeric data type
  * ----------
  */
-char *
-numeric_out(Numeric num)
+Datum
+numeric_out(PG_FUNCTION_ARGS)
 {
+	Numeric		num = PG_GETARG_NUMERIC(0);
 	NumericVar	x;
 	char	   *str;
 
-	/* ----------
-	 * Handle NULL
-	 * ----------
-	 */
-	if (num == NULL)
-		return pstrdup("NULL");
-
 	/* ----------
 	 * Handle NaN
 	 * ----------
 	 */
 	if (NUMERIC_IS_NAN(num))
-		return pstrdup("NaN");
+		PG_RETURN_CSTRING(pstrdup("NaN"));
 
 	/* ----------
 	 * Get the number in the variable format.
@@ -271,7 +257,7 @@ numeric_out(Numeric num)
 
 	free_var(&x);
 
-	return str;
+	PG_RETURN_CSTRING(str);
 }
 
 
@@ -283,9 +269,11 @@ numeric_out(Numeric num)
  *	scale of the attribute have to be applied on the value.
  * ----------
  */
-Numeric
-numeric(Numeric num, int32 typmod)
+Datum
+numeric(PG_FUNCTION_ARGS)
 {
+	Numeric		num = PG_GETARG_NUMERIC(0);
+	int32		typmod = PG_GETARG_INT32(1);
 	Numeric		new;
 	int32		tmp_typmod;
 	int			precision;
@@ -293,19 +281,12 @@ numeric(Numeric num, int32 typmod)
 	int			maxweight;
 	NumericVar	var;
 
-	/* ----------
-	 * Handle NULL
-	 * ----------
-	 */
-	if (num == NULL)
-		return NULL;
-
 	/* ----------
 	 * Handle NaN
 	 * ----------
 	 */
 	if (NUMERIC_IS_NAN(num))
-		return make_result(&const_nan);
+		PG_RETURN_NUMERIC(make_result(&const_nan));
 
 	/* ----------
 	 * If the value isn't a valid type modifier, simply return a
@@ -316,7 +297,7 @@ numeric(Numeric num, int32 typmod)
 	{
 		new = (Numeric) palloc(num->varlen);
 		memcpy(new, num, num->varlen);
-		return new;
+		PG_RETURN_NUMERIC(new);
 	}
 
 	/* ----------
@@ -341,7 +322,7 @@ numeric(Numeric num, int32 typmod)
 		new->n_rscale = scale;
 		new->n_sign_dscale = NUMERIC_SIGN(new) |
 			((uint16) scale & NUMERIC_DSCALE_MASK);
-		return new;
+		PG_RETURN_NUMERIC(new);
 	}
 
 	/* ----------
@@ -357,7 +338,7 @@ numeric(Numeric num, int32 typmod)
 
 	free_var(&var);
 
-	return new;
+	PG_RETURN_NUMERIC(new);
 }
 
 
@@ -502,26 +483,21 @@ numeric_sign(Numeric num)
  *	point --- Oracle interprets rounding that way.
  * ----------
  */
-Numeric
-numeric_round(Numeric num, int32 scale)
+Datum
+numeric_round(PG_FUNCTION_ARGS)
 {
+	Numeric		num = PG_GETARG_NUMERIC(0);
+	int32		scale = PG_GETARG_INT32(1);
 	Numeric		res;
 	NumericVar	arg;
 	int			i;
 
-	/* ----------
-	 * Handle NULL
-	 * ----------
-	 */
-	if (num == NULL)
-		return NULL;
-
 	/* ----------
 	 * Handle NaN
 	 * ----------
 	 */
 	if (NUMERIC_IS_NAN(num))
-		return make_result(&const_nan);
+		PG_RETURN_NUMERIC(make_result(&const_nan));
 
 	/* ----------
 	 * Limit the scale value to avoid possible overflow in calculations below.
@@ -587,7 +563,7 @@ numeric_round(Numeric num, int32 scale)
 	res = make_result(&arg);
 
 	free_var(&arg);
-	return res;
+	PG_RETURN_NUMERIC(res);
 }
 
 
@@ -599,25 +575,20 @@ numeric_round(Numeric num, int32 scale)
  *	point --- Oracle interprets truncation that way.
  * ----------
  */
-Numeric
-numeric_trunc(Numeric num, int32 scale)
+Datum
+numeric_trunc(PG_FUNCTION_ARGS)
 {
+	Numeric		num = PG_GETARG_NUMERIC(0);
+	int32		scale = PG_GETARG_INT32(1);
 	Numeric		res;
 	NumericVar	arg;
 
-	/* ----------
-	 * Handle NULL
-	 * ----------
-	 */
-	if (num == NULL)
-		return NULL;
-
 	/* ----------
 	 * Handle NaN
 	 * ----------
 	 */
 	if (NUMERIC_IS_NAN(num))
-		return make_result(&const_nan);
+		PG_RETURN_NUMERIC(make_result(&const_nan));
 
 	/* ----------
 	 * Limit the scale value to avoid possible overflow in calculations below.
@@ -650,7 +621,7 @@ numeric_trunc(Numeric num, int32 scale)
 	res = make_result(&arg);
 
 	free_var(&arg);
-	return res;
+	PG_RETURN_NUMERIC(res);
 }
 
 
@@ -1708,9 +1679,10 @@ numeric_power(Numeric num1, Numeric num2)
  */
 
 
-Numeric
-int4_numeric(int32 val)
+Datum
+int4_numeric(PG_FUNCTION_ARGS)
 {
+	int32		val = PG_GETARG_INT32(0);
 	Numeric		res;
 	NumericVar	result;
 	char	   *tmp;
@@ -1725,7 +1697,7 @@ int4_numeric(int32 val)
 	free_var(&result);
 	pfree(tmp);
 
-	return res;
+	PG_RETURN_NUMERIC(res);
 }
 
 
@@ -1769,7 +1741,8 @@ int8_numeric(int64 *val)
 
 	init_var(&result);
 
-	tmp = int8out(val);
+	tmp = DatumGetCString(DirectFunctionCall1(int8out,
+											  PointerGetDatum(val)));
 	set_var_from_str(tmp, &result);
 	res = make_result(&result);
 
@@ -1785,7 +1758,7 @@ numeric_int8(Numeric num)
 {
 	NumericVar	x;
 	char	   *str;
-	int64	   *result;
+	Datum		result;
 
 	if (num == NULL)
 		return NULL;
@@ -1804,10 +1777,11 @@ numeric_int8(Numeric num)
 
 	free_var(&x);
 
-	result = int8in(str);
+	result = DirectFunctionCall1(int8in, CStringGetDatum(str));
+
 	pfree(str);
 
-	return result;
+	return (int64 *) (result);
 }
 
 
@@ -1904,7 +1878,8 @@ numeric_float8(Numeric num)
 		return result;
 	}
 
-	tmp = numeric_out(num);
+	tmp = DatumGetCString(DirectFunctionCall1(numeric_out,
+											  NumericGetDatum(num)));
 	result = float8in(tmp);
 	pfree(tmp);
 
@@ -1954,7 +1929,8 @@ numeric_float4(Numeric num)
 		return result;
 	}
 
-	tmp = numeric_out(num);
+	tmp = DatumGetCString(DirectFunctionCall1(numeric_out,
+											  NumericGetDatum(num)));
 	result = float4in(tmp);
 	pfree(tmp);
 

src/backend/utils/adt/oracle_compat.c

 /*
  *	Edmund Mergl <E.Mergl@bawue.de>
  *
- *	$Id: oracle_compat.c,v 1.24 2000/04/12 17:15:51 momjian Exp $
+ *	$Id: oracle_compat.c,v 1.25 2000/06/13 07:35:07 tgl Exp $
  *
  */
 
@@ -150,9 +150,12 @@ initcap(text *string)
  *
  ********************************************************************/
 
-text *
-lpad(text *string1, int4 len, text *string2)
+Datum
+lpad(PG_FUNCTION_ARGS)
 {
+	text	   *string1 = PG_GETARG_TEXT_P(0);
+	int32		len = PG_GETARG_INT32(1);
+	text	   *string2 = PG_GETARG_TEXT_P(2);
 	text	   *ret;
 	char	   *ptr1,
 			   *ptr2,
@@ -160,12 +163,10 @@ lpad(text *string1, int4 len, text *string2)
 	int			m,
 				n;
 
-	if ((string1 == (text *) NULL) ||
-		(len <= (VARSIZE(string1) - VARHDRSZ)) ||
-		((m = len - VARSIZE(string1) + VARHDRSZ) <= 0) ||
-		(string2 == (text *) NULL) ||
+	if (((VARSIZE(string1) - VARHDRSZ) < 0) ||
+		((m = len - (VARSIZE(string1) - VARHDRSZ)) <= 0) ||
 		((VARSIZE(string2) - VARHDRSZ) <= 0))
-		return string1;
+		PG_RETURN_TEXT_P(string1);
 
 	ret = (text *) palloc(VARHDRSZ + len);
 	VARSIZE(ret) = VARHDRSZ + len;
@@ -176,7 +177,7 @@ lpad(text *string1, int4 len, text *string2)
 	while (m--)
 	{
 		*ptr_ret++ = *ptr2;
-		ptr2 = ptr2 == VARDATA(string2) + VARSIZE(string2) - VARHDRSZ - 1 ? VARDATA(string2) : ++ptr2;
+		ptr2 = (ptr2 == VARDATA(string2) + VARSIZE(string2) - VARHDRSZ - 1) ? VARDATA(string2) : ++ptr2;
 	}
 
 	n = VARSIZE(string1) - VARHDRSZ;
@@ -185,7 +186,7 @@ lpad(text *string1, int4 len, text *string2)
 	while (n--)
 		*ptr_ret++ = *ptr1++;
 
-	return ret;
+	PG_RETURN_TEXT_P(ret);
 }
 
 
@@ -204,9 +205,12 @@ lpad(text *string1, int4 len, text *string2)
  *
  ********************************************************************/
 
-text *
-rpad(text *string1, int4 len, text *string2)
+Datum
+rpad(PG_FUNCTION_ARGS)
 {
+	text	   *string1 = PG_GETARG_TEXT_P(0);
+	int32		len = PG_GETARG_INT32(1);
+	text	   *string2 = PG_GETARG_TEXT_P(2);
 	text	   *ret;
 	char	   *ptr1,
 			   *ptr2,
@@ -214,12 +218,10 @@ rpad(text *string1, int4 len, text *string2)
 	int			m,
 				n;
 
-	if ((string1 == (text *) NULL) ||
-		(len <= (VARSIZE(string1) - VARHDRSZ)) ||
-		((m = len - VARSIZE(string1) + VARHDRSZ) <= 0) ||
-		(string2 == (text *) NULL) ||
+	if (((VARSIZE(string1) - VARHDRSZ) < 0) ||
+		((m = len - (VARSIZE(string1) - VARHDRSZ)) <= 0) ||
 		((VARSIZE(string2) - VARHDRSZ) <= 0))
-		return string1;
+		PG_RETURN_TEXT_P(string1);
 
 	ret = (text *) palloc(VARHDRSZ + len);
 	VARSIZE(ret) = VARHDRSZ + len;
@@ -236,10 +238,10 @@ rpad(text *string1, int4 len, text *string2)
 	while (m--)
 	{
 		*ptr_ret++ = *ptr2;
-		ptr2 = ptr2 == VARDATA(string2) + VARSIZE(string2) - VARHDRSZ - 1 ? VARDATA(string2) : ++ptr2;
+		ptr2 = (ptr2 == VARDATA(string2) + VARSIZE(string2) - VARHDRSZ - 1) ? VARDATA(string2) : ++ptr2;
 	}
 
-	return ret;
+	PG_RETURN_TEXT_P(ret);
 }
 
 
@@ -551,22 +553,25 @@ ascii(text *string)
 }	/* ascii() */
 
 
-text *
-ichar(int4 cvalue)
+Datum
+ichar(PG_FUNCTION_ARGS)
 {
+	int32		cvalue = PG_GETARG_INT32(0);
 	text	   *result;
 
 	result = (text *) palloc(VARHDRSZ + 1);
 	VARSIZE(result) = VARHDRSZ + 1;
 	*VARDATA(result) = (char) cvalue;
 
-	return result;
-}	/* ichar() */
+	PG_RETURN_TEXT_P(result);
+}
 
 
-text *
-repeat(text *string, int4 count)
+Datum
+repeat(PG_FUNCTION_ARGS)
 {
+	text	   *string = PG_GETARG_TEXT_P(0);
+	int32		count = PG_GETARG_INT32(1);
 	text	   *result;
 	int			slen,
 				tlen;
@@ -589,5 +594,5 @@ repeat(text *string, int4 count)
 		cp += slen;
 	}
 
-	return result;
-}	/* repeat() */
+	PG_RETURN_TEXT_P(result);
+}

src/backend/utils/adt/ruleutils.c

@@ -3,7 +3,7 @@
  *			  out of its tuple
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/ruleutils.c,v 1.53 2000/06/12 19:40:43 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/ruleutils.c,v 1.54 2000/06/13 07:35:08 tgl Exp $
  *
  *	  This software is copyrighted by Jan Wieck - Hamburg.
  *
@@ -551,18 +551,19 @@ pg_get_indexdef(PG_FUNCTION_ARGS)
  *				  fallback to 'unknown (UID=n)'
  * ----------
  */
-NameData   *
-pg_get_userbyid(int32 uid)
+Datum
+pg_get_userbyid(PG_FUNCTION_ARGS)
 {
+	int32		uid = PG_GETARG_INT32(0);
+	Name		result;
 	HeapTuple	usertup;
 	Form_pg_shadow user_rec;
-	NameData   *result;
 
 	/* ----------
 	 * Allocate space for the result
 	 * ----------
 	 */
-	result = (NameData *) palloc(NAMEDATALEN);
+	result = (Name) palloc(NAMEDATALEN);
 	memset(NameStr(*result), 0, NAMEDATALEN);
 
 	/* ----------
@@ -570,16 +571,17 @@ pg_get_userbyid(int32 uid)
 	 * ----------
 	 */
 	usertup = SearchSysCacheTuple(SHADOWSYSID,
-								  ObjectIdGetDatum(uid), 0, 0, 0);
+								  ObjectIdGetDatum(uid),
+								  0, 0, 0);
 	if (HeapTupleIsValid(usertup))
 	{
 		user_rec = (Form_pg_shadow) GETSTRUCT(usertup);
 		StrNCpy(NameStr(*result), NameStr(user_rec->usename), NAMEDATALEN);
 	}
 	else
-		sprintf((char *) result, "unknown (UID=%d)", uid);
+		sprintf(NameStr(*result), "unknown (UID=%d)", uid);
 
-	return result;
+	PG_RETURN_NAME(result);
 }
 
 /* ----------

src/backend/utils/adt/varchar.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/varchar.c,v 1.63 2000/06/05 07:28:52 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/varchar.c,v 1.64 2000/06/13 07:35:08 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -61,20 +61,21 @@ extern char *convertstr(char *, int, int);
 /*
  * bpcharin -
  *	  converts a string of char() type to the internal representation.
- *	  len is the length specified in () plus VARHDRSZ bytes. (XXX dummy is here
- *	  because we pass typelem as the second argument for array_in.)
+ *	  len is the length specified in () plus VARHDRSZ bytes.
  */
-char *
-bpcharin(char *s, int dummy, int32 atttypmod)
+Datum
+bpcharin(PG_FUNCTION_ARGS)
 {
-	char	   *result,
-			   *r;
+	char	   *s = PG_GETARG_CSTRING(0);
+#ifdef NOT_USED
+	Oid			typelem = PG_GETARG_OID(1);
+#endif
+	int32		atttypmod = PG_GETARG_INT32(2);
+	BpChar	   *result;
+	char	   *r;
 	int			len;
 	int			i;
 
-	if (s == NULL)
-		return (char *) NULL;
-
 	if (atttypmod < (int32) VARHDRSZ)
 	{
 		/* If typmod is -1 (or invalid), use the actual string length */
@@ -84,7 +85,7 @@ bpcharin(char *s, int dummy, int32 atttypmod)
 	else
 		len = atttypmod - VARHDRSZ;
 
-	result = (char *) palloc(atttypmod);
+	result = (BpChar *) palloc(atttypmod);
 	VARSIZE(result) = atttypmod;
 	r = VARDATA(result);
 	for (i = 0; i < len; i++, r++, s++)
@@ -95,85 +96,78 @@ bpcharin(char *s, int dummy, int32 atttypmod)
 	}
 
 #ifdef CYR_RECODE
-	convertstr(result + VARHDRSZ, len, 0);
+	convertstr(VARDATA(result), len, 0);
 #endif
 
 	/* blank pad the string if necessary */
 	for (; i < len; i++)
 		*r++ = ' ';
-	return result;
+
+	PG_RETURN_BPCHAR_P(result);
 }
 
-char *
-bpcharout(char *s)
+Datum
+bpcharout(PG_FUNCTION_ARGS)
 {
+	BpChar	   *s = PG_GETARG_BPCHAR_P(0);
 	char	   *result;
 	int			len;
 
-	if (s == NULL)
-	{
-		result = (char *) palloc(2);
-		result[0] = '-';
-		result[1] = '\0';
-	}
-	else
-	{
-		len = VARSIZE(s) - VARHDRSZ;
-		result = (char *) palloc(len + 1);
-		StrNCpy(result, VARDATA(s), len + 1);	/* these are blank-padded */
-	}
+	len = VARSIZE(s) - VARHDRSZ;
+	result = (char *) palloc(len + 1);
+	StrNCpy(result, VARDATA(s), len + 1); /* copy and add null term */
 
 #ifdef CYR_RECODE
 	convertstr(result, len, 1);
 #endif
 
-	return result;
+	PG_RETURN_CSTRING(result);
 }
 
 /* bpchar()
  * Converts a char() type to a specific internal length.
  * len is the length specified in () plus VARHDRSZ bytes.
  */
-char *
-bpchar(char *s, int32 len)
+Datum
+bpchar(PG_FUNCTION_ARGS)
 {
-	char	   *result,
-			   *r;
+	BpChar	   *str = PG_GETARG_BPCHAR_P(0);
+	int32		len = PG_GETARG_INT32(1);
+	BpChar	   *result;
+	char	   *r,
+			   *s;
 	int			rlen,
 				slen;
 	int			i;
 
-	if (s == NULL)
-		return (char *) NULL;
-
 	/* No work if typmod is invalid or supplied data matches it already */
-	if (len < (int32) VARHDRSZ || len == VARSIZE(s))
-		return s;
+	if (len < (int32) VARHDRSZ || len == VARSIZE(str))
+		PG_RETURN_BPCHAR_P(str);
 
 	rlen = len - VARHDRSZ;
 
 #ifdef STRINGDEBUG
 	printf("bpchar- convert string length %d (%d) ->%d (%d)\n",
-		   VARSIZE(s) - VARHDRSZ, VARSIZE(s), rlen, len);
+		   VARSIZE(str) - VARHDRSZ, VARSIZE(str), rlen, len);
 #endif
 
-	result = (char *) palloc(len);
+	result = (BpChar *) palloc(len);
 	VARSIZE(result) = len;
 	r = VARDATA(result);
-#ifdef MULTIBYTE
 
+#ifdef MULTIBYTE
 	/*
 	 * truncate multi-byte string in a way not to break multi-byte
 	 * boundary
 	 */
-	if (VARSIZE(s) > len)
-		slen = pg_mbcliplen(VARDATA(s), VARSIZE(s) - VARHDRSZ, rlen);
+	if (VARSIZE(str) > len)
+		slen = pg_mbcliplen(VARDATA(str), VARSIZE(str) - VARHDRSZ, rlen);
 	else
-		slen = VARSIZE(s) - VARHDRSZ;
+		slen = VARSIZE(str) - VARHDRSZ;
 #else
-	slen = VARSIZE(s) - VARHDRSZ;
+	slen = VARSIZE(str) - VARHDRSZ;
 #endif
-	s = VARDATA(s);
+	s = VARDATA(str);
 
 #ifdef STRINGDEBUG
 	printf("bpchar- string is '");
@@ -181,13 +175,9 @@ bpchar(char *s, int32 len)
 
 	for (i = 0; (i < rlen) && (i < slen); i++)
 	{
-		if (*s == '\0')
-			break;
-
 #ifdef STRINGDEBUG
 		printf("%c", *s);
 #endif
-
 		*r++ = *s++;
 	}
 
@@ -199,19 +189,21 @@ bpchar(char *s, int32 len)
 	for (; i < rlen; i++)
 		*r++ = ' ';
 
-	return result;
-}	/* bpchar() */
+	PG_RETURN_BPCHAR_P(result);
+}
 
 /* _bpchar()
- * Converts an array of char() type to a specific internal length.
+ * Converts an array of char() elements to a specific internal length.
  * len is the length specified in () plus VARHDRSZ bytes.
  */
-ArrayType  *
-_bpchar(ArrayType *v, int32 len)
+Datum
+_bpchar(PG_FUNCTION_ARGS)
 {
+	ArrayType  *v = (ArrayType *) PG_GETARG_VARLENA_P(0);
+	int32		len = PG_GETARG_INT32(1);
 	FunctionCallInfoData	locfcinfo;
-	Datum					result;
-	/* Since bpchar() is a built-in function, we should only need to
+	/*
+	 * Since bpchar() is a built-in function, we should only need to
 	 * look it up once per run.
 	 */
 	static FmgrInfo			bpchar_finfo;
@@ -226,9 +218,7 @@ _bpchar(ArrayType *v, int32 len)
 	locfcinfo.arg[0] = PointerGetDatum(v);
 	locfcinfo.arg[1] = Int32GetDatum(len);
 
-	result = array_map(&locfcinfo, BPCHAROID, BPCHAROID);
-
-	return (ArrayType *) DatumGetPointer(result);
+	return array_map(&locfcinfo, BPCHAROID, BPCHAROID);
 }
 
 
@@ -240,7 +230,7 @@ _bpchar(ArrayType *v, int32 len)
 Datum
 bpchar_char(PG_FUNCTION_ARGS)
 {
-	struct varlena *s = PG_GETARG_BPCHAR_P(0);
+	BpChar	   *s = PG_GETARG_BPCHAR_P(0);
 
 	PG_RETURN_CHAR(*VARDATA(s));
 }
@@ -252,9 +242,9 @@ Datum
 char_bpchar(PG_FUNCTION_ARGS)
 {
 	char		c = PG_GETARG_CHAR(0);
-	struct varlena *result;
+	BpChar	   *result;
 
-	result = (struct varlena *) palloc(VARHDRSZ + 1);
+	result = (BpChar *) palloc(VARHDRSZ + 1);
 
 	VARSIZE(result) = VARHDRSZ + 1;
 	*(VARDATA(result)) = c;
@@ -338,75 +328,67 @@ name_bpchar(NameData *s)
 /*
  * varcharin -
  *	  converts a string of varchar() type to the internal representation.
- *	  len is the length specified in () plus VARHDRSZ bytes. (XXX dummy is here
- *	  because we pass typelem as the second argument for array_in.)
+ *	  len is the length specified in () plus VARHDRSZ bytes.
  */
-char *
-varcharin(char *s, int dummy, int32 atttypmod)
+Datum
+varcharin(PG_FUNCTION_ARGS)
 {
-	char	   *result;
+	char	   *s = PG_GETARG_CSTRING(0);
+#ifdef NOT_USED
+	Oid			typelem = PG_GETARG_OID(1);
+#endif
+	int32		atttypmod = PG_GETARG_INT32(2);
+	VarChar	   *result;
 	int			len;
 
-	if (s == NULL)
-		return (char *) NULL;
-
 	len = strlen(s) + VARHDRSZ;
 	if (atttypmod >= (int32) VARHDRSZ && len > atttypmod)
 		len = atttypmod;		/* clip the string at max length */
 
-	result = (char *) palloc(len);
+	result = (VarChar *) palloc(len);
 	VARSIZE(result) = len;
-	strncpy(VARDATA(result), s, len - VARHDRSZ);
+	memcpy(VARDATA(result), s, len - VARHDRSZ);
 
 #ifdef CYR_RECODE
-	convertstr(result + VARHDRSZ, len, 0);
+	convertstr(VARDATA(result), len, 0);
 #endif
 
-	return result;
+	PG_RETURN_VARCHAR_P(result);
 }
 
-char *
-varcharout(char *s)
+Datum
+varcharout(PG_FUNCTION_ARGS)
 {
+	VarChar	   *s = PG_GETARG_VARCHAR_P(0);
 	char	   *result;
 	int			len;
 
-	if (s == NULL)
-	{
-		result = (char *) palloc(2);
-		result[0] = '-';
-		result[1] = '\0';
-	}
-	else
-	{
-		len = VARSIZE(s) - VARHDRSZ;
-		result = (char *) palloc(len + 1);
-		StrNCpy(result, VARDATA(s), len + 1);
-	}
+	len = VARSIZE(s) - VARHDRSZ;
+	result = (char *) palloc(len + 1);
+	StrNCpy(result, VARDATA(s), len + 1); /* copy and add null term */
 
 #ifdef CYR_RECODE
 	convertstr(result, len, 1);
 #endif
 
-	return result;
+	PG_RETURN_CSTRING(result);
 }
 
 /* varchar()
  * Converts a varchar() type to the specified size.
  * slen is the length specified in () plus VARHDRSZ bytes.
  */
-char *
-varchar(char *s, int32 slen)
+Datum
+varchar(PG_FUNCTION_ARGS)
 {
-	char	   *result;
+	VarChar	   *s = PG_GETARG_VARCHAR_P(0);
+	int32		slen = PG_GETARG_INT32(1);
+	VarChar	   *result;
 	int			len;
 
-	if (s == NULL)
-		return (char *) NULL;
-
 	len = VARSIZE(s);
 	if (slen < (int32) VARHDRSZ || len <= slen)
-		return (char *) s;
+		PG_RETURN_VARCHAR_P(s);
 
 	/* only reach here if we need to truncate string... */
 
@@ -422,23 +404,25 @@ varchar(char *s, int32 slen)
 	len = slen - VARHDRSZ;
 #endif
 
-	result = (char *) palloc(slen);
+	result = (VarChar *) palloc(slen);
 	VARSIZE(result) = slen;
-	strncpy(VARDATA(result), VARDATA(s), len);
+	memcpy(VARDATA(result), VARDATA(s), len);
 
-	return result;
-}	/* varchar() */
+	PG_RETURN_VARCHAR_P(result);
+}
 
 /* _varchar()
- * Converts an array of varchar() type to the specified size.
+ * Converts an array of varchar() elements to the specified size.
  * len is the length specified in () plus VARHDRSZ bytes.
  */
-ArrayType  *
-_varchar(ArrayType *v, int32 len)
+Datum
+_varchar(PG_FUNCTION_ARGS)
 {
+	ArrayType  *v = (ArrayType *) PG_GETARG_VARLENA_P(0);
+	int32		len = PG_GETARG_INT32(1);
 	FunctionCallInfoData	locfcinfo;
-	Datum					result;
-	/* Since varchar() is a built-in function, we should only need to
+	/*
+	 * Since varchar() is a built-in function, we should only need to
 	 * look it up once per run.
 	 */
 	static FmgrInfo			varchar_finfo;
@@ -453,9 +437,7 @@ _varchar(ArrayType *v, int32 len)
 	locfcinfo.arg[0] = PointerGetDatum(v);
 	locfcinfo.arg[1] = Int32GetDatum(len);
 
-	result = array_map(&locfcinfo, VARCHAROID, VARCHAROID);
-
-	return (ArrayType *) DatumGetPointer(result);
+	return array_map(&locfcinfo, VARCHAROID, VARCHAROID);
 }
 
 

src/backend/utils/adt/varlena.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/varlena.c,v 1.58 2000/04/12 17:15:52 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/varlena.c,v 1.59 2000/06/13 07:35:08 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -323,21 +323,19 @@ textcat(text *t1, text *t2)
  * Formerly returned the entire string; now returns a portion.
  * - Thomas Lockhart 1998-12-10
  */
-text *
-text_substr(text *string, int32 m, int32 n)
+Datum
+text_substr(PG_FUNCTION_ARGS)
 {
+	text	   *string = PG_GETARG_TEXT_P(0);
+	int32		m = PG_GETARG_INT32(1);
+	int32		n = PG_GETARG_INT32(2);
 	text	   *ret;
 	int			len;
-
 #ifdef MULTIBYTE
 	int			i;
 	char	   *p;
-
 #endif
 
-	if (string == (text *) NULL)
-		return string;
-
 	len = VARSIZE(string) - VARHDRSZ;
 #ifdef MULTIBYTE
 	len = pg_mbstrlen_with_len(VARDATA(string), len);
@@ -374,13 +372,14 @@ text_substr(text *string, int32 m, int32 n)
 		p += pg_mblen(p);
 	n = p - (VARDATA(string) + m);
 #endif
+
 	ret = (text *) palloc(VARHDRSZ + n);
 	VARSIZE(ret) = VARHDRSZ + n;
 
 	memcpy(VARDATA(ret), VARDATA(string) + m, n);
 
-	return ret;
-}	/* text_substr() */
+	PG_RETURN_TEXT_P(ret);
+}
 
 /*
  * textpos -
@@ -636,19 +635,17 @@ byteaoctetlen(bytea *v)
  * byteaGetByte
  *
  * this routine treats "bytea" as an array of bytes.
- * It returns the Nth byte (a number between 0 and 255) or
- * it dies if the length of this array is less than n.
+ * It returns the Nth byte (a number between 0 and 255).
  *-------------------------------------------------------------
  */
-int32
-byteaGetByte(bytea *v, int32 n)
+Datum
+byteaGetByte(PG_FUNCTION_ARGS)
 {
+	bytea	   *v = PG_GETARG_BYTEA_P(0);
+	int32		n = PG_GETARG_INT32(1);
 	int			len;
 	int			byte;
 
-	if (!PointerIsValid(v))
-		return 0;
-
 	len = VARSIZE(v) - VARHDRSZ;
 
 	if (n < 0 || n >= len)
@@ -657,7 +654,7 @@ byteaGetByte(bytea *v, int32 n)
 
 	byte = ((unsigned char *) VARDATA(v))[n];
 
-	return (int32) byte;
+	PG_RETURN_INT32(byte);
 }
 
 /*-------------------------------------------------------------
@@ -665,21 +662,19 @@ byteaGetByte(bytea *v, int32 n)
  *
  * This routine treats a "bytea" type like an array of bits.
  * It returns the value of the Nth bit (0 or 1).
- * If 'n' is out of range, it dies!
  *
  *-------------------------------------------------------------
  */
-int32
-byteaGetBit(bytea *v, int32 n)
+Datum
+byteaGetBit(PG_FUNCTION_ARGS)
 {
+	bytea	   *v = PG_GETARG_BYTEA_P(0);
+	int32		n = PG_GETARG_INT32(1);
 	int			byteNo,
 				bitNo;
 	int			len;
 	int			byte;
 
-	if (!PointerIsValid(v))
-		return 0;
-
 	len = VARSIZE(v) - VARHDRSZ;
 
 	if (n < 0 || n >= len * 8)
@@ -692,9 +687,9 @@ byteaGetBit(bytea *v, int32 n)
 	byte = ((unsigned char *) VARDATA(v))[byteNo];
 
 	if (byte & (1 << bitNo))
-		return (int32) 1;
+		PG_RETURN_INT32(1);
 	else
-		return (int32) 0;
+		PG_RETURN_INT32(0);
 }
 
 /*-------------------------------------------------------------
@@ -705,15 +700,15 @@ byteaGetBit(bytea *v, int32 n)
  *
  *-------------------------------------------------------------
  */
-bytea *
-byteaSetByte(bytea *v, int32 n, int32 newByte)
+Datum
+byteaSetByte(PG_FUNCTION_ARGS)
 {
+	bytea	   *v = PG_GETARG_BYTEA_P(0);
+	int32		n = PG_GETARG_INT32(1);
+	int32		newByte = PG_GETARG_INT32(2);
 	int			len;
 	bytea	   *res;
 
-	if (!PointerIsValid(v))
-		return 0;
-
 	len = VARSIZE(v) - VARHDRSZ;
 
 	if (n < 0 || n >= len)
@@ -731,7 +726,7 @@ byteaSetByte(bytea *v, int32 n, int32 newByte)
 	 */
 	((unsigned char *) VARDATA(res))[n] = newByte;
 
-	return res;
+	PG_RETURN_BYTEA_P(res);
 }
 
 /*-------------------------------------------------------------
@@ -742,9 +737,12 @@ byteaSetByte(bytea *v, int32 n, int32 newByte)
  *
  *-------------------------------------------------------------
  */
-bytea *
-byteaSetBit(bytea *v, int32 n, int32 newBit)
+Datum
+byteaSetBit(PG_FUNCTION_ARGS)
 {
+	bytea	   *v = PG_GETARG_BYTEA_P(0);
+	int32		n = PG_GETARG_INT32(1);
+	int32		newBit = PG_GETARG_INT32(2);
 	bytea	   *res;
 	int			len;
 	int			oldByte,
@@ -752,9 +750,6 @@ byteaSetBit(bytea *v, int32 n, int32 newBit)
 	int			byteNo,
 				bitNo;
 
-	if (!PointerIsValid(v))
-		return NULL;
-
 	len = VARSIZE(v) - VARHDRSZ;
 
 	if (n < 0 || n >= len * 8)
@@ -771,24 +766,24 @@ byteaSetBit(bytea *v, int32 n, int32 newBit)
 		elog(ERROR, "byteaSetBit: new bit must be 0 or 1");
 
 	/*
-	 * get the byte where the bit we want is stored.
+	 * Make a copy of the original varlena.
 	 */
-	oldByte = byteaGetByte(v, byteNo);
+	res = (bytea *) palloc(VARSIZE(v));
+	memcpy((char *) res, (char *) v, VARSIZE(v));
 
 	/*
-	 * calculate the new value for that byte
+	 * Update the byte.
 	 */
+	oldByte = ((unsigned char *) VARDATA(res))[byteNo];
+
 	if (newBit == 0)
 		newByte = oldByte & (~(1 << bitNo));
 	else
 		newByte = oldByte | (1 << bitNo);
 
-	/*
-	 * NOTE: 'byteaSetByte' creates a copy of 'v' & sets the byte.
-	 */
-	res = byteaSetByte(v, byteNo, newByte);
+	((unsigned char *) VARDATA(res))[byteNo] = newByte;
 
-	return res;
+	PG_RETURN_BYTEA_P(res);
 }
 
 

src/backend/utils/init/miscinit.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/init/miscinit.c,v 1.48 2000/06/08 22:37:33 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/init/miscinit.c,v 1.49 2000/06/13 07:35:09 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -28,6 +28,7 @@
 #include "catalog/catname.h"
 #include "catalog/pg_shadow.h"
 #include "miscadmin.h"
+#include "utils/builtins.h"
 #include "utils/syscache.h"
 
 static char *GetPidFname(void);
@@ -98,25 +99,26 @@ SetDatabaseName(const char *name)
 }
 
 #ifndef MULTIBYTE
-/* even if MULTIBYTE is not enabled, this function is neccesary
- * since pg_proc.h has entries for them.
+/* even if MULTIBYTE is not enabled, these functions are necessary
+ * since pg_proc.h has references to them.
  */
-const char *
-getdatabaseencoding()
+
+Datum
+getdatabaseencoding(PG_FUNCTION_ARGS)
 {
-	return ("SQL_ASCII");
+	PG_RETURN_NAME("SQL_ASCII");
 }
 
-const char *
-pg_encoding_to_char(int encoding)
+Datum
+PG_encoding_to_char(PG_FUNCTION_ARGS)
 {
-	return ("SQL_ASCII");
+	PG_RETURN_NAME("SQL_ASCII");
 }
 
-int
-pg_char_to_encoding(const char *encoding_string)
+Datum
+PG_char_to_encoding(PG_FUNCTION_ARGS)
 {
-	return (0);
+	PG_RETURN_INT32(0);
 }
 
 #endif

src/backend/utils/mb/common.c

@@ -2,7 +2,7 @@
  * This file contains some public functions
  * usable for both the backend and the frontend.
  * Tatsuo Ishii
- * $Id: common.c,v 1.8 2000/01/18 05:14:24 ishii Exp $ */
+ * $Id: common.c,v 1.9 2000/06/13 07:35:15 tgl Exp $ */
 
 #include <stdlib.h>
 #include <string.h>
@@ -14,8 +14,10 @@
 #endif
 
 #include "postgres.h"
+
 #include "miscadmin.h"
 #include "mb/pg_wchar.h"
+#include "utils/builtins.h"
 
 /*
  * convert encoding char to encoding symbol value.
@@ -38,6 +40,15 @@ pg_char_to_encoding(const char *s)
 	return (p->encoding);
 }
 
+/* Same, as an fmgr-callable function */
+Datum
+PG_char_to_encoding(PG_FUNCTION_ARGS)
+{
+	Name		s = PG_GETARG_NAME(0);
+
+	PG_RETURN_INT32(pg_char_to_encoding(NameStr(*s)));
+}
+
 /*
  * check to see if encoding name is valid
  */
@@ -77,6 +88,15 @@ pg_encoding_to_char(int encoding)
 	return (p->name);
 }
 
+/* Same, as an fmgr-callable function */
+Datum
+PG_encoding_to_char(PG_FUNCTION_ARGS)
+{
+	int32		encoding = PG_GETARG_INT32(0);
+
+	PG_RETURN_NAME(pg_encoding_to_char(encoding));
+}
+
 /* returns the byte length of a multi-byte word for an encoding */
 int
 pg_encoding_mblen(int encoding, const unsigned char *mbstr)

src/backend/utils/mb/mbutils.c

@@ -3,12 +3,14 @@
  * client encoding and server internal encoding.
  * (currently mule internal code (mic) is used)
  * Tatsuo Ishii
- * $Id: mbutils.c,v 1.9 1999/09/11 22:28:00 tgl Exp $ */
+ * $Id: mbutils.c,v 1.10 2000/06/13 07:35:12 tgl Exp $ */
 
 
 #include "postgres.h"
+
 #include "miscadmin.h"
 #include "mb/pg_wchar.h"
+#include "utils/builtins.h"
 
 static int	client_encoding = -1;
 static void (*client_to_mic) ();/* something to MIC */
@@ -266,10 +268,10 @@ GetDatabaseEncoding()
 }
 
 /* for builtin-function */
-const char *
-getdatabaseencoding()
+Datum
+getdatabaseencoding(PG_FUNCTION_ARGS)
 {
-	return (pg_encoding_to_char(DatabaseEncoding));
+	PG_RETURN_NAME(pg_encoding_to_char(DatabaseEncoding));
 }
 
 /* set and get template1 database encoding */

src/include/access/gist.h

@@ -182,14 +182,9 @@ typedef struct intrange
 	int			flag;
 } INTRANGE;
 
-extern void gistbuild(Relation heap,
-		  Relation index, int natts,
-		  AttrNumber *attnum, IndexStrategy istrat,
-		  uint16 pint, Datum *params,
-		  FuncIndexInfo *finfo,
-		  PredInfo *predInfo);
-extern InsertIndexResult gistinsert(Relation r, Datum *datum,
-		   char *nulls, ItemPointer ht_ctid, Relation heapRel);
+extern Datum gistbuild(PG_FUNCTION_ARGS);
+extern Datum gistinsert(PG_FUNCTION_ARGS);
+extern Datum gistdelete(PG_FUNCTION_ARGS);
 extern void _gistdump(Relation r);
 extern void gistfreestack(GISTSTACK *s);
 extern void initGISTstate(GISTSTATE *giststate, Relation index);
@@ -198,6 +193,6 @@ extern void gistdentryinit(GISTSTATE *giststate, GISTENTRY *e, char *pr,
 extern StrategyNumber RelationGetGISTStrategy(Relation, AttrNumber, RegProcedure);
 
 /* gistget.c */
-extern RetrieveIndexResult gistgettuple(IndexScanDesc s, ScanDirection dir);
+extern Datum gistgettuple(PG_FUNCTION_ARGS);
 
 #endif	 /* GIST_H */

src/include/access/gistscan.h

@@ -10,15 +10,15 @@
  *-------------------------------------------------------------------------
  */
 #ifndef GISTSCAN_H
+#define GISTSCAN_H
 
 #include "access/relscan.h"
 
-extern IndexScanDesc gistbeginscan(Relation r, bool fromEnd,
-			  uint16 nkeys, ScanKey key);
-extern void gistrescan(IndexScanDesc s, bool fromEnd, ScanKey key);
-extern void gistmarkpos(IndexScanDesc s);
-extern void gistrestrpos(IndexScanDesc s);
-extern void gistendscan(IndexScanDesc s);
+extern Datum gistbeginscan(PG_FUNCTION_ARGS);
+extern Datum gistrescan(PG_FUNCTION_ARGS);
+extern Datum gistmarkpos(PG_FUNCTION_ARGS);
+extern Datum gistrestrpos(PG_FUNCTION_ARGS);
+extern Datum gistendscan(PG_FUNCTION_ARGS);
 extern void gistadjscans(Relation r, int op, BlockNumber blkno, OffsetNumber offnum);
 
 #endif	 /* GISTSCAN_H */

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.32 2000/06/05 07:28:57 tgl Exp $
+ * $Id: hash.h,v 1.33 2000/06/13 07:35:17 tgl Exp $
  *
  * NOTES
  *		modeled after Margo Seltzer's hash implementation for unix.
@@ -248,19 +248,15 @@ typedef HashItemData *HashItem;
 
 /* public routines */
 
-extern void hashbuild(Relation heap, Relation index, int natts,
-		  AttrNumber *attnum, IndexStrategy istrat, uint16 pcount,
-		  Datum *params, FuncIndexInfo *finfo, PredInfo *predInfo);
-extern InsertIndexResult hashinsert(Relation rel, Datum *datum, char *nulls,
-		   ItemPointer ht_ctid, Relation heapRel);
-extern char *hashgettuple(IndexScanDesc scan, ScanDirection dir);
-extern char *hashbeginscan(Relation rel, bool fromEnd, uint16 keysz,
-			  ScanKey scankey);
-extern void hashrescan(IndexScanDesc scan, bool fromEnd, ScanKey scankey);
-extern void hashendscan(IndexScanDesc scan);
-extern void hashmarkpos(IndexScanDesc scan);
-extern void hashrestrpos(IndexScanDesc scan);
-extern void hashdelete(Relation rel, ItemPointer tid);
+extern Datum hashbuild(PG_FUNCTION_ARGS);
+extern Datum hashinsert(PG_FUNCTION_ARGS);
+extern Datum hashgettuple(PG_FUNCTION_ARGS);
+extern Datum hashbeginscan(PG_FUNCTION_ARGS);
+extern Datum hashrescan(PG_FUNCTION_ARGS);
+extern Datum hashendscan(PG_FUNCTION_ARGS);
+extern Datum hashmarkpos(PG_FUNCTION_ARGS);
+extern Datum hashrestrpos(PG_FUNCTION_ARGS);
+extern Datum hashdelete(PG_FUNCTION_ARGS);
 
 /*
  * Datatype-specific hash functions in hashfunc.c.

src/include/access/nbtree.h

@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: nbtree.h,v 1.36 2000/06/08 22:37:38 momjian Exp $
+ * $Id: nbtree.h,v 1.37 2000/06/13 07:35:17 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -227,21 +227,16 @@ extern void _bt_pagedel(Relation rel, ItemPointer tid);
  */
 extern bool BuildingBtree;		/* in nbtree.c */
 
-extern void btbuild(Relation heap, Relation index, int natts,
-		AttrNumber *attnum, IndexStrategy istrat, uint16 pcount,
-		Datum *params, FuncIndexInfo *finfo, PredInfo *predInfo);
-extern InsertIndexResult btinsert(Relation rel, Datum *datum, char *nulls,
-		 ItemPointer ht_ctid, Relation heapRel);
-extern char *btgettuple(IndexScanDesc scan, ScanDirection dir);
-extern char *btbeginscan(Relation rel, bool fromEnd, uint16 keysz,
-			ScanKey scankey);
-
-extern void btrescan(IndexScanDesc scan, bool fromEnd, ScanKey scankey);
+extern Datum btbuild(PG_FUNCTION_ARGS);
+extern Datum btinsert(PG_FUNCTION_ARGS);
+extern Datum btgettuple(PG_FUNCTION_ARGS);
+extern Datum btbeginscan(PG_FUNCTION_ARGS);
+extern Datum btrescan(PG_FUNCTION_ARGS);
 extern void btmovescan(IndexScanDesc scan, Datum v);
-extern void btendscan(IndexScanDesc scan);
-extern void btmarkpos(IndexScanDesc scan);
-extern void btrestrpos(IndexScanDesc scan);
-extern void btdelete(Relation rel, ItemPointer tid);
+extern Datum btendscan(PG_FUNCTION_ARGS);
+extern Datum btmarkpos(PG_FUNCTION_ARGS);
+extern Datum btrestrpos(PG_FUNCTION_ARGS);
+extern Datum btdelete(PG_FUNCTION_ARGS);
 
 /*
  * prototypes for functions in nbtscan.c

src/include/access/rtree.h

@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: rtree.h,v 1.17 2000/01/26 05:57:51 momjian Exp $
+ * $Id: rtree.h,v 1.18 2000/06/13 07:35:17 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -104,28 +104,21 @@ typedef RTreeScanOpaqueData *RTreeScanOpaque;
 /* defined in rtree.c */
 extern void freestack(RTSTACK *s);
 
-/* rget.c */
-extern RetrieveIndexResult rtgettuple(IndexScanDesc s, ScanDirection dir);
-
 /*
  *		RTree code.
  *		Defined in access/index-rtree/
  */
-extern InsertIndexResult rtinsert(Relation r, Datum *datum, char *nulls,
-		 ItemPointer ht_ctid, Relation heapRel);
-extern char *rtdelete(Relation r, ItemPointer tid);
-
-extern RetrieveIndexResult rtgettuple(IndexScanDesc s, ScanDirection dir);
-extern IndexScanDesc rtbeginscan(Relation r, bool fromEnd, uint16 nkeys,
-			ScanKey key);
-
-extern void rtendscan(IndexScanDesc s);
-extern void rtmarkpos(IndexScanDesc s);
-extern void rtrestrpos(IndexScanDesc s);
-extern void rtrescan(IndexScanDesc s, bool fromEnd, ScanKey key);
-extern void rtbuild(Relation heap, Relation index, int natts,
-		AttrNumber *attnum, IndexStrategy istrat, uint16 pcount,
-		Datum *params, FuncIndexInfo *finfo, PredInfo *predInfo);
+extern Datum rtinsert(PG_FUNCTION_ARGS);
+extern Datum rtdelete(PG_FUNCTION_ARGS);
+
+extern Datum rtgettuple(PG_FUNCTION_ARGS);
+extern Datum rtbeginscan(PG_FUNCTION_ARGS);
+
+extern Datum rtendscan(PG_FUNCTION_ARGS);
+extern Datum rtmarkpos(PG_FUNCTION_ARGS);
+extern Datum rtrestrpos(PG_FUNCTION_ARGS);
+extern Datum rtrescan(PG_FUNCTION_ARGS);
+extern Datum rtbuild(PG_FUNCTION_ARGS);
 extern void _rtdump(Relation r);
 
 /* rtscan.c */

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.30 2000/06/12 22:36:12 momjian Exp $
+ * $Id: catversion.h,v 1.31 2000/06/13 07:35:19 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -53,6 +53,6 @@
  */
 
 /*							yyyymmddN */
-#define CATALOG_VERSION_NO	200006121
+#define CATALOG_VERSION_NO	200006131
 
 #endif

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.4 2000/06/05 07:29:02 tgl Exp $
+ * $Id: fmgr.h,v 1.5 2000/06/13 07:35:23 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -99,37 +99,49 @@ extern void fmgr_info(Oid functionId, FmgrInfo *finfo);
  */
 #define PG_ARGISNULL(n)  (fcinfo->argnull[n])
 
+#if 1
+/* VERY TEMPORARY until some TOAST support is committed ... */
+#define PG_DETOAST_DATUM(datum)  \
+	 ((struct varlena *) DatumGetPointer(datum))
+#else
+/* Eventually it will look more like this... */
+#define PG_DETOAST_DATUM(datum)  \
+	(VARATT_IS_EXTENDED(DatumGetPointer(datum)) ?  \
+	 (struct varlena *) heap_tuple_untoast_attr((varattrib *) DatumGetPointer(datum)) :  \
+	 (struct varlena *) DatumGetPointer(datum))
+#endif
+
 /* 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])
+#define PG_GETARG_INT32(n)   DatumGetInt32(PG_GETARG_DATUM(n))
+#define PG_GETARG_UINT32(n)  DatumGetUInt32(PG_GETARG_DATUM(n))
+#define PG_GETARG_INT16(n)   DatumGetInt16(PG_GETARG_DATUM(n))
+#define PG_GETARG_UINT16(n)  DatumGetUInt16(PG_GETARG_DATUM(n))
+#define PG_GETARG_CHAR(n)    DatumGetChar(PG_GETARG_DATUM(n))
+#define PG_GETARG_BOOL(n)    DatumGetBool(PG_GETARG_DATUM(n))
+#define PG_GETARG_OID(n)     DatumGetObjectId(PG_GETARG_DATUM(n))
+#define PG_GETARG_POINTER(n) DatumGetPointer(PG_GETARG_DATUM(n))
+#define PG_GETARG_CSTRING(n) DatumGetCString(PG_GETARG_DATUM(n))
+#define PG_GETARG_NAME(n)    DatumGetName(PG_GETARG_DATUM(n))
 /* these macros hide the pass-by-reference-ness of the datatype: */
-#define PG_GETARG_FLOAT4(n)  DatumGetFloat4(fcinfo->arg[n])
-#define PG_GETARG_FLOAT8(n)  DatumGetFloat8(fcinfo->arg[n])
-#define PG_GETARG_INT64(n)   DatumGetInt64(fcinfo->arg[n])
+#define PG_GETARG_FLOAT4(n)  DatumGetFloat4(PG_GETARG_DATUM(n))
+#define PG_GETARG_FLOAT8(n)  DatumGetFloat8(PG_GETARG_DATUM(n))
+#define PG_GETARG_INT64(n)   DatumGetInt64(PG_GETARG_DATUM(n))
 /* 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
+#define PG_GETARG_VARLENA_P(n) PG_DETOAST_DATUM(PG_GETARG_DATUM(n))
+/* DatumGetFoo macros for varlena types will typically look like this: */
+#define DatumGetByteaP(X)    ((bytea *) PG_DETOAST_DATUM(X))
+#define DatumGetTextP(X)     ((text *) PG_DETOAST_DATUM(X))
+#define DatumGetBpCharP(X)   ((BpChar *) PG_DETOAST_DATUM(X))
+#define DatumGetVarCharP(X)  ((VarChar *) PG_DETOAST_DATUM(X))
 /* GETARG macros for varlena types will typically look like this: */
-#define PG_GETARG_TEXT_P(n) ((text *) PG_GETARG_VARLENA_P(n))
+#define PG_GETARG_BYTEA_P(n)   DatumGetByteaP(PG_GETARG_DATUM(n))
+#define PG_GETARG_TEXT_P(n)    DatumGetTextP(PG_GETARG_DATUM(n))
+#define PG_GETARG_BPCHAR_P(n)  DatumGetBpCharP(PG_GETARG_DATUM(n))
+#define PG_GETARG_VARCHAR_P(n) DatumGetVarCharP(PG_GETARG_DATUM(n))
 
 /* To return a NULL do this: */
 #define PG_RETURN_NULL()  \
@@ -151,7 +163,10 @@ extern void fmgr_info(Oid functionId, FmgrInfo *finfo);
 #define PG_RETURN_FLOAT8(x)  return Float8GetDatum(x)
 #define PG_RETURN_INT64(x)   return Int64GetDatum(x)
 /* RETURN macros for other pass-by-ref types will typically look like this: */
-#define PG_RETURN_TEXT_P(x)  PG_RETURN_POINTER(x)
+#define PG_RETURN_BYTEA_P(x)   PG_RETURN_POINTER(x)
+#define PG_RETURN_TEXT_P(x)    PG_RETURN_POINTER(x)
+#define PG_RETURN_BPCHAR_P(x)  PG_RETURN_POINTER(x)
+#define PG_RETURN_VARCHAR_P(x) PG_RETURN_POINTER(x)
 
 
 /*-------------------------------------------------------------------------

src/include/mb/pg_wchar.h

-/* $Id: pg_wchar.h,v 1.14 2000/04/20 22:40:18 tgl Exp $ */
+/* $Id: pg_wchar.h,v 1.15 2000/06/13 07:35:27 tgl Exp $ */
 
 #ifndef PG_WCHAR_H
 #define PG_WCHAR_H
@@ -122,11 +122,11 @@ extern unsigned char *pg_client_to_server(unsigned char *, int);
 extern unsigned char *pg_server_to_client(unsigned char *, int);
 extern int	pg_valid_client_encoding(const char *);
 
-/* moved to miscadmin.h
- * pg_proc.h now have them.
+/* internally-used versions of functions.  The PG_xxx forms of these
+ * functions have fmgr-compatible interfaves.
+ */
 extern const char *pg_encoding_to_char(int);
 extern int	pg_char_to_encoding(const char *);
-*/
 
 extern int	GetDatabaseEncoding(void);
 extern void SetDatabaseEncoding(int);

src/include/miscadmin.h

@@ -12,7 +12,7 @@
  * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: miscadmin.h,v 1.58 2000/06/08 22:37:35 momjian Exp $
+ * $Id: miscadmin.h,v 1.59 2000/06/13 07:35:24 tgl Exp $
  *
  * NOTES
  *	  some of the information in this file will be moved to
@@ -131,13 +131,6 @@ extern char *ExpandDatabasePath(const char *path);
 extern void SetDatabaseName(const char *name);
 extern void SetDatabasePath(const char *path);
 
-/* even if MULTIBYTE is not enabled, this function is neccesary
- * since pg_proc.h does have.
- */
-extern const char *getdatabaseencoding(void);
-extern const char *pg_encoding_to_char(int);
-extern int	pg_char_to_encoding(const char *);
-
 extern char *getpgusername(void);
 extern void SetPgUserName(void);
 extern int	GetUserId(void);

src/include/utils/cash.h

@@ -33,9 +33,9 @@ extern Cash *cash_mul_flt4(Cash *c, float4 *f);
 extern Cash *cash_div_flt4(Cash *c, float4 *f);
 extern Cash *flt4_mul_cash(float4 *f, Cash *c);
 
-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 Datum cash_mul_int4(PG_FUNCTION_ARGS);
+extern Datum cash_div_int4(PG_FUNCTION_ARGS);
+extern Datum int4_mul_cash(PG_FUNCTION_ARGS);
 
 extern Datum cash_mul_int2(PG_FUNCTION_ARGS);
 extern Datum int2_mul_cash(PG_FUNCTION_ARGS);

src/test/regress/input/create_function_1.source

@@ -40,5 +40,5 @@ CREATE FUNCTION ttdummy ()
 CREATE FUNCTION set_ttdummy (int4)
         RETURNS int4
         AS '_OBJWD_/regress_DLSUFFIX_'
-        LANGUAGE 'c';
+        LANGUAGE 'newC';
 

src/test/regress/output/create_function_1.source

@@ -33,4 +33,4 @@ CREATE FUNCTION ttdummy ()
 CREATE FUNCTION set_ttdummy (int4)
         RETURNS int4
         AS '_OBJWD_/regress_DLSUFFIX_'
-        LANGUAGE 'c';
+        LANGUAGE 'newC';