Another pgindent run with updated typedefs.

66 files changed, 459 insertions, 456 deletions

diff --git a/src/backend/access/index/indexam.c b/src/backend/access/index/indexam.c
index 69470e33a62..fb88535f0e0 100644
--- a/src/backend/access/index/indexam.c
+++ b/src/backend/access/index/indexam.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/index/indexam.c,v 1.69 2003/08/04 02:39:57 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/index/indexam.c,v 1.70 2003/08/08 21:41:25 momjian Exp $
  *
  * INTERFACE ROUTINES
  *		index_open		- open an index relation by relation OID
@@ -632,7 +632,7 @@ index_bulk_delete(Relation indexRelation,
  */
 IndexBulkDeleteResult *
 index_vacuum_cleanup(Relation indexRelation,
-					 IndexVacuumCleanupInfo * info,
+					 IndexVacuumCleanupInfo *info,
 					 IndexBulkDeleteResult *stats)
 {
 	RegProcedure procedure;
diff --git a/src/backend/access/nbtree/nbtpage.c b/src/backend/access/nbtree/nbtpage.c
index 21a4121f406..b0aff28a596 100644
--- a/src/backend/access/nbtree/nbtpage.c
+++ b/src/backend/access/nbtree/nbtpage.c
@@ -9,7 +9,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtpage.c,v 1.68 2003/08/04 02:39:57 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtpage.c,v 1.69 2003/08/08 21:41:27 momjian Exp $
  *
  *	NOTES
  *	   Postgres btree pages look like ordinary relation pages.	The opaque
@@ -1110,11 +1110,10 @@ _bt_pagedel(Relation rel, Buffer buf, bool vacuum_full)
 		_bt_wrtbuf(rel, lbuf);
 
 	/*
-	 * If parent became half dead, recurse to try to delete it.
-	 * Otherwise, if right sibling is empty and is now the last child of
-	 * the parent, recurse to try to delete it.  (These cases cannot apply
-	 * at the same time, though the second case might itself recurse to
-	 * the first.)
+	 * If parent became half dead, recurse to try to delete it. Otherwise,
+	 * if right sibling is empty and is now the last child of the parent,
+	 * recurse to try to delete it.  (These cases cannot apply at the same
+	 * time, though the second case might itself recurse to the first.)
 	 */
 	if (parent_half_dead)
 	{
diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index 2dcf9b0e1af..d27af61c5cd 100644
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -8,7 +8,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtsearch.c,v 1.79 2003/08/04 02:39:57 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtsearch.c,v 1.80 2003/08/08 21:41:27 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -951,9 +951,9 @@ _bt_walk_left(Relation rel, Buffer buf)
 
 		/*
 		 * If this isn't the page we want, walk right till we find what we
-		 * want --- but go no more than four hops (an arbitrary limit).
-		 * If we don't find the correct page by then, the most likely bet
-		 * is that the original page got deleted and isn't in the sibling
+		 * want --- but go no more than four hops (an arbitrary limit). If
+		 * we don't find the correct page by then, the most likely bet is
+		 * that the original page got deleted and isn't in the sibling
 		 * chain at all anymore, not that its left sibling got split more
 		 * than four times.
 		 *
diff --git a/src/backend/access/nbtree/nbtxlog.c b/src/backend/access/nbtree/nbtxlog.c
index b7b22477e86..4fecd3116af 100644
--- a/src/backend/access/nbtree/nbtxlog.c
+++ b/src/backend/access/nbtree/nbtxlog.c
@@ -8,7 +8,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtxlog.c,v 1.5 2003/08/04 02:39:57 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtxlog.c,v 1.6 2003/08/08 21:41:27 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -32,7 +32,7 @@ typedef struct bt_incomplete_split
 	BlockNumber leftblk;		/* left half of split */
 	BlockNumber rightblk;		/* right half of split */
 	bool		is_root;		/* we split the root */
-}	bt_incomplete_split;
+} bt_incomplete_split;
 
 static List *incomplete_splits;
 
diff --git a/src/backend/access/transam/slru.c b/src/backend/access/transam/slru.c
index 95e13e72fdd..3f0d387d447 100644
--- a/src/backend/access/transam/slru.c
+++ b/src/backend/access/transam/slru.c
@@ -6,7 +6,7 @@
  * Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Header: /cvsroot/pgsql/src/backend/access/transam/slru.c,v 1.5 2003/08/08 14:39:45 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/transam/slru.c,v 1.6 2003/08/08 21:41:27 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -93,7 +93,7 @@ typedef enum
 	SLRU_PAGE_CLEAN,			/* page is valid and not dirty */
 	SLRU_PAGE_DIRTY,			/* page is valid but needs write */
 	SLRU_PAGE_WRITE_IN_PROGRESS /* page is being written out */
-}	SlruPageStatus;
+} SlruPageStatus;
 
 /*
  * Shared-memory state
@@ -117,7 +117,7 @@ typedef struct SlruSharedData
 	 * swapping out the latest page.
 	 */
 	int			latest_page_number;
-}	SlruSharedData;
+} SlruSharedData;
 typedef SlruSharedData *SlruShared;
 
 
@@ -145,7 +145,7 @@ typedef enum
 	SLRU_SEEK_FAILED,
 	SLRU_READ_FAILED,
 	SLRU_WRITE_FAILED
-}	SlruErrorCause;
+} SlruErrorCause;
 static SlruErrorCause slru_errcause;
 static int	slru_errno;
 
diff --git a/src/backend/access/transam/xact.c b/src/backend/access/transam/xact.c
index a85337100b7..e632ae9e1f4 100644
--- a/src/backend/access/transam/xact.c
+++ b/src/backend/access/transam/xact.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/transam/xact.c,v 1.151 2003/08/04 02:39:57 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/transam/xact.c,v 1.152 2003/08/08 21:41:28 momjian Exp $
  *
  * NOTES
  *		Transaction aborts can now occur two ways:
@@ -954,9 +954,9 @@ CommitTransaction(void)
 	 *
 	 * The ordering of operations is not entirely random.  The idea is:
 	 * release resources visible to other backends (eg, files, buffer
-	 * pins); then release locks; then release backend-local resources.
-	 * We want to release locks at the point where any backend waiting for
-	 * us will see our transaction as being fully cleaned up.
+	 * pins); then release locks; then release backend-local resources. We
+	 * want to release locks at the point where any backend waiting for us
+	 * will see our transaction as being fully cleaned up.
 	 */
 
 	smgrDoPendingDeletes(true);
diff --git a/src/backend/commands/cluster.c b/src/backend/commands/cluster.c
index 4cb5f23033c..6056a195e75 100644
--- a/src/backend/commands/cluster.c
+++ b/src/backend/commands/cluster.c
@@ -11,7 +11,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/commands/cluster.c,v 1.114 2003/08/04 02:39:58 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/commands/cluster.c,v 1.115 2003/08/08 21:41:28 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -60,10 +60,10 @@ typedef struct
 {
 	Oid			tableOid;
 	Oid			indexOid;
-}	RelToCluster;
+} RelToCluster;
 
 
-static void cluster_rel(RelToCluster * rv, bool recheck);
+static void cluster_rel(RelToCluster *rv, bool recheck);
 static Oid	make_new_heap(Oid OIDOldHeap, const char *NewName);
 static void copy_heap_data(Oid OIDNewHeap, Oid OIDOldHeap, Oid OIDOldIndex);
 static List *get_indexattr_list(Relation OldHeap, Oid OldIndex);
@@ -248,7 +248,7 @@ cluster(ClusterStmt *stmt)
  * them incrementally while we load the table.
  */
 static void
-cluster_rel(RelToCluster * rvtc, bool recheck)
+cluster_rel(RelToCluster *rvtc, bool recheck)
 {
 	Relation	OldHeap,
 				OldIndex;
diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index e8b65909851..eb8a796f229 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/commands/copy.c,v 1.207 2003/08/04 02:39:58 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/commands/copy.c,v 1.208 2003/08/08 21:41:30 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -61,7 +61,7 @@ typedef enum CopyDest
 	COPY_FILE,					/* to/from file */
 	COPY_OLD_FE,				/* to/from frontend (old protocol) */
 	COPY_NEW_FE					/* to/from frontend (new protocol) */
-}	CopyDest;
+} CopyDest;
 
 /*
  * Represents the type of data returned by CopyReadAttribute()
@@ -82,7 +82,7 @@ typedef enum EolType
 	EOL_NL,
 	EOL_CR,
 	EOL_CRNL
-}	EolType;
+} EolType;
 
 
 /* non-export function prototypes */
diff --git a/src/backend/commands/explain.c b/src/backend/commands/explain.c
index a1e64bf4ef1..6e2b8572713 100644
--- a/src/backend/commands/explain.c
+++ b/src/backend/commands/explain.c
@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1994-5, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/commands/explain.c,v 1.113 2003/08/04 02:39:58 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/commands/explain.c,v 1.114 2003/08/08 21:41:30 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -47,7 +47,7 @@ static void ExplainOneQuery(Query *query, ExplainStmt *stmt,
 				TupOutputState *tstate);
 static double elapsed_time(struct timeval * starttime);
 static void explain_outNode(StringInfo str,
-				Plan *plan, PlanState * planstate,
+				Plan *plan, PlanState *planstate,
 				Plan *outer_plan,
 				int indent, ExplainState *es);
 static void show_scan_qual(List *qual, bool is_or_qual, const char *qlabel,
@@ -313,7 +313,7 @@ elapsed_time(struct timeval * starttime)
  */
 static void
 explain_outNode(StringInfo str,
-				Plan *plan, PlanState * planstate,
+				Plan *plan, PlanState *planstate,
 				Plan *outer_plan,
 				int indent, ExplainState *es)
 {
diff --git a/src/backend/commands/portalcmds.c b/src/backend/commands/portalcmds.c
index 0a446df3685..c11b48db4c1 100644
--- a/src/backend/commands/portalcmds.c
+++ b/src/backend/commands/portalcmds.c
@@ -14,7 +14,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/commands/portalcmds.c,v 1.22 2003/08/06 17:46:45 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/commands/portalcmds.c,v 1.23 2003/08/08 21:41:32 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -36,7 +36,7 @@
  *		Execute SQL DECLARE CURSOR command.
  */
 void
-PerformCursorOpen(DeclareCursorStmt * stmt)
+PerformCursorOpen(DeclareCursorStmt *stmt)
 {
 	List	   *rewritten;
 	Query	   *query;
diff --git a/src/backend/commands/prepare.c b/src/backend/commands/prepare.c
index d0fabd1ad31..d48bbeddecb 100644
--- a/src/backend/commands/prepare.c
+++ b/src/backend/commands/prepare.c
@@ -10,7 +10,7 @@
  * Copyright (c) 2002-2003, PostgreSQL Global Development Group
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/commands/prepare.c,v 1.22 2003/08/04 00:43:16 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/commands/prepare.c,v 1.23 2003/08/08 21:41:32 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -412,7 +412,7 @@ FetchPreparedStatementParams(const char *stmt_name)
  * Note: the result is created or copied into current memory context.
  */
 TupleDesc
-FetchPreparedStatementResultDesc(PreparedStatement * stmt)
+FetchPreparedStatementResultDesc(PreparedStatement *stmt)
 {
 	Query	   *query;
 
diff --git a/src/backend/commands/sequence.c b/src/backend/commands/sequence.c
index 7b29f5c5cdf..c62f4a71c56 100644
--- a/src/backend/commands/sequence.c
+++ b/src/backend/commands/sequence.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/commands/sequence.c,v 1.101 2003/08/04 02:39:58 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/commands/sequence.c,v 1.102 2003/08/08 21:41:32 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -302,7 +302,7 @@ DefineSequence(CreateSeqStmt *seq)
  * Modify the defition of a sequence relation
  */
 void
-AlterSequence(AlterSeqStmt * stmt)
+AlterSequence(AlterSeqStmt *stmt)
 {
 	SeqTable	elm;
 	Relation	seqrel;
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index 079d891f073..77885802335 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/commands/tablecmds.c,v 1.78 2003/08/04 02:39:58 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/commands/tablecmds.c,v 1.79 2003/08/08 21:41:32 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -69,7 +69,7 @@ typedef struct OnCommitItem
 	 */
 	bool		created_in_cur_xact;
 	bool		deleted_in_cur_xact;
-}	OnCommitItem;
+} OnCommitItem;
 
 static List *on_commits = NIL;
 
diff --git a/src/backend/commands/trigger.c b/src/backend/commands/trigger.c
index 5ea4778ce32..3e49f5add36 100644
--- a/src/backend/commands/trigger.c
+++ b/src/backend/commands/trigger.c
@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/commands/trigger.c,v 1.155 2003/08/04 02:39:58 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/commands/trigger.c,v 1.156 2003/08/08 21:41:32 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -1653,7 +1653,7 @@ typedef struct DeferredTriggersData
 	DeferredTriggerEvent deftrig_events;
 	DeferredTriggerEvent deftrig_events_imm;
 	DeferredTriggerEvent deftrig_event_tail;
-}	DeferredTriggersData;
+} DeferredTriggersData;
 
 /* ----------
  * deftrig_events, deftrig_event_tail:
diff --git a/src/backend/commands/typecmds.c b/src/backend/commands/typecmds.c
index 86258fb02d5..bb339cfb770 100644
--- a/src/backend/commands/typecmds.c
+++ b/src/backend/commands/typecmds.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/commands/typecmds.c,v 1.42 2003/08/04 02:39:58 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/commands/typecmds.c,v 1.43 2003/08/08 21:41:32 momjian Exp $
  *
  * DESCRIPTION
  *	  The "DefineFoo" routines take the parse tree and pick out the
@@ -70,7 +70,7 @@ typedef struct
 	int			natts;			/* number of attributes of interest */
 	int		   *atts;			/* attribute numbers */
 	/* atts[] is of allocated length RelationGetNumberOfAttributes(rel) */
-}	RelToCheck;
+} RelToCheck;
 
 
 static Oid	findTypeInputFunction(List *procname, Oid typeOid);
diff --git a/src/backend/executor/execAmi.c b/src/backend/executor/execAmi.c
index 02f8ae6af0a..a8eca13f1bc 100644
--- a/src/backend/executor/execAmi.c
+++ b/src/backend/executor/execAmi.c
@@ -6,7 +6,7 @@
  * Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- *	$Header: /cvsroot/pgsql/src/backend/executor/execAmi.c,v 1.74 2003/08/04 02:39:58 momjian Exp $
+ *	$Header: /cvsroot/pgsql/src/backend/executor/execAmi.c,v 1.75 2003/08/08 21:41:34 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -48,7 +48,7 @@
  * ----------------------------------------------------------------
  */
 void
-ExecReScan(PlanState * node, ExprContext *exprCtxt)
+ExecReScan(PlanState *node, ExprContext *exprCtxt)
 {
 	/* If collecting timing stats, update them */
 	if (node->instrument)
@@ -177,7 +177,7 @@ ExecReScan(PlanState * node, ExprContext *exprCtxt)
  * Marks the current scan position.
  */
 void
-ExecMarkPos(PlanState * node)
+ExecMarkPos(PlanState *node)
 {
 	switch (nodeTag(node))
 	{
@@ -218,7 +218,7 @@ ExecMarkPos(PlanState * node)
  * restores the scan position previously saved with ExecMarkPos()
  */
 void
-ExecRestrPos(PlanState * node)
+ExecRestrPos(PlanState *node)
 {
 	switch (nodeTag(node))
 	{
diff --git a/src/backend/executor/execGrouping.c b/src/backend/executor/execGrouping.c
index 351cbc3171c..100e7a1c375 100644
--- a/src/backend/executor/execGrouping.c
+++ b/src/backend/executor/execGrouping.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/executor/execGrouping.c,v 1.6 2003/08/04 02:39:58 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/executor/execGrouping.c,v 1.7 2003/08/08 21:41:34 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -296,7 +296,7 @@ BuildTupleHashTable(int numCols, AttrNumber *keyColIdx,
 	Assert(entrysize >= sizeof(TupleHashEntryData));
 
 	tabsize = sizeof(TupleHashTableData) +
-		(nbuckets - 1) * sizeof(TupleHashEntry);
+		(nbuckets - 1) *sizeof(TupleHashEntry);
 	hashtable = (TupleHashTable) MemoryContextAllocZero(tablecxt, tabsize);
 
 	hashtable->numCols = numCols;
@@ -411,7 +411,7 @@ LookupTupleHashEntry(TupleHashTable hashtable, TupleTableSlot *slot,
  * Iterator state must be initialized with ResetTupleHashIterator() macro.
  */
 TupleHashEntry
-ScanTupleHashTable(TupleHashTable hashtable, TupleHashIterator * state)
+ScanTupleHashTable(TupleHashTable hashtable, TupleHashIterator *state)
 {
 	TupleHashEntry entry;
 
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index e76f294c05f..a75edb370a2 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -26,7 +26,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/executor/execMain.c,v 1.215 2003/08/06 17:46:45 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/executor/execMain.c,v 1.216 2003/08/08 21:41:34 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -68,7 +68,7 @@ static void initResultRelInfo(ResultRelInfo *resultRelInfo,
 				  Index resultRelationIndex,
 				  List *rangeTable,
 				  CmdType operation);
-static TupleTableSlot *ExecutePlan(EState *estate, PlanState * planstate,
+static TupleTableSlot *ExecutePlan(EState *estate, PlanState *planstate,
 			CmdType operation,
 			long numberTuples,
 			ScanDirection direction,
@@ -895,7 +895,7 @@ initResultRelInfo(ResultRelInfo *resultRelInfo,
  * ----------------------------------------------------------------
  */
 void
-ExecEndPlan(PlanState * planstate, EState *estate)
+ExecEndPlan(PlanState *planstate, EState *estate)
 {
 	ResultRelInfo *resultRelInfo;
 	int			i;
@@ -965,7 +965,7 @@ ExecEndPlan(PlanState * planstate, EState *estate)
  */
 static TupleTableSlot *
 ExecutePlan(EState *estate,
-			PlanState * planstate,
+			PlanState *planstate,
 			CmdType operation,
 			long numberTuples,
 			ScanDirection direction,
diff --git a/src/backend/executor/execProcnode.c b/src/backend/executor/execProcnode.c
index a282cf0f34e..8beebdedc18 100644
--- a/src/backend/executor/execProcnode.c
+++ b/src/backend/executor/execProcnode.c
@@ -12,7 +12,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/executor/execProcnode.c,v 1.39 2003/08/04 02:39:58 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/executor/execProcnode.c,v 1.40 2003/08/08 21:41:39 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -268,7 +268,7 @@ ExecInitNode(Plan *node, EState *estate)
  * ----------------------------------------------------------------
  */
 TupleTableSlot *
-ExecProcNode(PlanState * node)
+ExecProcNode(PlanState *node)
 {
 	TupleTableSlot *result;
 
@@ -484,7 +484,7 @@ ExecCountSlotsNode(Plan *node)
  * ----------------------------------------------------------------
  */
 void
-ExecEndNode(PlanState * node)
+ExecEndNode(PlanState *node)
 {
 	List	   *subp;
 
diff --git a/src/backend/executor/execQual.c b/src/backend/executor/execQual.c
index 48cc71a1de5..4ecae71cd68 100644
--- a/src/backend/executor/execQual.c
+++ b/src/backend/executor/execQual.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.140 2003/08/04 02:39:58 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.141 2003/08/08 21:41:39 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -50,53 +50,53 @@
 
 
 /* static function decls */
-static Datum ExecEvalAggref(AggrefExprState * aggref,
+static Datum ExecEvalAggref(AggrefExprState *aggref,
 			   ExprContext *econtext,
 			   bool *isNull);
-static Datum ExecEvalArrayRef(ArrayRefExprState * astate,
+static Datum ExecEvalArrayRef(ArrayRefExprState *astate,
 				 ExprContext *econtext,
 				 bool *isNull, ExprDoneCond *isDone);
 static Datum ExecEvalVar(Var *variable, ExprContext *econtext, bool *isNull);
 static Datum ExecEvalParam(Param *expression, ExprContext *econtext,
 			  bool *isNull);
-static Datum ExecEvalFunc(FuncExprState * fcache, ExprContext *econtext,
+static Datum ExecEvalFunc(FuncExprState *fcache, ExprContext *econtext,
 			 bool *isNull, ExprDoneCond *isDone);
-static Datum ExecEvalOper(FuncExprState * fcache, ExprContext *econtext,
+static Datum ExecEvalOper(FuncExprState *fcache, ExprContext *econtext,
 			 bool *isNull, ExprDoneCond *isDone);
-static Datum ExecEvalDistinct(FuncExprState * fcache, ExprContext *econtext,
+static Datum ExecEvalDistinct(FuncExprState *fcache, ExprContext *econtext,
 				 bool *isNull);
-static Datum ExecEvalScalarArrayOp(ScalarArrayOpExprState * sstate,
+static Datum ExecEvalScalarArrayOp(ScalarArrayOpExprState *sstate,
 					  ExprContext *econtext, bool *isNull);
 static ExprDoneCond ExecEvalFuncArgs(FunctionCallInfo fcinfo,
 				 List *argList, ExprContext *econtext);
-static Datum ExecEvalNot(BoolExprState * notclause, ExprContext *econtext,
+static Datum ExecEvalNot(BoolExprState *notclause, ExprContext *econtext,
 			bool *isNull);
-static Datum ExecEvalOr(BoolExprState * orExpr, ExprContext *econtext,
+static Datum ExecEvalOr(BoolExprState *orExpr, ExprContext *econtext,
 		   bool *isNull);
-static Datum ExecEvalAnd(BoolExprState * andExpr, ExprContext *econtext,
+static Datum ExecEvalAnd(BoolExprState *andExpr, ExprContext *econtext,
 			bool *isNull);
-static Datum ExecEvalCase(CaseExprState * caseExpr, ExprContext *econtext,
+static Datum ExecEvalCase(CaseExprState *caseExpr, ExprContext *econtext,
 			 bool *isNull, ExprDoneCond *isDone);
-static Datum ExecEvalArray(ArrayExprState * astate,
+static Datum ExecEvalArray(ArrayExprState *astate,
 			  ExprContext *econtext,
 			  bool *isNull);
-static Datum ExecEvalCoalesce(CoalesceExprState * coalesceExpr,
+static Datum ExecEvalCoalesce(CoalesceExprState *coalesceExpr,
 				 ExprContext *econtext,
 				 bool *isNull);
-static Datum ExecEvalNullIf(FuncExprState * nullIfExpr, ExprContext *econtext,
+static Datum ExecEvalNullIf(FuncExprState *nullIfExpr, ExprContext *econtext,
 			   bool *isNull);
-static Datum ExecEvalNullTest(GenericExprState * nstate,
+static Datum ExecEvalNullTest(GenericExprState *nstate,
 				 ExprContext *econtext,
 				 bool *isNull, ExprDoneCond *isDone);
-static Datum ExecEvalBooleanTest(GenericExprState * bstate,
+static Datum ExecEvalBooleanTest(GenericExprState *bstate,
 					ExprContext *econtext,
 					bool *isNull, ExprDoneCond *isDone);
-static Datum ExecEvalCoerceToDomain(CoerceToDomainState * cstate,
+static Datum ExecEvalCoerceToDomain(CoerceToDomainState *cstate,
 					   ExprContext *econtext,
 					   bool *isNull, ExprDoneCond *isDone);
-static Datum ExecEvalCoerceToDomainValue(CoerceToDomainValue * conVal,
+static Datum ExecEvalCoerceToDomainValue(CoerceToDomainValue *conVal,
 							ExprContext *econtext, bool *isNull);
-static Datum ExecEvalFieldSelect(GenericExprState * fstate,
+static Datum ExecEvalFieldSelect(GenericExprState *fstate,
 					ExprContext *econtext,
 					bool *isNull, ExprDoneCond *isDone);
 
@@ -127,7 +127,7 @@ static Datum ExecEvalFieldSelect(GenericExprState * fstate,
  *----------
  */
 static Datum
-ExecEvalArrayRef(ArrayRefExprState * astate,
+ExecEvalArrayRef(ArrayRefExprState *astate,
 				 ExprContext *econtext,
 				 bool *isNull,
 				 ExprDoneCond *isDone)
@@ -301,7 +301,7 @@ ExecEvalArrayRef(ArrayRefExprState * astate,
  * ----------------------------------------------------------------
  */
 static Datum
-ExecEvalAggref(AggrefExprState * aggref, ExprContext *econtext, bool *isNull)
+ExecEvalAggref(AggrefExprState *aggref, ExprContext *econtext, bool *isNull)
 {
 	if (econtext->ecxt_aggvalues == NULL)		/* safety check */
 		elog(ERROR, "no aggregates in this expression context");
@@ -606,7 +606,7 @@ GetAttributeByName(TupleTableSlot *slot, char *attname, bool *isNull)
  * init_fcache - initialize a FuncExprState node during first use
  */
 void
-init_fcache(Oid foid, FuncExprState * fcache, MemoryContext fcacheCxt)
+init_fcache(Oid foid, FuncExprState *fcache, MemoryContext fcacheCxt)
 {
 	AclResult	aclresult;
 
@@ -679,7 +679,7 @@ ExecEvalFuncArgs(FunctionCallInfo fcinfo,
  * Evaluate the arguments to a function and then the function itself.
  */
 Datum
-ExecMakeFunctionResult(FuncExprState * fcache,
+ExecMakeFunctionResult(FuncExprState *fcache,
 					   ExprContext *econtext,
 					   bool *isNull,
 					   ExprDoneCond *isDone)
@@ -882,7 +882,7 @@ ExecMakeFunctionResult(FuncExprState * fcache,
  * object.	(If function returns an empty set, we just return NULL instead.)
  */
 Tuplestorestate *
-ExecMakeTableFunctionResult(ExprState * funcexpr,
+ExecMakeTableFunctionResult(ExprState *funcexpr,
 							ExprContext *econtext,
 							TupleDesc expectedDesc,
 							TupleDesc *returnDesc)
@@ -1159,7 +1159,7 @@ ExecMakeTableFunctionResult(ExprState * funcexpr,
  * ----------------------------------------------------------------
  */
 static Datum
-ExecEvalFunc(FuncExprState * fcache,
+ExecEvalFunc(FuncExprState *fcache,
 			 ExprContext *econtext,
 			 bool *isNull,
 			 ExprDoneCond *isDone)
@@ -1182,7 +1182,7 @@ ExecEvalFunc(FuncExprState * fcache,
  * ----------------------------------------------------------------
  */
 static Datum
-ExecEvalOper(FuncExprState * fcache,
+ExecEvalOper(FuncExprState *fcache,
 			 ExprContext *econtext,
 			 bool *isNull,
 			 ExprDoneCond *isDone)
@@ -1212,7 +1212,7 @@ ExecEvalOper(FuncExprState * fcache,
  * ----------------------------------------------------------------
  */
 static Datum
-ExecEvalDistinct(FuncExprState * fcache,
+ExecEvalDistinct(FuncExprState *fcache,
 				 ExprContext *econtext,
 				 bool *isNull)
 {
@@ -1278,7 +1278,7 @@ ExecEvalDistinct(FuncExprState * fcache,
  * the result is known.
  */
 static Datum
-ExecEvalScalarArrayOp(ScalarArrayOpExprState * sstate,
+ExecEvalScalarArrayOp(ScalarArrayOpExprState *sstate,
 					  ExprContext *econtext, bool *isNull)
 {
 	ScalarArrayOpExpr *opexpr = (ScalarArrayOpExpr *) sstate->fxprstate.xprstate.expr;
@@ -1431,7 +1431,7 @@ ExecEvalScalarArrayOp(ScalarArrayOpExprState * sstate,
  * ----------------------------------------------------------------
  */
 static Datum
-ExecEvalNot(BoolExprState * notclause, ExprContext *econtext, bool *isNull)
+ExecEvalNot(BoolExprState *notclause, ExprContext *econtext, bool *isNull)
 {
 	ExprState  *clause;
 	Datum		expr_value;
@@ -1459,7 +1459,7 @@ ExecEvalNot(BoolExprState * notclause, ExprContext *econtext, bool *isNull)
  * ----------------------------------------------------------------
  */
 static Datum
-ExecEvalOr(BoolExprState * orExpr, ExprContext *econtext, bool *isNull)
+ExecEvalOr(BoolExprState *orExpr, ExprContext *econtext, bool *isNull)
 {
 	List	   *clauses;
 	List	   *clause;
@@ -1507,7 +1507,7 @@ ExecEvalOr(BoolExprState * orExpr, ExprContext *econtext, bool *isNull)
  * ----------------------------------------------------------------
  */
 static Datum
-ExecEvalAnd(BoolExprState * andExpr, ExprContext *econtext, bool *isNull)
+ExecEvalAnd(BoolExprState *andExpr, ExprContext *econtext, bool *isNull)
 {
 	List	   *clauses;
 	List	   *clause;
@@ -1555,7 +1555,7 @@ ExecEvalAnd(BoolExprState * andExpr, ExprContext *econtext, bool *isNull)
  * ----------------------------------------------------------------
  */
 static Datum
-ExecEvalCase(CaseExprState * caseExpr, ExprContext *econtext,
+ExecEvalCase(CaseExprState *caseExpr, ExprContext *econtext,
 			 bool *isNull, ExprDoneCond *isDone)
 {
 	List	   *clauses;
@@ -1613,7 +1613,7 @@ ExecEvalCase(CaseExprState * caseExpr, ExprContext *econtext,
  * ----------------------------------------------------------------
  */
 static Datum
-ExecEvalArray(ArrayExprState * astate, ExprContext *econtext,
+ExecEvalArray(ArrayExprState *astate, ExprContext *econtext,
 			  bool *isNull)
 {
 	ArrayExpr  *arrayExpr = (ArrayExpr *) astate->xprstate.expr;
@@ -1770,7 +1770,7 @@ ExecEvalArray(ArrayExprState * astate, ExprContext *econtext,
  * ----------------------------------------------------------------
  */
 static Datum
-ExecEvalCoalesce(CoalesceExprState * coalesceExpr, ExprContext *econtext,
+ExecEvalCoalesce(CoalesceExprState *coalesceExpr, ExprContext *econtext,
 				 bool *isNull)
 {
 	List	   *arg;
@@ -1800,7 +1800,7 @@ ExecEvalCoalesce(CoalesceExprState * coalesceExpr, ExprContext *econtext,
  * ----------------------------------------------------------------
  */
 static Datum
-ExecEvalNullIf(FuncExprState * fcache, ExprContext *econtext,
+ExecEvalNullIf(FuncExprState *fcache, ExprContext *econtext,
 			   bool *isNull)
 {
 	Datum		result;
@@ -1859,7 +1859,7 @@ ExecEvalNullIf(FuncExprState * fcache, ExprContext *econtext,
  * ----------------------------------------------------------------
  */
 static Datum
-ExecEvalNullTest(GenericExprState * nstate,
+ExecEvalNullTest(GenericExprState *nstate,
 				 ExprContext *econtext,
 				 bool *isNull,
 				 ExprDoneCond *isDone)
@@ -1904,7 +1904,7 @@ ExecEvalNullTest(GenericExprState * nstate,
  * ----------------------------------------------------------------
  */
 static Datum
-ExecEvalBooleanTest(GenericExprState * bstate,
+ExecEvalBooleanTest(GenericExprState *bstate,
 					ExprContext *econtext,
 					bool *isNull,
 					ExprDoneCond *isDone)
@@ -1990,7 +1990,7 @@ ExecEvalBooleanTest(GenericExprState * bstate,
  * datum) otherwise throw an error.
  */
 static Datum
-ExecEvalCoerceToDomain(CoerceToDomainState * cstate, ExprContext *econtext,
+ExecEvalCoerceToDomain(CoerceToDomainState *cstate, ExprContext *econtext,
 					   bool *isNull, ExprDoneCond *isDone)
 {
 	CoerceToDomain *ctest = (CoerceToDomain *) cstate->xprstate.expr;
@@ -2067,7 +2067,7 @@ ExecEvalCoerceToDomain(CoerceToDomainState * cstate, ExprContext *econtext,
  * Return the value stored by CoerceToDomain.
  */
 static Datum
-ExecEvalCoerceToDomainValue(CoerceToDomainValue * conVal,
+ExecEvalCoerceToDomainValue(CoerceToDomainValue *conVal,
 							ExprContext *econtext, bool *isNull)
 {
 	*isNull = econtext->domainValue_isNull;
@@ -2081,7 +2081,7 @@ ExecEvalCoerceToDomainValue(CoerceToDomainValue * conVal,
  * ----------------------------------------------------------------
  */
 static Datum
-ExecEvalFieldSelect(GenericExprState * fstate,
+ExecEvalFieldSelect(GenericExprState *fstate,
 					ExprContext *econtext,
 					bool *isNull,
 					ExprDoneCond *isDone)
@@ -2145,7 +2145,7 @@ ExecEvalFieldSelect(GenericExprState * fstate,
  * ----------------------------------------------------------------
  */
 Datum
-ExecEvalExpr(ExprState * expression,
+ExecEvalExpr(ExprState *expression,
 			 ExprContext *econtext,
 			 bool *isNull,
 			 ExprDoneCond *isDone)
@@ -2312,7 +2312,7 @@ ExecEvalExpr(ExprState * expression,
  * Same as above, but get into the right allocation context explicitly.
  */
 Datum
-ExecEvalExprSwitchContext(ExprState * expression,
+ExecEvalExprSwitchContext(ExprState *expression,
 						  ExprContext *econtext,
 						  bool *isNull,
 						  ExprDoneCond *isDone)
@@ -2360,7 +2360,7 @@ ExecEvalExprSwitchContext(ExprState * expression,
  * This case should usually come through ExecPrepareExpr, not directly here.
  */
 ExprState *
-ExecInitExpr(Expr *node, PlanState * parent)
+ExecInitExpr(Expr *node, PlanState *parent)
 {
 	ExprState  *state;
 
@@ -2683,7 +2683,7 @@ ExecInitExpr(Expr *node, PlanState * parent)
  * subplan list.
  */
 SubPlanState *
-ExecInitExprInitPlan(SubPlan *node, PlanState * parent)
+ExecInitExprInitPlan(SubPlan *node, PlanState *parent)
 {
 	SubPlanState *sstate = makeNode(SubPlanState);
 
diff --git a/src/backend/executor/execScan.c b/src/backend/executor/execScan.c
index 36593174d76..6764b3af678 100644
--- a/src/backend/executor/execScan.c
+++ b/src/backend/executor/execScan.c
@@ -12,7 +12,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/executor/execScan.c,v 1.26 2003/08/08 14:39:45 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/executor/execScan.c,v 1.27 2003/08/08 21:41:40 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -45,7 +45,7 @@ static bool tlist_matches_tupdesc(List *tlist, Index varno, TupleDesc tupdesc);
  * ----------------------------------------------------------------
  */
 TupleTableSlot *
-ExecScan(ScanState * node,
+ExecScan(ScanState *node,
 		 ExecScanAccessMtd accessMtd)	/* function returning a tuple */
 {
 	EState	   *estate;
@@ -176,7 +176,7 @@ ExecScan(ScanState * node,
  * ExecAssignScanType must have been called already.
  */
 void
-ExecAssignScanProjectionInfo(ScanState * node)
+ExecAssignScanProjectionInfo(ScanState *node)
 {
 	Scan	   *scan = (Scan *) node->ps.plan;
 
diff --git a/src/backend/executor/execTuples.c b/src/backend/executor/execTuples.c
index 8bc1e5899f9..bef10bc6352 100644
--- a/src/backend/executor/execTuples.c
+++ b/src/backend/executor/execTuples.c
@@ -15,7 +15,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/executor/execTuples.c,v 1.70 2003/08/06 17:46:45 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/executor/execTuples.c,v 1.71 2003/08/08 21:41:40 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -482,7 +482,7 @@ ExecSetSlotDescriptorIsNew(TupleTableSlot *slot,		/* slot to change */
  * ----------------
  */
 void
-ExecInitResultTupleSlot(EState *estate, PlanState * planstate)
+ExecInitResultTupleSlot(EState *estate, PlanState *planstate)
 {
 	INIT_SLOT_DEFS;
 	INIT_SLOT_ALLOC;
@@ -494,7 +494,7 @@ ExecInitResultTupleSlot(EState *estate, PlanState * planstate)
  * ----------------
  */
 void
-ExecInitScanTupleSlot(EState *estate, ScanState * scanstate)
+ExecInitScanTupleSlot(EState *estate, ScanState *scanstate)
 {
 	INIT_SLOT_DEFS;
 	INIT_SLOT_ALLOC;
diff --git a/src/backend/executor/execUtils.c b/src/backend/executor/execUtils.c
index 15c0f82b5b4..9c815f84cda 100644
--- a/src/backend/executor/execUtils.c
+++ b/src/backend/executor/execUtils.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/executor/execUtils.c,v 1.102 2003/08/04 02:39:58 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/executor/execUtils.c,v 1.103 2003/08/08 21:41:40 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -385,7 +385,7 @@ MakePerTupleExprContext(EState *estate)
  * ----------------
  */
 void
-ExecAssignExprContext(EState *estate, PlanState * planstate)
+ExecAssignExprContext(EState *estate, PlanState *planstate)
 {
 	planstate->ps_ExprContext = CreateExprContext(estate);
 }
@@ -395,7 +395,7 @@ ExecAssignExprContext(EState *estate, PlanState * planstate)
  * ----------------
  */
 void
-ExecAssignResultType(PlanState * planstate,
+ExecAssignResultType(PlanState *planstate,
 					 TupleDesc tupDesc, bool shouldFree)
 {
 	TupleTableSlot *slot = planstate->ps_ResultTupleSlot;
@@ -408,7 +408,7 @@ ExecAssignResultType(PlanState * planstate,
  * ----------------
  */
 void
-ExecAssignResultTypeFromOuterPlan(PlanState * planstate)
+ExecAssignResultTypeFromOuterPlan(PlanState *planstate)
 {
 	PlanState  *outerPlan;
 	TupleDesc	tupDesc;
@@ -424,7 +424,7 @@ ExecAssignResultTypeFromOuterPlan(PlanState * planstate)
  * ----------------
  */
 void
-ExecAssignResultTypeFromTL(PlanState * planstate)
+ExecAssignResultTypeFromTL(PlanState *planstate)
 {
 	bool		hasoid = false;
 	TupleDesc	tupDesc;
@@ -479,7 +479,7 @@ ExecAssignResultTypeFromTL(PlanState * planstate)
  * ----------------
  */
 TupleDesc
-ExecGetResultType(PlanState * planstate)
+ExecGetResultType(PlanState *planstate)
 {
 	TupleTableSlot *slot = planstate->ps_ResultTupleSlot;
 
@@ -525,7 +525,7 @@ ExecBuildProjectionInfo(List *targetList,
  * ----------------
  */
 void
-ExecAssignProjectionInfo(PlanState * planstate)
+ExecAssignProjectionInfo(PlanState *planstate)
 {
 	planstate->ps_ProjInfo =
 		ExecBuildProjectionInfo(planstate->targetlist,
@@ -544,7 +544,7 @@ ExecAssignProjectionInfo(PlanState * planstate)
  * ----------------
  */
 void
-ExecFreeExprContext(PlanState * planstate)
+ExecFreeExprContext(PlanState *planstate)
 {
 	ExprContext *econtext;
 
@@ -576,7 +576,7 @@ ExecFreeExprContext(PlanState * planstate)
  * ----------------
  */
 TupleDesc
-ExecGetScanType(ScanState * scanstate)
+ExecGetScanType(ScanState *scanstate)
 {
 	TupleTableSlot *slot = scanstate->ss_ScanTupleSlot;
 
@@ -588,7 +588,7 @@ ExecGetScanType(ScanState * scanstate)
  * ----------------
  */
 void
-ExecAssignScanType(ScanState * scanstate,
+ExecAssignScanType(ScanState *scanstate,
 				   TupleDesc tupDesc, bool shouldFree)
 {
 	TupleTableSlot *slot = scanstate->ss_ScanTupleSlot;
@@ -601,7 +601,7 @@ ExecAssignScanType(ScanState * scanstate,
  * ----------------
  */
 void
-ExecAssignScanTypeFromOuterPlan(ScanState * scanstate)
+ExecAssignScanTypeFromOuterPlan(ScanState *scanstate)
 {
 	PlanState  *outerPlan;
 	TupleDesc	tupDesc;
@@ -879,7 +879,7 @@ ExecInsertIndexTuples(TupleTableSlot *slot,
  *		Add changed parameters to a plan node's chgParam set
  */
 void
-UpdateChangedParamSet(PlanState * node, Bitmapset * newchg)
+UpdateChangedParamSet(PlanState *node, Bitmapset *newchg)
 {
 	Bitmapset  *parmset;
 
diff --git a/src/backend/executor/nodeAgg.c b/src/backend/executor/nodeAgg.c
index 026beb40bed..d8fb9a9565d 100644
--- a/src/backend/executor/nodeAgg.c
+++ b/src/backend/executor/nodeAgg.c
@@ -45,7 +45,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/executor/nodeAgg.c,v 1.114 2003/08/04 02:39:58 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/executor/nodeAgg.c,v 1.115 2003/08/08 21:41:41 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -173,7 +173,7 @@ typedef struct AggStatePerGroupData
 	 * later input value. Only the first non-NULL input will be
 	 * auto-substituted.
 	 */
-}	AggStatePerGroupData;
+} AggStatePerGroupData;
 
 /*
  * To implement hashed aggregation, we need a hashtable that stores a
@@ -188,7 +188,7 @@ typedef struct AggHashEntryData
 	TupleHashEntryData shared;	/* common header for hash table entries */
 	/* per-aggregate transition status array - must be last! */
 	AggStatePerGroupData pergroup[1];	/* VARIABLE LENGTH ARRAY */
-}	AggHashEntryData;	/* VARIABLE LENGTH STRUCT */
+} AggHashEntryData;				/* VARIABLE LENGTH STRUCT */
 
 
 static void initialize_aggregates(AggState *aggstate,
@@ -579,7 +579,7 @@ build_hash_table(AggState *aggstate)
 	Assert(node->numGroups > 0);
 
 	entrysize = sizeof(AggHashEntryData) +
-		(aggstate->numaggs - 1) * sizeof(AggStatePerGroupData);
+		(aggstate->numaggs - 1) *sizeof(AggStatePerGroupData);
 
 	aggstate->hashtable = BuildTupleHashTable(node->numCols,
 											  node->grpColIdx,
diff --git a/src/backend/executor/nodeHashjoin.c b/src/backend/executor/nodeHashjoin.c
index 443fea6a50c..454b18e7868 100644
--- a/src/backend/executor/nodeHashjoin.c
+++ b/src/backend/executor/nodeHashjoin.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/executor/nodeHashjoin.c,v 1.55 2003/08/04 02:39:59 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/executor/nodeHashjoin.c,v 1.56 2003/08/08 21:41:42 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -22,7 +22,7 @@
 #include "utils/memutils.h"
 
 
-static TupleTableSlot *ExecHashJoinOuterGetTuple(PlanState * node,
+static TupleTableSlot *ExecHashJoinOuterGetTuple(PlanState *node,
 						  HashJoinState *hjstate);
 static TupleTableSlot *ExecHashJoinGetSavedTuple(HashJoinState *hjstate,
 						  BufFile *file,
@@ -499,7 +499,7 @@ ExecEndHashJoin(HashJoinState *node)
  */
 
 static TupleTableSlot *
-ExecHashJoinOuterGetTuple(PlanState * node, HashJoinState *hjstate)
+ExecHashJoinOuterGetTuple(PlanState *node, HashJoinState *hjstate)
 {
 	HashJoinTable hashtable = hjstate->hj_HashTable;
 	int			curbatch = hashtable->curbatch;
diff --git a/src/backend/executor/nodeMergejoin.c b/src/backend/executor/nodeMergejoin.c
index 3d3af66d0a5..0b383d24d1a 100644
--- a/src/backend/executor/nodeMergejoin.c
+++ b/src/backend/executor/nodeMergejoin.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/executor/nodeMergejoin.c,v 1.60 2003/08/04 02:39:59 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/executor/nodeMergejoin.c,v 1.61 2003/08/08 21:41:42 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -102,7 +102,7 @@ static bool MergeCompare(List *eqQual, List *compareQual, ExprContext *econtext)
  */
 static void
 MJFormSkipQuals(List *qualList, List **ltQuals, List **gtQuals,
-				PlanState * parent)
+				PlanState *parent)
 {
 	List	   *ltexprs,
 			   *gtexprs,
diff --git a/src/backend/executor/nodeSeqscan.c b/src/backend/executor/nodeSeqscan.c
index 20e1be245f8..21a5eee3428 100644
--- a/src/backend/executor/nodeSeqscan.c
+++ b/src/backend/executor/nodeSeqscan.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/executor/nodeSeqscan.c,v 1.45 2003/08/04 02:39:59 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/executor/nodeSeqscan.c,v 1.46 2003/08/08 21:41:42 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -29,8 +29,8 @@
 #include "executor/nodeSeqscan.h"
 #include "parser/parsetree.h"
 
-static void InitScanRelation(SeqScanState * node, EState *estate);
-static TupleTableSlot *SeqNext(SeqScanState * node);
+static void InitScanRelation(SeqScanState *node, EState *estate);
+static TupleTableSlot *SeqNext(SeqScanState *node);
 
 /* ----------------------------------------------------------------
  *						Scan Support
@@ -43,7 +43,7 @@ static TupleTableSlot *SeqNext(SeqScanState * node);
  * ----------------------------------------------------------------
  */
 static TupleTableSlot *
-SeqNext(SeqScanState * node)
+SeqNext(SeqScanState *node)
 {
 	HeapTuple	tuple;
 	HeapScanDesc scandesc;
@@ -123,7 +123,7 @@ SeqNext(SeqScanState * node)
  */
 
 TupleTableSlot *
-ExecSeqScan(SeqScanState * node)
+ExecSeqScan(SeqScanState *node)
 {
 	/*
 	 * use SeqNext as access method
@@ -139,7 +139,7 @@ ExecSeqScan(SeqScanState * node)
  * ----------------------------------------------------------------
  */
 static void
-InitScanRelation(SeqScanState * node, EState *estate)
+InitScanRelation(SeqScanState *node, EState *estate)
 {
 	Index		relid;
 	List	   *rangeTable;
@@ -252,7 +252,7 @@ ExecCountSlotsSeqScan(SeqScan *node)
  * ----------------------------------------------------------------
  */
 void
-ExecEndSeqScan(SeqScanState * node)
+ExecEndSeqScan(SeqScanState *node)
 {
 	Relation	relation;
 	HeapScanDesc scanDesc;
@@ -302,7 +302,7 @@ ExecEndSeqScan(SeqScanState * node)
  * ----------------------------------------------------------------
  */
 void
-ExecSeqReScan(SeqScanState * node, ExprContext *exprCtxt)
+ExecSeqReScan(SeqScanState *node, ExprContext *exprCtxt)
 {
 	EState	   *estate;
 	Index		scanrelid;
@@ -332,7 +332,7 @@ ExecSeqReScan(SeqScanState * node, ExprContext *exprCtxt)
  * ----------------------------------------------------------------
  */
 void
-ExecSeqMarkPos(SeqScanState * node)
+ExecSeqMarkPos(SeqScanState *node)
 {
 	HeapScanDesc scan;
 
@@ -347,7 +347,7 @@ ExecSeqMarkPos(SeqScanState * node)
  * ----------------------------------------------------------------
  */
 void
-ExecSeqRestrPos(SeqScanState * node)
+ExecSeqRestrPos(SeqScanState *node)
 {
 	HeapScanDesc scan;
 
diff --git a/src/backend/executor/nodeSubplan.c b/src/backend/executor/nodeSubplan.c
index a684dc83db9..7530be263f3 100644
--- a/src/backend/executor/nodeSubplan.c
+++ b/src/backend/executor/nodeSubplan.c
@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/executor/nodeSubplan.c,v 1.53 2003/08/04 02:39:59 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/executor/nodeSubplan.c,v 1.54 2003/08/08 21:41:42 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -29,13 +29,13 @@
 #include "utils/lsyscache.h"
 
 
-static Datum ExecHashSubPlan(SubPlanState * node,
+static Datum ExecHashSubPlan(SubPlanState *node,
 				ExprContext *econtext,
 				bool *isNull);
-static Datum ExecScanSubPlan(SubPlanState * node,
+static Datum ExecScanSubPlan(SubPlanState *node,
 				ExprContext *econtext,
 				bool *isNull);
-static void buildSubPlanHash(SubPlanState * node);
+static void buildSubPlanHash(SubPlanState *node);
 static bool findPartialMatch(TupleHashTable hashtable, TupleTableSlot *slot);
 static bool tupleAllNulls(HeapTuple tuple);
 
@@ -45,7 +45,7 @@ static bool tupleAllNulls(HeapTuple tuple);
  * ----------------------------------------------------------------
  */
 Datum
-ExecSubPlan(SubPlanState * node,
+ExecSubPlan(SubPlanState *node,
 			ExprContext *econtext,
 			bool *isNull)
 {
@@ -64,7 +64,7 @@ ExecSubPlan(SubPlanState * node,
  * ExecHashSubPlan: store subselect result in an in-memory hash table
  */
 static Datum
-ExecHashSubPlan(SubPlanState * node,
+ExecHashSubPlan(SubPlanState *node,
 				ExprContext *econtext,
 				bool *isNull)
 {
@@ -194,7 +194,7 @@ ExecHashSubPlan(SubPlanState * node,
  * ExecScanSubPlan: default case where we have to rescan subplan each time
  */
 static Datum
-ExecScanSubPlan(SubPlanState * node,
+ExecScanSubPlan(SubPlanState *node,
 				ExprContext *econtext,
 				bool *isNull)
 {
@@ -461,7 +461,7 @@ ExecScanSubPlan(SubPlanState * node,
  * buildSubPlanHash: load hash table by scanning subplan output.
  */
 static void
-buildSubPlanHash(SubPlanState * node)
+buildSubPlanHash(SubPlanState *node)
 {
 	SubPlan    *subplan = (SubPlan *) node->xprstate.expr;
 	PlanState  *planstate = node->planstate;
@@ -663,7 +663,7 @@ tupleAllNulls(HeapTuple tuple)
  * ----------------------------------------------------------------
  */
 void
-ExecInitSubPlan(SubPlanState * node, EState *estate)
+ExecInitSubPlan(SubPlanState *node, EState *estate)
 {
 	SubPlan    *subplan = (SubPlan *) node->xprstate.expr;
 	EState	   *sp_estate;
@@ -899,7 +899,7 @@ ExecInitSubPlan(SubPlanState * node, EState *estate)
  * ----------------------------------------------------------------
  */
 void
-ExecSetParamPlan(SubPlanState * node, ExprContext *econtext)
+ExecSetParamPlan(SubPlanState *node, ExprContext *econtext)
 {
 	SubPlan    *subplan = (SubPlan *) node->xprstate.expr;
 	PlanState  *planstate = node->planstate;
@@ -1041,7 +1041,7 @@ ExecSetParamPlan(SubPlanState * node, ExprContext *econtext)
  * ----------------------------------------------------------------
  */
 void
-ExecEndSubPlan(SubPlanState * node)
+ExecEndSubPlan(SubPlanState *node)
 {
 	if (node->needShutdown)
 	{
@@ -1061,7 +1061,7 @@ ExecEndSubPlan(SubPlanState * node)
  * Mark an initplan as needing recalculation
  */
 void
-ExecReScanSetParamPlan(SubPlanState * node, PlanState * parent)
+ExecReScanSetParamPlan(SubPlanState *node, PlanState *parent)
 {
 	PlanState  *planstate = node->planstate;
 	SubPlan    *subplan = (SubPlan *) node->xprstate.expr;
diff --git a/src/backend/executor/spi.c b/src/backend/executor/spi.c
index 985b966d5d1..44d2e1ab06d 100644
--- a/src/backend/executor/spi.c
+++ b/src/backend/executor/spi.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/executor/spi.c,v 1.102 2003/08/08 19:18:21 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/executor/spi.c,v 1.103 2003/08/08 21:41:42 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -1263,7 +1263,7 @@ static void
 _SPI_cursor_operation(Portal portal, bool forward, int count,
 					  DestReceiver *dest)
 {
-	long	nfetched;
+	long		nfetched;
 
 	/* Check that the portal is valid */
 	if (!PortalIsValid(portal))
@@ -1288,9 +1288,10 @@ _SPI_cursor_operation(Portal portal, bool forward, int count,
 	 * Think not to combine this store with the preceding function call.
 	 * If the portal contains calls to functions that use SPI, then
 	 * SPI_stack is likely to move around while the portal runs.  When
-	 * control returns, _SPI_current will point to the correct stack entry...
-	 * but the pointer may be different than it was beforehand.  So we must
-	 * be sure to re-fetch the pointer after the function call completes.
+	 * control returns, _SPI_current will point to the correct stack
+	 * entry... but the pointer may be different than it was beforehand.
+	 * So we must be sure to re-fetch the pointer after the function call
+	 * completes.
 	 */
 	_SPI_current->processed = nfetched;
 
diff --git a/src/backend/executor/tstoreReceiver.c b/src/backend/executor/tstoreReceiver.c
index aeda0d13d54..96be506a98b 100644
--- a/src/backend/executor/tstoreReceiver.c
+++ b/src/backend/executor/tstoreReceiver.c
@@ -9,7 +9,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/executor/tstoreReceiver.c,v 1.9 2003/08/06 17:46:45 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/executor/tstoreReceiver.c,v 1.10 2003/08/08 21:41:42 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -24,7 +24,7 @@ typedef struct
 	DestReceiver pub;
 	Tuplestorestate *tstore;
 	MemoryContext cxt;
-}	TStoreState;
+} TStoreState;
 
 
 /*
diff --git a/src/backend/nodes/bitmapset.c b/src/backend/nodes/bitmapset.c
index e444f449e19..5a981923e84 100644
--- a/src/backend/nodes/bitmapset.c
+++ b/src/backend/nodes/bitmapset.c
@@ -14,7 +14,7 @@
  * Copyright (c) 2003, PostgreSQL Global Development Group
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/nodes/bitmapset.c,v 1.4 2003/08/04 00:43:18 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/nodes/bitmapset.c,v 1.5 2003/08/08 21:41:43 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -107,7 +107,7 @@ static const uint8 number_of_ones[256] = {
  * bms_copy - make a palloc'd copy of a bitmapset
  */
 Bitmapset *
-bms_copy(const Bitmapset * a)
+bms_copy(const Bitmapset *a)
 {
 	Bitmapset  *result;
 	size_t		size;
@@ -127,7 +127,7 @@ bms_copy(const Bitmapset * a)
  * be reported as equal to a palloc'd value containing no members.
  */
 bool
-bms_equal(const Bitmapset * a, const Bitmapset * b)
+bms_equal(const Bitmapset *a, const Bitmapset *b)
 {
 	const Bitmapset *shorter;
 	const Bitmapset *longer;
@@ -197,7 +197,7 @@ bms_make_singleton(int x)
  * Same as pfree except for allowing NULL input
  */
 void
-bms_free(Bitmapset * a)
+bms_free(Bitmapset *a)
 {
 	if (a)
 		pfree(a);
@@ -214,7 +214,7 @@ bms_free(Bitmapset * a)
  * bms_union - set union
  */
 Bitmapset *
-bms_union(const Bitmapset * a, const Bitmapset * b)
+bms_union(const Bitmapset *a, const Bitmapset *b)
 {
 	Bitmapset  *result;
 	const Bitmapset *other;
@@ -248,7 +248,7 @@ bms_union(const Bitmapset * a, const Bitmapset * b)
  * bms_intersect - set intersection
  */
 Bitmapset *
-bms_intersect(const Bitmapset * a, const Bitmapset * b)
+bms_intersect(const Bitmapset *a, const Bitmapset *b)
 {
 	Bitmapset  *result;
 	const Bitmapset *other;
@@ -280,7 +280,7 @@ bms_intersect(const Bitmapset * a, const Bitmapset * b)
  * bms_difference - set difference (ie, A without members of B)
  */
 Bitmapset *
-bms_difference(const Bitmapset * a, const Bitmapset * b)
+bms_difference(const Bitmapset *a, const Bitmapset *b)
 {
 	Bitmapset  *result;
 	int			shortlen;
@@ -304,7 +304,7 @@ bms_difference(const Bitmapset * a, const Bitmapset * b)
  * bms_is_subset - is A a subset of B?
  */
 bool
-bms_is_subset(const Bitmapset * a, const Bitmapset * b)
+bms_is_subset(const Bitmapset *a, const Bitmapset *b)
 {
 	int			shortlen;
 	int			longlen;
@@ -339,7 +339,7 @@ bms_is_subset(const Bitmapset * a, const Bitmapset * b)
  * bms_is_member - is X a member of A?
  */
 bool
-bms_is_member(int x, const Bitmapset * a)
+bms_is_member(int x, const Bitmapset *a)
 {
 	int			wordnum,
 				bitnum;
@@ -362,7 +362,7 @@ bms_is_member(int x, const Bitmapset * a)
  * bms_overlap - do sets overlap (ie, have a nonempty intersection)?
  */
 bool
-bms_overlap(const Bitmapset * a, const Bitmapset * b)
+bms_overlap(const Bitmapset *a, const Bitmapset *b)
 {
 	int			shortlen;
 	int			i;
@@ -384,7 +384,7 @@ bms_overlap(const Bitmapset * a, const Bitmapset * b)
  * bms_nonempty_difference - do sets have a nonempty difference?
  */
 bool
-bms_nonempty_difference(const Bitmapset * a, const Bitmapset * b)
+bms_nonempty_difference(const Bitmapset *a, const Bitmapset *b)
 {
 	int			shortlen;
 	int			i;
@@ -416,7 +416,7 @@ bms_nonempty_difference(const Bitmapset * a, const Bitmapset * b)
  * Raises error if |a| is not 1.
  */
 int
-bms_singleton_member(const Bitmapset * a)
+bms_singleton_member(const Bitmapset *a)
 {
 	int			result = -1;
 	int			nwords;
@@ -451,7 +451,7 @@ bms_singleton_member(const Bitmapset * a)
  * bms_num_members - count members of set
  */
 int
-bms_num_members(const Bitmapset * a)
+bms_num_members(const Bitmapset *a)
 {
 	int			result = 0;
 	int			nwords;
@@ -480,7 +480,7 @@ bms_num_members(const Bitmapset * a)
  * This is faster than making an exact count with bms_num_members().
  */
 BMS_Membership
-bms_membership(const Bitmapset * a)
+bms_membership(const Bitmapset *a)
 {
 	BMS_Membership result = BMS_EMPTY_SET;
 	int			nwords;
@@ -509,7 +509,7 @@ bms_membership(const Bitmapset * a)
  * This is even faster than bms_membership().
  */
 bool
-bms_is_empty(const Bitmapset * a)
+bms_is_empty(const Bitmapset *a)
 {
 	int			nwords;
 	int			wordnum;
@@ -544,7 +544,7 @@ bms_is_empty(const Bitmapset * a)
  * Input set is modified or recycled!
  */
 Bitmapset *
-bms_add_member(Bitmapset * a, int x)
+bms_add_member(Bitmapset *a, int x)
 {
 	int			wordnum,
 				bitnum;
@@ -582,7 +582,7 @@ bms_add_member(Bitmapset * a, int x)
  * Input set is modified in-place!
  */
 Bitmapset *
-bms_del_member(Bitmapset * a, int x)
+bms_del_member(Bitmapset *a, int x)
 {
 	int			wordnum,
 				bitnum;
@@ -602,7 +602,7 @@ bms_del_member(Bitmapset * a, int x)
  * bms_add_members - like bms_union, but left input is recycled
  */
 Bitmapset *
-bms_add_members(Bitmapset * a, const Bitmapset * b)
+bms_add_members(Bitmapset *a, const Bitmapset *b)
 {
 	Bitmapset  *result;
 	const Bitmapset *other;
@@ -638,7 +638,7 @@ bms_add_members(Bitmapset * a, const Bitmapset * b)
  * bms_int_members - like bms_intersect, but left input is recycled
  */
 Bitmapset *
-bms_int_members(Bitmapset * a, const Bitmapset * b)
+bms_int_members(Bitmapset *a, const Bitmapset *b)
 {
 	int			shortlen;
 	int			i;
@@ -664,7 +664,7 @@ bms_int_members(Bitmapset * a, const Bitmapset * b)
  * bms_del_members - like bms_difference, but left input is recycled
  */
 Bitmapset *
-bms_del_members(Bitmapset * a, const Bitmapset * b)
+bms_del_members(Bitmapset *a, const Bitmapset *b)
 {
 	int			shortlen;
 	int			i;
@@ -685,7 +685,7 @@ bms_del_members(Bitmapset * a, const Bitmapset * b)
  * bms_join - like bms_union, but *both* inputs are recycled
  */
 Bitmapset *
-bms_join(Bitmapset * a, Bitmapset * b)
+bms_join(Bitmapset *a, Bitmapset *b)
 {
 	Bitmapset  *result;
 	Bitmapset  *other;
@@ -732,7 +732,7 @@ bms_join(Bitmapset * a, Bitmapset * b)
  *----------
  */
 int
-bms_first_member(Bitmapset * a)
+bms_first_member(Bitmapset *a)
 {
 	int			nwords;
 	int			wordnum;
diff --git a/src/backend/nodes/copyfuncs.c b/src/backend/nodes/copyfuncs.c
index 9090217418d..fa1c567df0d 100644
--- a/src/backend/nodes/copyfuncs.c
+++ b/src/backend/nodes/copyfuncs.c
@@ -15,7 +15,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.262 2003/08/04 02:39:59 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.263 2003/08/08 21:41:43 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -755,7 +755,7 @@ _copyArrayRef(ArrayRef *from)
  * _copyFuncExpr
  */
 static FuncExpr *
-_copyFuncExpr(FuncExpr * from)
+_copyFuncExpr(FuncExpr *from)
 {
 	FuncExpr   *newnode = makeNode(FuncExpr);
 
@@ -772,7 +772,7 @@ _copyFuncExpr(FuncExpr * from)
  * _copyOpExpr
  */
 static OpExpr *
-_copyOpExpr(OpExpr * from)
+_copyOpExpr(OpExpr *from)
 {
 	OpExpr	   *newnode = makeNode(OpExpr);
 
@@ -789,7 +789,7 @@ _copyOpExpr(OpExpr * from)
  * _copyDistinctExpr (same as OpExpr)
  */
 static DistinctExpr *
-_copyDistinctExpr(DistinctExpr * from)
+_copyDistinctExpr(DistinctExpr *from)
 {
 	DistinctExpr *newnode = makeNode(DistinctExpr);
 
@@ -806,7 +806,7 @@ _copyDistinctExpr(DistinctExpr * from)
  * _copyScalarArrayOpExpr
  */
 static ScalarArrayOpExpr *
-_copyScalarArrayOpExpr(ScalarArrayOpExpr * from)
+_copyScalarArrayOpExpr(ScalarArrayOpExpr *from)
 {
 	ScalarArrayOpExpr *newnode = makeNode(ScalarArrayOpExpr);
 
@@ -822,7 +822,7 @@ _copyScalarArrayOpExpr(ScalarArrayOpExpr * from)
  * _copyBoolExpr
  */
 static BoolExpr *
-_copyBoolExpr(BoolExpr * from)
+_copyBoolExpr(BoolExpr *from)
 {
 	BoolExpr   *newnode = makeNode(BoolExpr);
 
@@ -940,7 +940,7 @@ _copyCaseWhen(CaseWhen *from)
  * _copyArrayExpr
  */
 static ArrayExpr *
-_copyArrayExpr(ArrayExpr * from)
+_copyArrayExpr(ArrayExpr *from)
 {
 	ArrayExpr  *newnode = makeNode(ArrayExpr);
 
@@ -956,7 +956,7 @@ _copyArrayExpr(ArrayExpr * from)
  * _copyCoalesceExpr
  */
 static CoalesceExpr *
-_copyCoalesceExpr(CoalesceExpr * from)
+_copyCoalesceExpr(CoalesceExpr *from)
 {
 	CoalesceExpr *newnode = makeNode(CoalesceExpr);
 
@@ -970,7 +970,7 @@ _copyCoalesceExpr(CoalesceExpr * from)
  * _copyNullIfExpr (same as OpExpr)
  */
 static NullIfExpr *
-_copyNullIfExpr(NullIfExpr * from)
+_copyNullIfExpr(NullIfExpr *from)
 {
 	NullIfExpr *newnode = makeNode(NullIfExpr);
 
@@ -1015,7 +1015,7 @@ _copyBooleanTest(BooleanTest *from)
  * _copyCoerceToDomain
  */
 static CoerceToDomain *
-_copyCoerceToDomain(CoerceToDomain * from)
+_copyCoerceToDomain(CoerceToDomain *from)
 {
 	CoerceToDomain *newnode = makeNode(CoerceToDomain);
 
@@ -1031,7 +1031,7 @@ _copyCoerceToDomain(CoerceToDomain * from)
  * _copyCoerceToDomainValue
  */
 static CoerceToDomainValue *
-_copyCoerceToDomainValue(CoerceToDomainValue * from)
+_copyCoerceToDomainValue(CoerceToDomainValue *from)
 {
 	CoerceToDomainValue *newnode = makeNode(CoerceToDomainValue);
 
@@ -1045,7 +1045,7 @@ _copyCoerceToDomainValue(CoerceToDomainValue * from)
  * _copySetToDefault
  */
 static SetToDefault *
-_copySetToDefault(SetToDefault * from)
+_copySetToDefault(SetToDefault *from)
 {
 	SetToDefault *newnode = makeNode(SetToDefault);
 
@@ -1191,7 +1191,7 @@ _copyJoinInfo(JoinInfo *from)
  * _copyInClauseInfo
  */
 static InClauseInfo *
-_copyInClauseInfo(InClauseInfo * from)
+_copyInClauseInfo(InClauseInfo *from)
 {
 	InClauseInfo *newnode = makeNode(InClauseInfo);
 
@@ -1633,7 +1633,7 @@ _copyAlterTableStmt(AlterTableStmt *from)
 }
 
 static AlterDomainStmt *
-_copyAlterDomainStmt(AlterDomainStmt * from)
+_copyAlterDomainStmt(AlterDomainStmt *from)
 {
 	AlterDomainStmt *newnode = makeNode(AlterDomainStmt);
 
@@ -1685,7 +1685,7 @@ _copyFuncWithArgs(FuncWithArgs *from)
 }
 
 static DeclareCursorStmt *
-_copyDeclareCursorStmt(DeclareCursorStmt * from)
+_copyDeclareCursorStmt(DeclareCursorStmt *from)
 {
 	DeclareCursorStmt *newnode = makeNode(DeclareCursorStmt);
 
@@ -1747,7 +1747,7 @@ _copyCreateStmt(CreateStmt *from)
 }
 
 static InhRelation *
-_copyInhRelation(InhRelation * from)
+_copyInhRelation(InhRelation *from)
 {
 	InhRelation *newnode = makeNode(InhRelation);
 
@@ -2118,7 +2118,7 @@ _copyCreateSeqStmt(CreateSeqStmt *from)
 }
 
 static AlterSeqStmt *
-_copyAlterSeqStmt(AlterSeqStmt * from)
+_copyAlterSeqStmt(AlterSeqStmt *from)
 {
 	AlterSeqStmt *newnode = makeNode(AlterSeqStmt);
 
diff --git a/src/backend/nodes/equalfuncs.c b/src/backend/nodes/equalfuncs.c
index a6b4889f74e..5ad5dab1d3c 100644
--- a/src/backend/nodes/equalfuncs.c
+++ b/src/backend/nodes/equalfuncs.c
@@ -18,7 +18,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.206 2003/08/04 02:39:59 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.207 2003/08/08 21:41:43 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -224,7 +224,7 @@ _equalArrayRef(ArrayRef *a, ArrayRef *b)
 }
 
 static bool
-_equalFuncExpr(FuncExpr * a, FuncExpr * b)
+_equalFuncExpr(FuncExpr *a, FuncExpr *b)
 {
 	COMPARE_SCALAR_FIELD(funcid);
 	COMPARE_SCALAR_FIELD(funcresulttype);
@@ -245,7 +245,7 @@ _equalFuncExpr(FuncExpr * a, FuncExpr * b)
 }
 
 static bool
-_equalOpExpr(OpExpr * a, OpExpr * b)
+_equalOpExpr(OpExpr *a, OpExpr *b)
 {
 	COMPARE_SCALAR_FIELD(opno);
 
@@ -268,7 +268,7 @@ _equalOpExpr(OpExpr * a, OpExpr * b)
 }
 
 static bool
-_equalDistinctExpr(DistinctExpr * a, DistinctExpr * b)
+_equalDistinctExpr(DistinctExpr *a, DistinctExpr *b)
 {
 	COMPARE_SCALAR_FIELD(opno);
 
@@ -291,7 +291,7 @@ _equalDistinctExpr(DistinctExpr * a, DistinctExpr * b)
 }
 
 static bool
-_equalScalarArrayOpExpr(ScalarArrayOpExpr * a, ScalarArrayOpExpr * b)
+_equalScalarArrayOpExpr(ScalarArrayOpExpr *a, ScalarArrayOpExpr *b)
 {
 	COMPARE_SCALAR_FIELD(opno);
 
@@ -313,7 +313,7 @@ _equalScalarArrayOpExpr(ScalarArrayOpExpr * a, ScalarArrayOpExpr * b)
 }
 
 static bool
-_equalBoolExpr(BoolExpr * a, BoolExpr * b)
+_equalBoolExpr(BoolExpr *a, BoolExpr *b)
 {
 	COMPARE_SCALAR_FIELD(boolop);
 	COMPARE_NODE_FIELD(args);
@@ -404,7 +404,7 @@ _equalCaseWhen(CaseWhen *a, CaseWhen *b)
 }
 
 static bool
-_equalArrayExpr(ArrayExpr * a, ArrayExpr * b)
+_equalArrayExpr(ArrayExpr *a, ArrayExpr *b)
 {
 	COMPARE_SCALAR_FIELD(array_typeid);
 	COMPARE_SCALAR_FIELD(element_typeid);
@@ -415,7 +415,7 @@ _equalArrayExpr(ArrayExpr * a, ArrayExpr * b)
 }
 
 static bool
-_equalCoalesceExpr(CoalesceExpr * a, CoalesceExpr * b)
+_equalCoalesceExpr(CoalesceExpr *a, CoalesceExpr *b)
 {
 	COMPARE_SCALAR_FIELD(coalescetype);
 	COMPARE_NODE_FIELD(args);
@@ -424,7 +424,7 @@ _equalCoalesceExpr(CoalesceExpr * a, CoalesceExpr * b)
 }
 
 static bool
-_equalNullIfExpr(NullIfExpr * a, NullIfExpr * b)
+_equalNullIfExpr(NullIfExpr *a, NullIfExpr *b)
 {
 	COMPARE_SCALAR_FIELD(opno);
 
@@ -465,7 +465,7 @@ _equalBooleanTest(BooleanTest *a, BooleanTest *b)
 }
 
 static bool
-_equalCoerceToDomain(CoerceToDomain * a, CoerceToDomain * b)
+_equalCoerceToDomain(CoerceToDomain *a, CoerceToDomain *b)
 {
 	COMPARE_NODE_FIELD(arg);
 	COMPARE_SCALAR_FIELD(resulttype);
@@ -484,7 +484,7 @@ _equalCoerceToDomain(CoerceToDomain * a, CoerceToDomain * b)
 }
 
 static bool
-_equalCoerceToDomainValue(CoerceToDomainValue * a, CoerceToDomainValue * b)
+_equalCoerceToDomainValue(CoerceToDomainValue *a, CoerceToDomainValue *b)
 {
 	COMPARE_SCALAR_FIELD(typeId);
 	COMPARE_SCALAR_FIELD(typeMod);
@@ -493,7 +493,7 @@ _equalCoerceToDomainValue(CoerceToDomainValue * a, CoerceToDomainValue * b)
 }
 
 static bool
-_equalSetToDefault(SetToDefault * a, SetToDefault * b)
+_equalSetToDefault(SetToDefault *a, SetToDefault *b)
 {
 	COMPARE_SCALAR_FIELD(typeId);
 	COMPARE_SCALAR_FIELD(typeMod);
@@ -587,7 +587,7 @@ _equalJoinInfo(JoinInfo *a, JoinInfo *b)
 }
 
 static bool
-_equalInClauseInfo(InClauseInfo * a, InClauseInfo * b)
+_equalInClauseInfo(InClauseInfo *a, InClauseInfo *b)
 {
 	COMPARE_BITMAPSET_FIELD(lefthand);
 	COMPARE_BITMAPSET_FIELD(righthand);
@@ -715,7 +715,7 @@ _equalAlterTableStmt(AlterTableStmt *a, AlterTableStmt *b)
 }
 
 static bool
-_equalAlterDomainStmt(AlterDomainStmt * a, AlterDomainStmt * b)
+_equalAlterDomainStmt(AlterDomainStmt *a, AlterDomainStmt *b)
 {
 	COMPARE_SCALAR_FIELD(subtype);
 	COMPARE_NODE_FIELD(typename);
@@ -759,7 +759,7 @@ _equalFuncWithArgs(FuncWithArgs *a, FuncWithArgs *b)
 }
 
 static bool
-_equalDeclareCursorStmt(DeclareCursorStmt * a, DeclareCursorStmt * b)
+_equalDeclareCursorStmt(DeclareCursorStmt *a, DeclareCursorStmt *b)
 {
 	COMPARE_STRING_FIELD(portalname);
 	COMPARE_SCALAR_FIELD(options);
@@ -811,7 +811,7 @@ _equalCreateStmt(CreateStmt *a, CreateStmt *b)
 }
 
 static bool
-_equalInhRelation(InhRelation * a, InhRelation * b)
+_equalInhRelation(InhRelation *a, InhRelation *b)
 {
 	COMPARE_NODE_FIELD(relation);
 	COMPARE_SCALAR_FIELD(including_defaults);
@@ -1122,7 +1122,7 @@ _equalCreateSeqStmt(CreateSeqStmt *a, CreateSeqStmt *b)
 }
 
 static bool
-_equalAlterSeqStmt(AlterSeqStmt * a, AlterSeqStmt * b)
+_equalAlterSeqStmt(AlterSeqStmt *a, AlterSeqStmt *b)
 {
 	COMPARE_NODE_FIELD(sequence);
 	COMPARE_NODE_FIELD(options);
diff --git a/src/backend/nodes/list.c b/src/backend/nodes/list.c
index 72b1ec893c9..dd6d29e6960 100644
--- a/src/backend/nodes/list.c
+++ b/src/backend/nodes/list.c
@@ -9,7 +9,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/nodes/list.c,v 1.53 2003/08/04 02:39:59 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/nodes/list.c,v 1.54 2003/08/08 21:41:44 momjian Exp $
  *
  * NOTES
  *	  XXX a few of the following functions are duplicated to handle
@@ -202,7 +202,7 @@ nconc(List *l1, List *l2)
  * since we avoid having to chase down the list again each time.
  */
 void
-FastAppend(FastList * fl, void *datum)
+FastAppend(FastList *fl, void *datum)
 {
 	List	   *cell = makeList1(datum);
 
@@ -223,7 +223,7 @@ FastAppend(FastList * fl, void *datum)
  * FastAppendi - same for integers
  */
 void
-FastAppendi(FastList * fl, int datum)
+FastAppendi(FastList *fl, int datum)
 {
 	List	   *cell = makeListi1(datum);
 
@@ -244,7 +244,7 @@ FastAppendi(FastList * fl, int datum)
  * FastAppendo - same for Oids
  */
 void
-FastAppendo(FastList * fl, Oid datum)
+FastAppendo(FastList *fl, Oid datum)
 {
 	List	   *cell = makeListo1(datum);
 
@@ -267,7 +267,7 @@ FastAppendo(FastList * fl, Oid datum)
  * Note that the cells of the second argument are absorbed into the FastList.
  */
 void
-FastConc(FastList * fl, List *cells)
+FastConc(FastList *fl, List *cells)
 {
 	if (cells == NIL)
 		return;					/* nothing to do */
@@ -290,7 +290,7 @@ FastConc(FastList * fl, List *cells)
  * Note that the cells of the second argument are absorbed into the first.
  */
 void
-FastConcFast(FastList * fl, FastList * fl2)
+FastConcFast(FastList *fl, FastList *fl2)
 {
 	if (fl2->head == NIL)
 		return;					/* nothing to do */
diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index 1ac0c357c82..b7c1a370695 100644
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.216 2003/08/04 02:39:59 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.217 2003/08/08 21:41:44 momjian Exp $
  *
  * NOTES
  *	  Every node type that can appear in stored rules' parsetrees *must*
@@ -184,7 +184,7 @@ _outOidList(StringInfo str, List *list)
  * an integer List would be.
  */
 static void
-_outBitmapset(StringInfo str, Bitmapset * bms)
+_outBitmapset(StringInfo str, Bitmapset *bms)
 {
 	Bitmapset  *tmpset;
 	int			x;
@@ -631,7 +631,7 @@ _outArrayRef(StringInfo str, ArrayRef *node)
 }
 
 static void
-_outFuncExpr(StringInfo str, FuncExpr * node)
+_outFuncExpr(StringInfo str, FuncExpr *node)
 {
 	WRITE_NODE_TYPE("FUNCEXPR");
 
@@ -643,7 +643,7 @@ _outFuncExpr(StringInfo str, FuncExpr * node)
 }
 
 static void
-_outOpExpr(StringInfo str, OpExpr * node)
+_outOpExpr(StringInfo str, OpExpr *node)
 {
 	WRITE_NODE_TYPE("OPEXPR");
 
@@ -655,7 +655,7 @@ _outOpExpr(StringInfo str, OpExpr * node)
 }
 
 static void
-_outDistinctExpr(StringInfo str, DistinctExpr * node)
+_outDistinctExpr(StringInfo str, DistinctExpr *node)
 {
 	WRITE_NODE_TYPE("DISTINCTEXPR");
 
@@ -667,7 +667,7 @@ _outDistinctExpr(StringInfo str, DistinctExpr * node)
 }
 
 static void
-_outScalarArrayOpExpr(StringInfo str, ScalarArrayOpExpr * node)
+_outScalarArrayOpExpr(StringInfo str, ScalarArrayOpExpr *node)
 {
 	WRITE_NODE_TYPE("SCALARARRAYOPEXPR");
 
@@ -678,7 +678,7 @@ _outScalarArrayOpExpr(StringInfo str, ScalarArrayOpExpr * node)
 }
 
 static void
-_outBoolExpr(StringInfo str, BoolExpr * node)
+_outBoolExpr(StringInfo str, BoolExpr *node)
 {
 	char	   *opstr = NULL;
 
@@ -778,7 +778,7 @@ _outCaseWhen(StringInfo str, CaseWhen *node)
 }
 
 static void
-_outArrayExpr(StringInfo str, ArrayExpr * node)
+_outArrayExpr(StringInfo str, ArrayExpr *node)
 {
 	WRITE_NODE_TYPE("ARRAY");
 
@@ -789,7 +789,7 @@ _outArrayExpr(StringInfo str, ArrayExpr * node)
 }
 
 static void
-_outCoalesceExpr(StringInfo str, CoalesceExpr * node)
+_outCoalesceExpr(StringInfo str, CoalesceExpr *node)
 {
 	WRITE_NODE_TYPE("COALESCE");
 
@@ -798,7 +798,7 @@ _outCoalesceExpr(StringInfo str, CoalesceExpr * node)
 }
 
 static void
-_outNullIfExpr(StringInfo str, NullIfExpr * node)
+_outNullIfExpr(StringInfo str, NullIfExpr *node)
 {
 	WRITE_NODE_TYPE("NULLIFEXPR");
 
@@ -828,7 +828,7 @@ _outBooleanTest(StringInfo str, BooleanTest *node)
 }
 
 static void
-_outCoerceToDomain(StringInfo str, CoerceToDomain * node)
+_outCoerceToDomain(StringInfo str, CoerceToDomain *node)
 {
 	WRITE_NODE_TYPE("COERCETODOMAIN");
 
@@ -839,7 +839,7 @@ _outCoerceToDomain(StringInfo str, CoerceToDomain * node)
 }
 
 static void
-_outCoerceToDomainValue(StringInfo str, CoerceToDomainValue * node)
+_outCoerceToDomainValue(StringInfo str, CoerceToDomainValue *node)
 {
 	WRITE_NODE_TYPE("COERCETODOMAINVALUE");
 
@@ -848,7 +848,7 @@ _outCoerceToDomainValue(StringInfo str, CoerceToDomainValue * node)
 }
 
 static void
-_outSetToDefault(StringInfo str, SetToDefault * node)
+_outSetToDefault(StringInfo str, SetToDefault *node)
 {
 	WRITE_NODE_TYPE("SETTODEFAULT");
 
@@ -977,7 +977,7 @@ _outAppendPath(StringInfo str, AppendPath *node)
 }
 
 static void
-_outResultPath(StringInfo str, ResultPath * node)
+_outResultPath(StringInfo str, ResultPath *node)
 {
 	WRITE_NODE_TYPE("RESULTPATH");
 
@@ -988,7 +988,7 @@ _outResultPath(StringInfo str, ResultPath * node)
 }
 
 static void
-_outMaterialPath(StringInfo str, MaterialPath * node)
+_outMaterialPath(StringInfo str, MaterialPath *node)
 {
 	WRITE_NODE_TYPE("MATERIALPATH");
 
@@ -998,7 +998,7 @@ _outMaterialPath(StringInfo str, MaterialPath * node)
 }
 
 static void
-_outUniquePath(StringInfo str, UniquePath * node)
+_outUniquePath(StringInfo str, UniquePath *node)
 {
 	WRITE_NODE_TYPE("UNIQUEPATH");
 
@@ -1077,7 +1077,7 @@ _outJoinInfo(StringInfo str, JoinInfo *node)
 }
 
 static void
-_outInClauseInfo(StringInfo str, InClauseInfo * node)
+_outInClauseInfo(StringInfo str, InClauseInfo *node)
 {
 	WRITE_NODE_TYPE("INCLAUSEINFO");
 
@@ -1130,7 +1130,7 @@ _outNotifyStmt(StringInfo str, NotifyStmt *node)
 }
 
 static void
-_outDeclareCursorStmt(StringInfo str, DeclareCursorStmt * node)
+_outDeclareCursorStmt(StringInfo str, DeclareCursorStmt *node)
 {
 	WRITE_NODE_TYPE("DECLARECURSOR");
 
diff --git a/src/backend/optimizer/path/costsize.c b/src/backend/optimizer/path/costsize.c
index 7e34d7fea50..6b0179c8539 100644
--- a/src/backend/optimizer/path/costsize.c
+++ b/src/backend/optimizer/path/costsize.c
@@ -49,7 +49,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/optimizer/path/costsize.c,v 1.113 2003/08/04 02:40:00 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/optimizer/path/costsize.c,v 1.114 2003/08/08 21:41:44 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -103,7 +103,7 @@ bool		enable_hashjoin = true;
 
 static Selectivity estimate_hash_bucketsize(Query *root, Var *var,
 						 int nbuckets);
-static bool cost_qual_eval_walker(Node *node, QualCost * total);
+static bool cost_qual_eval_walker(Node *node, QualCost *total);
 static Selectivity approx_selectivity(Query *root, List *quals,
 				   JoinType jointype);
 static void set_rel_width(Query *root, RelOptInfo *rel);
@@ -1449,7 +1449,7 @@ estimate_hash_bucketsize(Query *root, Var *var, int nbuckets)
  *		and a per-evaluation component.
  */
 void
-cost_qual_eval(QualCost * cost, List *quals)
+cost_qual_eval(QualCost *cost, List *quals)
 {
 	List	   *l;
 
@@ -1491,7 +1491,7 @@ cost_qual_eval(QualCost * cost, List *quals)
 }
 
 static bool
-cost_qual_eval_walker(Node *node, QualCost * total)
+cost_qual_eval_walker(Node *node, QualCost *total)
 {
 	if (node == NULL)
 		return false;
diff --git a/src/backend/optimizer/path/tidpath.c b/src/backend/optimizer/path/tidpath.c
index cd999825e64..f1b42b1c6be 100644
--- a/src/backend/optimizer/path/tidpath.c
+++ b/src/backend/optimizer/path/tidpath.c
@@ -9,7 +9,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/optimizer/path/tidpath.c,v 1.16 2003/08/04 02:40:00 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/optimizer/path/tidpath.c,v 1.17 2003/08/08 21:41:47 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -27,7 +27,7 @@
 
 static List *TidqualFromRestrictinfo(Relids relids, List *restrictinfo);
 static bool isEvaluable(int varno, Node *node);
-static Node *TidequalClause(int varno, OpExpr * node);
+static Node *TidequalClause(int varno, OpExpr *node);
 static List *TidqualFromExpr(int varno, Expr *expr);
 
 static bool
@@ -66,7 +66,7 @@ isEvaluable(int varno, Node *node)
  *	  or	the left  node if the opclause is ....=CTID
  */
 static Node *
-TidequalClause(int varno, OpExpr * node)
+TidequalClause(int varno, OpExpr *node)
 {
 	Node	   *rnode = NULL,
 			   *arg1,
diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c
index c77f7d40539..8abcfc576c1 100644
--- a/src/backend/optimizer/plan/createplan.c
+++ b/src/backend/optimizer/plan/createplan.c
@@ -10,7 +10,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.152 2003/08/07 19:20:22 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.153 2003/08/08 21:41:48 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -40,9 +40,9 @@ static bool use_physical_tlist(RelOptInfo *rel);
 static void disuse_physical_tlist(Plan *plan, Path *path);
 static Join *create_join_plan(Query *root, JoinPath *best_path);
 static Append *create_append_plan(Query *root, AppendPath *best_path);
-static Result *create_result_plan(Query *root, ResultPath * best_path);
-static Material *create_material_plan(Query *root, MaterialPath * best_path);
-static Plan *create_unique_plan(Query *root, UniquePath * best_path);
+static Result *create_result_plan(Query *root, ResultPath *best_path);
+static Material *create_material_plan(Query *root, MaterialPath *best_path);
+static Plan *create_unique_plan(Query *root, UniquePath *best_path);
 static SeqScan *create_seqscan_plan(Path *best_path, List *tlist,
 					List *scan_clauses);
 static IndexScan *create_indexscan_plan(Query *root, IndexPath *best_path,
@@ -443,7 +443,7 @@ create_append_plan(Query *root, AppendPath *best_path)
  *	  Returns a Plan node.
  */
 static Result *
-create_result_plan(Query *root, ResultPath * best_path)
+create_result_plan(Query *root, ResultPath *best_path)
 {
 	Result	   *plan;
 	List	   *tlist;
@@ -475,7 +475,7 @@ create_result_plan(Query *root, ResultPath * best_path)
  *	  Returns a Plan node.
  */
 static Material *
-create_material_plan(Query *root, MaterialPath * best_path)
+create_material_plan(Query *root, MaterialPath *best_path)
 {
 	Material   *plan;
 	Plan	   *subplan;
@@ -500,7 +500,7 @@ create_material_plan(Query *root, MaterialPath * best_path)
  *	  Returns a Plan node.
  */
 static Plan *
-create_unique_plan(Query *root, UniquePath * best_path)
+create_unique_plan(Query *root, UniquePath *best_path)
 {
 	Plan	   *plan;
 	Plan	   *subplan;
@@ -522,17 +522,18 @@ create_unique_plan(Query *root, UniquePath * best_path)
 	 * to unique-ify may be expressions in these variables.  We have to
 	 * add any such expressions to the subplan's tlist.  We then build
 	 * control information showing which subplan output columns are to be
-	 * examined by the grouping step.  (Since we do not remove any existing
-	 * subplan outputs, not all the output columns may be used for grouping.)
+	 * examined by the grouping step.  (Since we do not remove any
+	 * existing subplan outputs, not all the output columns may be used
+	 * for grouping.)
 	 *
-	 * Note: the reason we don't remove any subplan outputs is that there
-	 * are scenarios where a Var is needed at higher levels even though it
-	 * is not one of the nominal outputs of an IN clause.  Consider
-	 *		WHERE x IN (SELECT y FROM t1,t2 WHERE y = z)
-	 * Implied equality deduction will generate an "x = z" clause, which may
-	 * get used instead of "x = y" in the upper join step.  Therefore the
-	 * sub-select had better deliver both y and z in its targetlist.  It is
-	 * sufficient to unique-ify on y, however.
+	 * Note: the reason we don't remove any subplan outputs is that there are
+	 * scenarios where a Var is needed at higher levels even though it is
+	 * not one of the nominal outputs of an IN clause.	Consider WHERE x
+	 * IN (SELECT y FROM t1,t2 WHERE y = z) Implied equality deduction
+	 * will generate an "x = z" clause, which may get used instead of "x =
+	 * y" in the upper join step.  Therefore the sub-select had better
+	 * deliver both y and z in its targetlist.	It is sufficient to
+	 * unique-ify on y, however.
 	 *
 	 * To find the correct list of values to unique-ify, we look in the
 	 * information saved for IN expressions.  If this code is ever used in
@@ -1208,7 +1209,7 @@ fix_indxqual_sublist(List *indexqual,
 		Relids		leftvarnos;
 		Oid			opclass;
 
-		if (!IsA(clause, OpExpr) || length(clause->args) != 2)
+		if (!IsA(clause, OpExpr) ||length(clause->args) != 2)
 			elog(ERROR, "indexqual clause is not binary opclause");
 
 		/*
diff --git a/src/backend/optimizer/plan/setrefs.c b/src/backend/optimizer/plan/setrefs.c
index 33cf0cb90ac..ec21c1a8d3b 100644
--- a/src/backend/optimizer/plan/setrefs.c
+++ b/src/backend/optimizer/plan/setrefs.c
@@ -9,7 +9,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/optimizer/plan/setrefs.c,v 1.96 2003/08/04 02:40:01 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/optimizer/plan/setrefs.c,v 1.97 2003/08/08 21:41:50 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -60,7 +60,7 @@ static Node *replace_vars_with_subplan_refs(Node *node,
 static Node *replace_vars_with_subplan_refs_mutator(Node *node,
 						replace_vars_with_subplan_refs_context *context);
 static bool fix_opfuncids_walker(Node *node, void *context);
-static void set_sa_opfuncid(ScalarArrayOpExpr * opexpr);
+static void set_sa_opfuncid(ScalarArrayOpExpr *opexpr);
 
 
 /*****************************************************************************
@@ -759,7 +759,7 @@ fix_opfuncids_walker(Node *node, void *context)
  * DistinctExpr and NullIfExpr nodes.
  */
 void
-set_opfuncid(OpExpr * opexpr)
+set_opfuncid(OpExpr *opexpr)
 {
 	if (opexpr->opfuncid == InvalidOid)
 		opexpr->opfuncid = get_opcode(opexpr->opno);
@@ -770,7 +770,7 @@ set_opfuncid(OpExpr * opexpr)
  *		As above, for ScalarArrayOpExpr nodes.
  */
 static void
-set_sa_opfuncid(ScalarArrayOpExpr * opexpr)
+set_sa_opfuncid(ScalarArrayOpExpr *opexpr)
 {
 	if (opexpr->opfuncid == InvalidOid)
 		opexpr->opfuncid = get_opcode(opexpr->opno);
diff --git a/src/backend/optimizer/plan/subselect.c b/src/backend/optimizer/plan/subselect.c
index 2c8ef0630c8..d7d25c09f80 100644
--- a/src/backend/optimizer/plan/subselect.c
+++ b/src/backend/optimizer/plan/subselect.c
@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/optimizer/plan/subselect.c,v 1.81 2003/08/04 02:40:01 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/optimizer/plan/subselect.c,v 1.82 2003/08/08 21:41:51 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -71,14 +71,14 @@ typedef struct PlannerParamItem
 {
 	Node	   *item;			/* the Var, Aggref, or Param */
 	Index		abslevel;		/* its absolute query level */
-}	PlannerParamItem;
+} PlannerParamItem;
 
 
 typedef struct finalize_primnode_context
 {
 	Bitmapset  *paramids;		/* Set of PARAM_EXEC paramids found */
 	Bitmapset  *outer_params;	/* Set of accessible outer paramids */
-}	finalize_primnode_context;
+} finalize_primnode_context;
 
 
 static List *convert_sublink_opers(List *lefthand, List *operOids,
@@ -88,9 +88,9 @@ static bool subplan_is_hashable(SubLink *slink, SubPlan *node);
 static Node *replace_correlation_vars_mutator(Node *node, void *context);
 static Node *process_sublinks_mutator(Node *node, bool *isTopQual);
 static Bitmapset *finalize_plan(Plan *plan, List *rtable,
-			  Bitmapset * outer_params,
-			  Bitmapset * valid_params);
-static bool finalize_primnode(Node *node, finalize_primnode_context * context);
+			  Bitmapset *outer_params,
+			  Bitmapset *valid_params);
+static bool finalize_primnode(Node *node, finalize_primnode_context *context);
 
 
 /*
@@ -909,7 +909,7 @@ SS_finalize_plan(Plan *plan, List *rtable)
  */
 static Bitmapset *
 finalize_plan(Plan *plan, List *rtable,
-			  Bitmapset * outer_params, Bitmapset * valid_params)
+			  Bitmapset *outer_params, Bitmapset *valid_params)
 {
 	finalize_primnode_context context;
 	List	   *lst;
@@ -1073,7 +1073,7 @@ finalize_plan(Plan *plan, List *rtable,
  * expression tree to the result set.
  */
 static bool
-finalize_primnode(Node *node, finalize_primnode_context * context)
+finalize_primnode(Node *node, finalize_primnode_context *context)
 {
 	if (node == NULL)
 		return false;
diff --git a/src/backend/optimizer/prep/prepjointree.c b/src/backend/optimizer/prep/prepjointree.c
index 875c8aac299..615d6af7e9f 100644
--- a/src/backend/optimizer/prep/prepjointree.c
+++ b/src/backend/optimizer/prep/prepjointree.c
@@ -16,7 +16,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/optimizer/prep/prepjointree.c,v 1.10 2003/08/04 02:40:01 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/optimizer/prep/prepjointree.c,v 1.11 2003/08/08 21:41:52 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -41,14 +41,14 @@ typedef struct reduce_outer_joins_state
 	Relids		relids;			/* base relids within this subtree */
 	bool		contains_outer; /* does subtree contain outer join(s)? */
 	List	   *sub_states;		/* List of states for subtree components */
-}	reduce_outer_joins_state;
+} reduce_outer_joins_state;
 
 static bool is_simple_subquery(Query *subquery);
 static bool has_nullable_targetlist(Query *subquery);
 static void resolvenew_in_jointree(Node *jtnode, int varno, List *subtlist);
 static reduce_outer_joins_state *reduce_outer_joins_pass1(Node *jtnode);
 static void reduce_outer_joins_pass2(Node *jtnode,
-						 reduce_outer_joins_state * state,
+						 reduce_outer_joins_state *state,
 						 Query *parse,
 						 Relids nonnullable_rels);
 static Relids find_nonnullable_rels(Node *node, bool top_level);
@@ -609,7 +609,7 @@ reduce_outer_joins_pass1(Node *jtnode)
  */
 static void
 reduce_outer_joins_pass2(Node *jtnode,
-						 reduce_outer_joins_state * state,
+						 reduce_outer_joins_state *state,
 						 Query *parse,
 						 Relids nonnullable_rels)
 {
diff --git a/src/backend/optimizer/prep/prepqual.c b/src/backend/optimizer/prep/prepqual.c
index d4151ee0ff2..9c614cc3f11 100644
--- a/src/backend/optimizer/prep/prepqual.c
+++ b/src/backend/optimizer/prep/prepqual.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/optimizer/prep/prepqual.c,v 1.37 2003/08/04 02:40:01 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/optimizer/prep/prepqual.c,v 1.38 2003/08/08 21:41:52 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -21,12 +21,12 @@
 #include "utils/lsyscache.h"
 
 static Expr *flatten_andors(Expr *qual);
-static void flatten_andors_and_walker(FastList * out_list, List *andlist);
-static void flatten_andors_or_walker(FastList * out_list, List *orlist);
+static void flatten_andors_and_walker(FastList *out_list, List *andlist);
+static void flatten_andors_or_walker(FastList *out_list, List *orlist);
 static List *pull_ands(List *andlist);
-static void pull_ands_walker(FastList * out_list, List *andlist);
+static void pull_ands_walker(FastList *out_list, List *andlist);
 static List *pull_ors(List *orlist);
-static void pull_ors_walker(FastList * out_list, List *orlist);
+static void pull_ors_walker(FastList *out_list, List *orlist);
 static Expr *find_nots(Expr *qual);
 static Expr *push_nots(Expr *qual);
 static Expr *find_ors(Expr *qual);
@@ -328,7 +328,7 @@ flatten_andors(Expr *qual)
 }
 
 static void
-flatten_andors_and_walker(FastList * out_list, List *andlist)
+flatten_andors_and_walker(FastList *out_list, List *andlist)
 {
 	List	   *arg;
 
@@ -344,7 +344,7 @@ flatten_andors_and_walker(FastList * out_list, List *andlist)
 }
 
 static void
-flatten_andors_or_walker(FastList * out_list, List *orlist)
+flatten_andors_or_walker(FastList *out_list, List *orlist)
 {
 	List	   *arg;
 
@@ -377,7 +377,7 @@ pull_ands(List *andlist)
 }
 
 static void
-pull_ands_walker(FastList * out_list, List *andlist)
+pull_ands_walker(FastList *out_list, List *andlist)
 {
 	List	   *arg;
 
@@ -410,7 +410,7 @@ pull_ors(List *orlist)
 }
 
 static void
-pull_ors_walker(FastList * out_list, List *orlist)
+pull_ors_walker(FastList *out_list, List *orlist)
 {
 	List	   *arg;
 
diff --git a/src/backend/optimizer/util/clauses.c b/src/backend/optimizer/util/clauses.c
index 6d1edb3356f..b95002ef43e 100644
--- a/src/backend/optimizer/util/clauses.c
+++ b/src/backend/optimizer/util/clauses.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.151 2003/08/04 02:40:01 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.152 2003/08/08 21:41:55 momjian Exp $
  *
  * HISTORY
  *	  AUTHOR			DATE			MAJOR EVENT
@@ -50,7 +50,7 @@ typedef struct
 	int			nargs;
 	List	   *args;
 	int		   *usecounts;
-}	substitute_actual_parameters_context;
+} substitute_actual_parameters_context;
 
 static bool contain_agg_clause_walker(Node *node, void *context);
 static bool contain_distinct_agg_clause_walker(Node *node, void *context);
@@ -70,7 +70,7 @@ static Expr *inline_function(Oid funcid, Oid result_type, List *args,
 static Node *substitute_actual_parameters(Node *expr, int nargs, List *args,
 							 int *usecounts);
 static Node *substitute_actual_parameters_mutator(Node *node,
-						 substitute_actual_parameters_context * context);
+						  substitute_actual_parameters_context *context);
 static void sql_inline_error_callback(void *arg);
 static Expr *evaluate_expr(Expr *expr, Oid result_type);
 
@@ -981,7 +981,7 @@ NumRelids(Node *clause)
  * XXX the clause is destructively modified!
  */
 void
-CommuteClause(OpExpr * clause)
+CommuteClause(OpExpr *clause)
 {
 	Oid			opoid;
 	Node	   *temp;
@@ -2002,7 +2002,7 @@ substitute_actual_parameters(Node *expr, int nargs, List *args,
 
 static Node *
 substitute_actual_parameters_mutator(Node *node,
-						  substitute_actual_parameters_context * context)
+						   substitute_actual_parameters_context *context)
 {
 	if (node == NULL)
 		return NULL;
diff --git a/src/backend/optimizer/util/var.c b/src/backend/optimizer/util/var.c
index 46a37f66cde..b5e6417f1cf 100644
--- a/src/backend/optimizer/util/var.c
+++ b/src/backend/optimizer/util/var.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/optimizer/util/var.c,v 1.53 2003/08/04 02:40:01 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/optimizer/util/var.c,v 1.54 2003/08/08 21:41:55 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -39,7 +39,7 @@ typedef struct
 {
 	int			min_varlevel;
 	int			sublevels_up;
-}	find_minimum_var_level_context;
+} find_minimum_var_level_context;
 
 typedef struct
 {
@@ -61,7 +61,7 @@ static bool contain_var_clause_walker(Node *node, void *context);
 static bool contain_vars_of_level_walker(Node *node, int *sublevels_up);
 static bool contain_vars_above_level_walker(Node *node, int *sublevels_up);
 static bool find_minimum_var_level_walker(Node *node,
-							  find_minimum_var_level_context * context);
+							  find_minimum_var_level_context *context);
 static bool pull_var_clause_walker(Node *node,
 					   pull_var_clause_context *context);
 static Node *flatten_join_alias_vars_mutator(Node *node,
@@ -364,7 +364,7 @@ find_minimum_var_level(Node *node)
 
 static bool
 find_minimum_var_level_walker(Node *node,
-							  find_minimum_var_level_context * context)
+							  find_minimum_var_level_context *context)
 {
 	if (node == NULL)
 		return false;
diff --git a/src/backend/parser/analyze.c b/src/backend/parser/analyze.c
index 3835c31eb27..ea9a1d80a8e 100644
--- a/src/backend/parser/analyze.c
+++ b/src/backend/parser/analyze.c
@@ -6,7 +6,7 @@
  * Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- *	$Header: /cvsroot/pgsql/src/backend/parser/analyze.c,v 1.285 2003/08/04 02:40:01 momjian Exp $
+ *	$Header: /cvsroot/pgsql/src/backend/parser/analyze.c,v 1.286 2003/08/08 21:41:55 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -89,7 +89,7 @@ typedef struct
 {
 	Oid		   *paramTypes;
 	int			numParams;
-}	check_parameter_resolution_context;
+} check_parameter_resolution_context;
 
 
 static List *do_parse_analyze(Node *parseTree, ParseState *pstate);
@@ -106,7 +106,7 @@ static Query *transformSetOperationStmt(ParseState *pstate, SelectStmt *stmt);
 static Node *transformSetOperationTree(ParseState *pstate, SelectStmt *stmt);
 static Query *transformUpdateStmt(ParseState *pstate, UpdateStmt *stmt);
 static Query *transformDeclareCursorStmt(ParseState *pstate,
-						   DeclareCursorStmt * stmt);
+						   DeclareCursorStmt *stmt);
 static Query *transformPrepareStmt(ParseState *pstate, PrepareStmt *stmt);
 static Query *transformExecuteStmt(ParseState *pstate, ExecuteStmt *stmt);
 static Query *transformCreateStmt(ParseState *pstate, CreateStmt *stmt,
@@ -120,7 +120,7 @@ static void transformTableConstraint(ParseState *pstate,
 						 CreateStmtContext *cxt,
 						 Constraint *constraint);
 static void transformInhRelation(ParseState *pstate, CreateStmtContext *cxt,
-					 InhRelation * inhrelation);
+					 InhRelation *inhrelation);
 static void transformIndexConstraints(ParseState *pstate,
 						  CreateStmtContext *cxt);
 static void transformFKConstraints(ParseState *pstate,
@@ -135,7 +135,7 @@ static bool relationHasPrimaryKey(Oid relationOid);
 static void release_pstate_resources(ParseState *pstate);
 static FromExpr *makeFromExpr(List *fromlist, Node *quals);
 static bool check_parameter_resolution_walker(Node *node,
-						   check_parameter_resolution_context * context);
+							check_parameter_resolution_context *context);
 
 
 /*
@@ -1171,7 +1171,7 @@ transformTableConstraint(ParseState *pstate, CreateStmtContext *cxt,
  */
 static void
 transformInhRelation(ParseState *pstate, CreateStmtContext *cxt,
-					 InhRelation * inhRelation)
+					 InhRelation *inhRelation)
 {
 	AttrNumber	parent_attno;
 
@@ -1907,9 +1907,8 @@ transformRuleStmt(ParseState *pstate, RuleStmt *stmt,
 			{
 				/*
 				 * If sub_qry is a setop, manipulating its jointree will
-				 * do no good at all, because the jointree is dummy.
-				 * (This should be a can't-happen case because of prior
-				 * tests.)
+				 * do no good at all, because the jointree is dummy. (This
+				 * should be a can't-happen case because of prior tests.)
 				 */
 				if (sub_qry->setOperations != NULL)
 					ereport(ERROR,
@@ -2643,7 +2642,7 @@ transformAlterTableStmt(ParseState *pstate, AlterTableStmt *stmt,
 }
 
 static Query *
-transformDeclareCursorStmt(ParseState *pstate, DeclareCursorStmt * stmt)
+transformDeclareCursorStmt(ParseState *pstate, DeclareCursorStmt *stmt)
 {
 	Query	   *result = makeNode(Query);
 	List	   *extras_before = NIL,
@@ -3200,7 +3199,7 @@ analyzeCreateSchemaStmt(CreateSchemaStmt *stmt)
  */
 static bool
 check_parameter_resolution_walker(Node *node,
-							check_parameter_resolution_context * context)
+							 check_parameter_resolution_context *context)
 {
 	if (node == NULL)
 		return false;
diff --git a/src/backend/regex/regc_color.c b/src/backend/regex/regc_color.c
index da2b79b5f09..05f1d462ee7 100644
--- a/src/backend/regex/regc_color.c
+++ b/src/backend/regex/regc_color.c
@@ -28,7 +28,7 @@
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
- * $Header: /cvsroot/pgsql/src/backend/regex/regc_color.c,v 1.2 2003/08/04 00:43:21 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/regex/regc_color.c,v 1.3 2003/08/08 21:41:56 momjian Exp $
  *
  *
  * Note that there are some incestuous relationships between this code and
@@ -144,7 +144,7 @@ cmtreefree(struct colormap * cm,
 /*
  * setcolor - set the color of a character in a colormap
  */
-static color				/* previous color */
+static color					/* previous color */
 setcolor(struct colormap * cm,
 		 chr c,
 		 pcolor co)
@@ -218,7 +218,7 @@ maxcolor(struct colormap * cm)
  * newcolor - find a new color (must be subject of setcolor at once)
  * Beware:	may relocate the colordescs.
  */
-static color				/* COLORLESS for error */
+static color					/* COLORLESS for error */
 newcolor(struct colormap * cm)
 {
 	struct colordesc *cd;
@@ -421,7 +421,7 @@ subrange(struct vars * v,
 
 	/* first, align "from" on a tree-block boundary */
 	uf = (uchr) from;
-	i = (int) (((uf + BYTTAB - 1) & (uchr) ~ BYTMASK) - uf);
+	i = (int) (((uf + BYTTAB - 1) & (uchr) ~BYTMASK) - uf);
 	for (; from <= to && i > 0; i--, from++)
 		newarc(v->nfa, PLAIN, subcolor(v->cm, from), lp, rp);
 	if (from > to)				/* didn't reach a boundary */
diff --git a/src/backend/regex/regc_cvec.c b/src/backend/regex/regc_cvec.c
index 502bbeeca7e..b676d65a27e 100644
--- a/src/backend/regex/regc_cvec.c
+++ b/src/backend/regex/regc_cvec.c
@@ -28,7 +28,7 @@
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
- * $Header: /cvsroot/pgsql/src/backend/regex/regc_cvec.c,v 1.2 2003/08/04 00:43:21 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/regex/regc_cvec.c,v 1.3 2003/08/08 21:41:56 momjian Exp $
  *
  */
 
@@ -52,7 +52,7 @@ newcvec(int nchrs,				/* to hold this many chrs... */
 	if (cv == NULL)
 		return NULL;
 	cv->chrspace = nchrs;
-	cv->chrs = (chr *) & cv->mcces[nmcces];		/* chrs just after MCCE
+	cv->chrs = (chr *) &cv->mcces[nmcces];		/* chrs just after MCCE
 												 * ptrs */
 	cv->mccespace = nmcces;
 	cv->ranges = cv->chrs + nchrs + nmcces * (MAXMCCE + 1);
@@ -71,7 +71,7 @@ clearcvec(struct cvec * cv)
 
 	assert(cv != NULL);
 	cv->nchrs = 0;
-	assert(cv->chrs == (chr *) & cv->mcces[cv->mccespace]);
+	assert(cv->chrs == (chr *) &cv->mcces[cv->mccespace]);
 	cv->nmcces = 0;
 	cv->nmccechrs = 0;
 	cv->nranges = 0;
@@ -111,8 +111,8 @@ addrange(struct cvec * cv,		/* character vector */
  */
 static void
 addmcce(struct cvec * cv,		/* character vector */
-		chr * startp,			/* beginning of text */
-		chr * endp)				/* just past end of text */
+		chr *startp,			/* beginning of text */
+		chr *endp)				/* just past end of text */
 {
 	int			len;
 	int			i;
diff --git a/src/backend/regex/regc_lex.c b/src/backend/regex/regc_lex.c
index 2407e06ef47..18dff7ec34d 100644
--- a/src/backend/regex/regc_lex.c
+++ b/src/backend/regex/regc_lex.c
@@ -28,7 +28,7 @@
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
- * $Header: /cvsroot/pgsql/src/backend/regex/regc_lex.c,v 1.2 2003/08/04 00:43:21 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/regex/regc_lex.c,v 1.3 2003/08/08 21:41:56 momjian Exp $
  *
  */
 
@@ -201,8 +201,8 @@ prefixes(struct vars * v)
  */
 static void
 lexnest(struct vars * v,
-		chr * beginp,			/* start of interpolation */
-		chr * endp)				/* one past end of interpolation */
+		chr *beginp,			/* start of interpolation */
+		chr *endp)				/* one past end of interpolation */
 {
 	assert(v->savenow == NULL); /* only one level of nesting */
 	v->savenow = v->now;
@@ -876,7 +876,7 @@ lexescape(struct vars * v)
 /*
  * lexdigits - slurp up digits and return chr value
  */
-static chr					/* chr value; errors signalled via ERR */
+static chr						/* chr value; errors signalled via ERR */
 lexdigits(struct vars * v,
 		  int base,
 		  int minlen,
@@ -1121,8 +1121,8 @@ newline(void)
  */
 static chr
 chrnamed(struct vars * v,
-		 chr * startp,			/* start of name */
-		 chr * endp,			/* just past end of name */
+		 chr *startp,			/* start of name */
+		 chr *endp,				/* just past end of name */
 		 chr lastresort)		/* what to return if name lookup fails */
 {
 	celt		c;
diff --git a/src/backend/regex/regc_locale.c b/src/backend/regex/regc_locale.c
index 69c7fd7214a..99ab48cd8a8 100644
--- a/src/backend/regex/regc_locale.c
+++ b/src/backend/regex/regc_locale.c
@@ -47,7 +47,7 @@
  * permission to use and distribute the software in accordance with the
  * terms specified in this license.
  *
- * $Header: /cvsroot/pgsql/src/backend/regex/regc_locale.c,v 1.2 2003/08/04 00:43:21 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/regex/regc_locale.c,v 1.3 2003/08/08 21:41:56 momjian Exp $
  */
 
 /* ASCII character-name table */
@@ -453,8 +453,8 @@ allmcces(struct vars * v,		/* context */
  */
 static celt
 element(struct vars * v,		/* context */
-		chr * startp,			/* points to start of name */
-		chr * endp)				/* points just past end of name */
+		chr *startp,			/* points to start of name */
+		chr *endp)				/* points just past end of name */
 {
 	struct cname *cn;
 	size_t		len;
@@ -593,8 +593,8 @@ eclass(struct vars * v,			/* context */
  */
 static struct cvec *
 cclass(struct vars * v,			/* context */
-	   chr * startp,			/* where the name starts */
-	   chr * endp,				/* just past the end of the name */
+	   chr *startp,				/* where the name starts */
+	   chr *endp,				/* just past the end of the name */
 	   int cases)				/* case-independent? */
 {
 	size_t		len;
@@ -804,7 +804,7 @@ allcases(struct vars * v,		/* context */
  * stop at embedded NULs!
  */
 static int						/* 0 for equal, nonzero for unequal */
-cmp(const chr * x, const chr * y,		/* strings to compare */
+cmp(const chr *x, const chr *y, /* strings to compare */
 	size_t len)					/* exact length of comparison */
 {
 	return memcmp(VS(x), VS(y), len * sizeof(chr));
@@ -819,7 +819,7 @@ cmp(const chr * x, const chr * y,		/* strings to compare */
  * stop at embedded NULs!
  */
 static int						/* 0 for equal, nonzero for unequal */
-casecmp(const chr * x, const chr * y,	/* strings to compare */
+casecmp(const chr *x, const chr *y,		/* strings to compare */
 		size_t len)				/* exact length of comparison */
 {
 	for (; len > 0; len--, x++, y++)
diff --git a/src/backend/regex/regcomp.c b/src/backend/regex/regcomp.c
index 58af64539d8..cfc2481fca3 100644
--- a/src/backend/regex/regcomp.c
+++ b/src/backend/regex/regcomp.c
@@ -28,7 +28,7 @@
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
- * $Header: /cvsroot/pgsql/src/backend/regex/regcomp.c,v 1.37 2003/08/04 00:43:21 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/regex/regcomp.c,v 1.38 2003/08/08 21:41:56 momjian Exp $
  *
  */
 
@@ -293,7 +293,7 @@ static struct fns functions = {
  */
 int
 pg_regcomp(regex_t *re,
-		   const chr * string,
+		   const chr *string,
 		   size_t len,
 		   int flags)
 {
@@ -1052,8 +1052,8 @@ parseqatom(struct vars * v,
 	/*
 	 * prepare a general-purpose state skeleton
 	 *
-	 * ---> [s] ---prefix---> [begin] ---atom---> [end] ----rest---> [rp] /
-	 * / [lp] ----> [s2] ----bypass---------------------
+	 * ---> [s] ---prefix---> [begin] ---atom---> [end] ----rest---> [rp] / /
+	 * [lp] ----> [s2] ----bypass---------------------
 	 *
 	 * where bypass is an empty, and prefix is some repetitions of atom
 	 */
@@ -1758,7 +1758,7 @@ dovec(struct vars * v,
 /*
  * nextleader - find next MCCE leader within range
  */
-static celt				/* NOCELT means none */
+static celt						/* NOCELT means none */
 nextleader(struct vars * v,
 		   chr from,
 		   chr to)
diff --git a/src/backend/regex/rege_dfa.c b/src/backend/regex/rege_dfa.c
index 6004462c934..7d06898ad70 100644
--- a/src/backend/regex/rege_dfa.c
+++ b/src/backend/regex/rege_dfa.c
@@ -28,7 +28,7 @@
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
- * $Header: /cvsroot/pgsql/src/backend/regex/rege_dfa.c,v 1.2 2003/08/04 00:43:21 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/regex/rege_dfa.c,v 1.3 2003/08/08 21:41:56 momjian Exp $
  *
  */
 
@@ -38,8 +38,8 @@
 static chr *					/* endpoint, or NULL */
 longest(struct vars * v,		/* used only for debug and exec flags */
 		struct dfa * d,
-		chr * start,			/* where the match should start */
-		chr * stop,				/* match must end at or before here */
+		chr *start,				/* where the match should start */
+		chr *stop,				/* match must end at or before here */
 		int *hitstopp)			/* record whether hit v->stop, if non-NULL */
 {
 	chr		   *cp;
@@ -142,10 +142,10 @@ longest(struct vars * v,		/* used only for debug and exec flags */
 static chr *					/* endpoint, or NULL */
 shortest(struct vars * v,
 		 struct dfa * d,
-		 chr * start,			/* where the match should start */
-		 chr * min,				/* match must end at or after here */
-		 chr * max,				/* match must end at or before here */
-		 chr ** coldp,			/* store coldstart pointer here, if
+		 chr *start,			/* where the match should start */
+		 chr *min,				/* match must end at or after here */
+		 chr *max,				/* match must end at or before here */
+		 chr **coldp,			/* store coldstart pointer here, if
 								 * nonNULL */
 		 int *hitstopp)			/* record whether hit v->stop, if non-NULL */
 {
@@ -394,7 +394,7 @@ hash(unsigned *uv,
 static struct sset *
 initialize(struct vars * v,		/* used only for debug flags */
 		   struct dfa * d,
-		   chr * start)
+		   chr *start)
 {
 	struct sset *ss;
 	int			i;
@@ -430,8 +430,8 @@ miss(struct vars * v,			/* used only for debug flags */
 	 struct dfa * d,
 	 struct sset * css,
 	 pcolor co,
-	 chr * cp,					/* next chr */
-	 chr * start)				/* where the attempt got started */
+	 chr *cp,					/* next chr */
+	 chr *start)				/* where the attempt got started */
 {
 	struct cnfa *cnfa = d->cnfa;
 	int			i;
@@ -538,7 +538,7 @@ miss(struct vars * v,			/* used only for debug flags */
 static int						/* predicate:  constraint satisfied? */
 lacon(struct vars * v,
 	  struct cnfa * pcnfa,		/* parent cnfa */
-	  chr * cp,
+	  chr *cp,
 	  pcolor co)				/* "color" of the lookahead constraint */
 {
 	int			n;
@@ -571,8 +571,8 @@ lacon(struct vars * v,
 static struct sset *
 getvacant(struct vars * v,		/* used only for debug flags */
 		  struct dfa * d,
-		  chr * cp,
-		  chr * start)
+		  chr *cp,
+		  chr *start)
 {
 	int			i;
 	struct sset *ss;
@@ -639,8 +639,8 @@ getvacant(struct vars * v,		/* used only for debug flags */
 static struct sset *
 pickss(struct vars * v,			/* used only for debug flags */
 	   struct dfa * d,
-	   chr * cp,
-	   chr * start)
+	   chr *cp,
+	   chr *start)
 {
 	int			i;
 	struct sset *ss;
diff --git a/src/backend/regex/regexec.c b/src/backend/regex/regexec.c
index 535501ff0b7..11032b431a5 100644
--- a/src/backend/regex/regexec.c
+++ b/src/backend/regex/regexec.c
@@ -27,7 +27,7 @@
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
- * $Header: /cvsroot/pgsql/src/backend/regex/regexec.c,v 1.22 2003/08/04 00:43:21 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/regex/regexec.c,v 1.23 2003/08/08 21:41:56 momjian Exp $
  *
  */
 
@@ -166,9 +166,9 @@ static struct sset *pickss(struct vars *, struct dfa *, chr *, chr *);
  */
 int
 pg_regexec(regex_t *re,
-		   const chr * string,
+		   const chr *string,
 		   size_t len,
-		   rm_detail_t * details,
+		   rm_detail_t *details,
 		   size_t nmatch,
 		   regmatch_t pmatch[],
 		   int flags)
@@ -399,7 +399,7 @@ cfindloop(struct vars * v,
 		  struct colormap * cm,
 		  struct dfa * d,
 		  struct dfa * s,
-		  chr ** coldp)			/* where to put coldstart pointer */
+		  chr **coldp)			/* where to put coldstart pointer */
 {
 	chr		   *begin;
 	chr		   *end;
@@ -528,8 +528,8 @@ zapmem(struct vars * v,
 static void
 subset(struct vars * v,
 	   struct subre * sub,
-	   chr * begin,
-	   chr * end)
+	   chr *begin,
+	   chr *end)
 {
 	int			n = sub->subno;
 
@@ -548,8 +548,8 @@ subset(struct vars * v,
 static int						/* regexec return code */
 dissect(struct vars * v,
 		struct subre * t,
-		chr * begin,			/* beginning of relevant substring */
-		chr * end)				/* end of same */
+		chr *begin,				/* beginning of relevant substring */
+		chr *end)				/* end of same */
 {
 	assert(t != NULL);
 	MDEBUG(("dissect %ld-%ld\n", LOFF(begin), LOFF(end)));
@@ -589,8 +589,8 @@ dissect(struct vars * v,
 static int						/* regexec return code */
 condissect(struct vars * v,
 		   struct subre * t,
-		   chr * begin,			/* beginning of relevant substring */
-		   chr * end)			/* end of same */
+		   chr *begin,			/* beginning of relevant substring */
+		   chr *end)			/* end of same */
 {
 	struct dfa *d;
 	struct dfa *d2;
@@ -671,8 +671,8 @@ condissect(struct vars * v,
 static int						/* regexec return code */
 altdissect(struct vars * v,
 		   struct subre * t,
-		   chr * begin,			/* beginning of relevant substring */
-		   chr * end)			/* end of same */
+		   chr *begin,			/* beginning of relevant substring */
+		   chr *end)			/* end of same */
 {
 	struct dfa *d;
 	int			i;
@@ -706,8 +706,8 @@ altdissect(struct vars * v,
 static int						/* regexec return code */
 cdissect(struct vars * v,
 		 struct subre * t,
-		 chr * begin,			/* beginning of relevant substring */
-		 chr * end)				/* end of same */
+		 chr *begin,			/* beginning of relevant substring */
+		 chr *end)				/* end of same */
 {
 	int			er;
 
@@ -754,8 +754,8 @@ cdissect(struct vars * v,
 static int						/* regexec return code */
 ccondissect(struct vars * v,
 			struct subre * t,
-			chr * begin,		/* beginning of relevant substring */
-			chr * end)			/* end of same */
+			chr *begin,			/* beginning of relevant substring */
+			chr *end)			/* end of same */
 {
 	struct dfa *d;
 	struct dfa *d2;
@@ -855,8 +855,8 @@ ccondissect(struct vars * v,
 static int						/* regexec return code */
 crevdissect(struct vars * v,
 			struct subre * t,
-			chr * begin,		/* beginning of relevant substring */
-			chr * end)			/* end of same */
+			chr *begin,			/* beginning of relevant substring */
+			chr *end)			/* end of same */
 {
 	struct dfa *d;
 	struct dfa *d2;
@@ -953,8 +953,8 @@ crevdissect(struct vars * v,
 static int						/* regexec return code */
 cbrdissect(struct vars * v,
 		   struct subre * t,
-		   chr * begin,			/* beginning of relevant substring */
-		   chr * end)			/* end of same */
+		   chr *begin,			/* beginning of relevant substring */
+		   chr *end)			/* end of same */
 {
 	int			i;
 	int			n = t->subno;
@@ -1020,8 +1020,8 @@ cbrdissect(struct vars * v,
 static int						/* regexec return code */
 caltdissect(struct vars * v,
 			struct subre * t,
-			chr * begin,		/* beginning of relevant substring */
-			chr * end)			/* end of same */
+			chr *begin,			/* beginning of relevant substring */
+			chr *end)			/* end of same */
 {
 	struct dfa *d;
 	int			er;
diff --git a/src/backend/rewrite/rewriteHandler.c b/src/backend/rewrite/rewriteHandler.c
index dc9b7f22163..e8f3c185d16 100644
--- a/src/backend/rewrite/rewriteHandler.c
+++ b/src/backend/rewrite/rewriteHandler.c
@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.127 2003/08/04 02:40:03 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.128 2003/08/08 21:41:56 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -38,7 +38,7 @@ typedef struct rewrite_event
 {
 	Oid			relation;		/* OID of relation having rules */
 	CmdType		event;			/* type of rule being fired */
-}	rewrite_event;
+} rewrite_event;
 
 static Query *rewriteRuleAction(Query *parsetree,
 				  Query *rule_action,
diff --git a/src/backend/rewrite/rewriteManip.c b/src/backend/rewrite/rewriteManip.c
index c9f96f5ecd5..3d0cf931c69 100644
--- a/src/backend/rewrite/rewriteManip.c
+++ b/src/backend/rewrite/rewriteManip.c
@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteManip.c,v 1.76 2003/08/04 02:40:03 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteManip.c,v 1.77 2003/08/08 21:41:58 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -25,10 +25,10 @@
 typedef struct
 {
 	int			sublevels_up;
-}	checkExprHasAggs_context;
+} checkExprHasAggs_context;
 
 static bool checkExprHasAggs_walker(Node *node,
-						checkExprHasAggs_context * context);
+						checkExprHasAggs_context *context);
 static bool checkExprHasSubLink_walker(Node *node, void *context);
 static Relids offset_relid_set(Relids relids, int offset);
 static Relids adjust_relid_set(Relids relids, int oldrelid, int newrelid);
@@ -63,7 +63,7 @@ checkExprHasAggs(Node *node)
 }
 
 static bool
-checkExprHasAggs_walker(Node *node, checkExprHasAggs_context * context)
+checkExprHasAggs_walker(Node *node, checkExprHasAggs_context *context)
 {
 	if (node == NULL)
 		return false;
diff --git a/src/backend/storage/freespace/freespace.c b/src/backend/storage/freespace/freespace.c
index 7dd286b8936..94578c4d9b9 100644
--- a/src/backend/storage/freespace/freespace.c
+++ b/src/backend/storage/freespace/freespace.c
@@ -8,7 +8,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/storage/freespace/freespace.c,v 1.20 2003/08/04 02:40:03 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/storage/freespace/freespace.c,v 1.21 2003/08/08 21:41:59 momjian Exp $
  *
  *
  * NOTES:
@@ -144,7 +144,7 @@ typedef struct FsmCacheFileHeader
 	uint32		endian;
 	uint32		version;
 	int32		numRels;
-}	FsmCacheFileHeader;
+} FsmCacheFileHeader;
 
 /* Per-relation header */
 typedef struct FsmCacheRelHeader
@@ -154,7 +154,7 @@ typedef struct FsmCacheRelHeader
 	uint32		avgRequest;		/* moving average of space requests */
 	int32		lastPageCount;	/* pages passed to RecordRelationFreeSpace */
 	int32		storedPages;	/* # of pages stored in arena */
-}	FsmCacheRelHeader;
+} FsmCacheRelHeader;
 
 
 /*
@@ -236,10 +236,10 @@ static bool lookup_fsm_page_entry(FSMRelation *fsmrel, BlockNumber page,
 					  int *outPageIndex);
 static void compact_fsm_storage(void);
 static void push_fsm_rels_after(FSMRelation *afterRel);
-static void pack_incoming_pages(FSMPageData * newLocation, int newPages,
-					PageFreeSpaceInfo * pageSpaces, int nPages);
-static void pack_existing_pages(FSMPageData * newLocation, int newPages,
-					FSMPageData * oldLocation, int oldPages);
+static void pack_incoming_pages(FSMPageData *newLocation, int newPages,
+					PageFreeSpaceInfo *pageSpaces, int nPages);
+static void pack_existing_pages(FSMPageData *newLocation, int newPages,
+					FSMPageData *oldLocation, int oldPages);
 static int	fsm_calc_request(FSMRelation *fsmrel);
 static int	fsm_calc_target_allocation(int myRequest);
 static int	fsm_current_chunks(FSMRelation *fsmrel);
@@ -459,7 +459,7 @@ GetAvgFSMRequestSize(RelFileNode *rel)
 void
 RecordRelationFreeSpace(RelFileNode *rel,
 						int nPages,
-						PageFreeSpaceInfo * pageSpaces)
+						PageFreeSpaceInfo *pageSpaces)
 {
 	FSMRelation *fsmrel;
 
@@ -1560,8 +1560,8 @@ push_fsm_rels_after(FSMRelation *afterRel)
 #define HISTOGRAM_BINS	64
 
 static void
-pack_incoming_pages(FSMPageData * newLocation, int newPages,
-					PageFreeSpaceInfo * pageSpaces, int nPages)
+pack_incoming_pages(FSMPageData *newLocation, int newPages,
+					PageFreeSpaceInfo *pageSpaces, int nPages)
 {
 	int			histogram[HISTOGRAM_BINS];
 	int			above,
@@ -1630,8 +1630,8 @@ pack_incoming_pages(FSMPageData * newLocation, int newPages,
  * so that we can copy data moving forward in the arrays without problem.
  */
 static void
-pack_existing_pages(FSMPageData * newLocation, int newPages,
-					FSMPageData * oldLocation, int oldPages)
+pack_existing_pages(FSMPageData *newLocation, int newPages,
+					FSMPageData *oldLocation, int oldPages)
 {
 	int			histogram[HISTOGRAM_BINS];
 	int			above,
diff --git a/src/backend/storage/lmgr/deadlock.c b/src/backend/storage/lmgr/deadlock.c
index b9125ea57ae..4ed712bcec6 100644
--- a/src/backend/storage/lmgr/deadlock.c
+++ b/src/backend/storage/lmgr/deadlock.c
@@ -12,7 +12,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/storage/lmgr/deadlock.c,v 1.23 2003/08/04 02:40:03 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/storage/lmgr/deadlock.c,v 1.24 2003/08/08 21:42:00 momjian Exp $
  *
  *	Interface:
  *
@@ -61,7 +61,7 @@ typedef struct
 	LOCKTAG		locktag;		/* ID of awaited lock object */
 	LOCKMODE	lockmode;		/* type of lock we're waiting for */
 	int			pid;			/* PID of blocked backend */
-}	DEADLOCK_INFO;
+} DEADLOCK_INFO;
 
 
 static bool DeadLockCheckRecurse(PGPROC *proc);
diff --git a/src/backend/storage/lmgr/s_lock.c b/src/backend/storage/lmgr/s_lock.c
index de6b355aace..3124feb798e 100644
--- a/src/backend/storage/lmgr/s_lock.c
+++ b/src/backend/storage/lmgr/s_lock.c
@@ -9,7 +9,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/storage/lmgr/s_lock.c,v 1.15 2003/08/06 16:43:43 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/storage/lmgr/s_lock.c,v 1.16 2003/08/08 21:42:00 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -54,26 +54,27 @@ s_lock(volatile slock_t *lock, const char *file, int line)
 	 * finish 100 iterations.  However, on a uniprocessor, the tight loop
 	 * is just a waste of cycles, so don't iterate thousands of times.
 	 *
-	 * Once we do decide to block, we use randomly increasing select() delays.
-	 * The first delay is 10 msec, then the delay randomly increases to about
-	 * one second, after which we reset to 10 msec and start again.  The idea
-	 * here is that in the presence of heavy contention we need to increase
-	 * the delay, else the spinlock holder may never get to run and release
-	 * the lock.  (Consider situation where spinlock holder has been nice'd
-	 * down in priority by the scheduler --- it will not get scheduled until
-	 * all would-be acquirers are sleeping, so if we always use a 10-msec
-	 * sleep, there is a real possibility of starvation.)  But we can't just
-	 * clamp the delay to an upper bound, else it would take a long time to
-	 * make a reasonable number of tries.
+	 * Once we do decide to block, we use randomly increasing select()
+	 * delays. The first delay is 10 msec, then the delay randomly
+	 * increases to about one second, after which we reset to 10 msec and
+	 * start again.  The idea here is that in the presence of heavy
+	 * contention we need to increase the delay, else the spinlock holder
+	 * may never get to run and release the lock.  (Consider situation
+	 * where spinlock holder has been nice'd down in priority by the
+	 * scheduler --- it will not get scheduled until all would-be
+	 * acquirers are sleeping, so if we always use a 10-msec sleep, there
+	 * is a real possibility of starvation.)  But we can't just clamp the
+	 * delay to an upper bound, else it would take a long time to make a
+	 * reasonable number of tries.
 	 *
 	 * We time out and declare error after NUM_DELAYS delays (thus, exactly
 	 * that many tries).  With the given settings, this will usually take
-	 * 3 or so minutes.  It seems better to fix the total number of tries (and
-	 * thus the probability of unintended failure) than to fix the total time
-	 * spent.
+	 * 3 or so minutes.  It seems better to fix the total number of tries
+	 * (and thus the probability of unintended failure) than to fix the
+	 * total time spent.
 	 *
-	 * The select() delays are measured in centiseconds (0.01 sec) because
-	 * 10 msec is a common resolution limit at the OS level.
+	 * The select() delays are measured in centiseconds (0.01 sec) because 10
+	 * msec is a common resolution limit at the OS level.
 	 */
 #define SPINS_PER_DELAY		100
 #define NUM_DELAYS			1000
@@ -97,12 +98,13 @@ s_lock(volatile slock_t *lock, const char *file, int line)
 			(void) select(0, NULL, NULL, NULL, &delay);
 
 #if defined(S_LOCK_TEST)
-			fprintf(stdout, "*"); fflush(stdout);
+			fprintf(stdout, "*");
+			fflush(stdout);
 #endif
 
 			/* increase delay by a random fraction between 1X and 2X */
 			cur_delay += (int) (cur_delay *
-				(((double) random()) / ((double) MAX_RANDOM_VALUE)) + 0.5);
+			  (((double) random()) / ((double) MAX_RANDOM_VALUE)) + 0.5);
 			/* wrap back to minimum delay when max is exceeded */
 			if (cur_delay > MAX_DELAY_CSEC)
 				cur_delay = MIN_DELAY_CSEC;
diff --git a/src/backend/utils/adt/arrayfuncs.c b/src/backend/utils/adt/arrayfuncs.c
index 53540e1fa4c..df8265d9995 100644
--- a/src/backend/utils/adt/arrayfuncs.c
+++ b/src/backend/utils/adt/arrayfuncs.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/arrayfuncs.c,v 1.96 2003/08/04 02:40:04 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/arrayfuncs.c,v 1.97 2003/08/08 21:42:04 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -1194,7 +1194,7 @@ array_length_coerce(PG_FUNCTION_ARGS)
 	{
 		Oid			elemtype;
 		FmgrInfo	coerce_finfo;
-	}			alc_extra;
+	} alc_extra;
 	alc_extra  *my_extra;
 	FunctionCallInfoData locfcinfo;
 
@@ -2036,7 +2036,7 @@ array_map(FunctionCallInfo fcinfo, Oid inpType, Oid retType)
 	{
 		ArrayMetaState inp_extra;
 		ArrayMetaState ret_extra;
-	}			am_extra;
+	} am_extra;
 	am_extra   *my_extra;
 	ArrayMetaState *inp_extra;
 	ArrayMetaState *ret_extra;
@@ -2531,7 +2531,7 @@ array_cmp(FunctionCallInfo fcinfo)
 		char		typalign;
 		FmgrInfo	eqproc;
 		FmgrInfo	ordproc;
-	}			ac_extra;
+	} ac_extra;
 	ac_extra   *my_extra;
 
 	element_type = ARR_ELEMTYPE(array1);
@@ -2896,7 +2896,7 @@ array_type_coerce(PG_FUNCTION_ARGS)
 		Oid			srctype;
 		Oid			desttype;
 		FmgrInfo	coerce_finfo;
-	}			atc_extra;
+	} atc_extra;
 	atc_extra  *my_extra;
 	FunctionCallInfoData locfcinfo;
 
@@ -2989,7 +2989,7 @@ array_type_coerce(PG_FUNCTION_ARGS)
  *	rcontext is where to keep working state
  */
 ArrayBuildState *
-accumArrayResult(ArrayBuildState * astate,
+accumArrayResult(ArrayBuildState *astate,
 				 Datum dvalue, bool disnull,
 				 Oid element_type,
 				 MemoryContext rcontext)
@@ -3051,7 +3051,7 @@ accumArrayResult(ArrayBuildState * astate,
  *	rcontext is where to construct result
  */
 Datum
-makeArrayResult(ArrayBuildState * astate,
+makeArrayResult(ArrayBuildState *astate,
 				MemoryContext rcontext)
 {
 	int			dims[1];
@@ -3073,7 +3073,7 @@ makeArrayResult(ArrayBuildState * astate,
  *	rcontext is where to construct result
  */
 Datum
-makeMdArrayResult(ArrayBuildState * astate,
+makeMdArrayResult(ArrayBuildState *astate,
 				  int ndims,
 				  int *dims,
 				  int *lbs,
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index c94f9bf6f97..f6bfafa3cef 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/datetime.c,v 1.112 2003/08/05 18:30:21 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/datetime.c,v 1.113 2003/08/08 21:42:05 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -711,7 +711,7 @@ TrimTrailingZeros(char *str)
  * *numfields - set to the actual number of fields detected
  *
  * The fields extracted from the input are stored as separate, null-terminated
- * strings in the workspace at lowstr.  Any text is converted to lower case.
+ * strings in the workspace at lowstr.	Any text is converted to lower case.
  *
  * Several field types are assigned:
  *	DTK_NUMBER - digits and (possibly) a decimal point
@@ -769,7 +769,7 @@ ParseDateTime(const char *timestr, char *lowstr,
 			else if ((*cp == '-') || (*cp == '/') || (*cp == '.'))
 			{
 				/* save delimiting character to use later */
-				char	delim = *cp;
+				char		delim = *cp;
 
 				*lp++ = *cp++;
 				/* second field is all digits? then no embedded text month */
@@ -833,7 +833,7 @@ ParseDateTime(const char *timestr, char *lowstr,
 			 */
 			if ((*cp == '-') || (*cp == '/') || (*cp == '.'))
 			{
-				char	delim = *cp;
+				char		delim = *cp;
 
 				ftype[nf] = DTK_DATE;
 				*lp++ = *cp++;
@@ -2415,7 +2415,7 @@ DecodeNumber(int flen, char *str, int fmask,
 
 	if (*cp == '.')
 	{
-		double	frac;
+		double		frac;
 
 		/*
 		 * More than two digits before decimal point? Then could be a date
diff --git a/src/backend/utils/adt/oracle_compat.c b/src/backend/utils/adt/oracle_compat.c
index 4e0c14be164..cd9ad553c3d 100644
--- a/src/backend/utils/adt/oracle_compat.c
+++ b/src/backend/utils/adt/oracle_compat.c
@@ -9,7 +9,7 @@
  *
  *
  * IDENTIFICATION
- *	$Header: /cvsroot/pgsql/src/backend/utils/adt/oracle_compat.c,v 1.47 2003/08/04 00:43:25 momjian Exp $
+ *	$Header: /cvsroot/pgsql/src/backend/utils/adt/oracle_compat.c,v 1.48 2003/08/08 21:42:06 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -872,7 +872,7 @@ ascii(PG_FUNCTION_ARGS)
  ********************************************************************/
 
 Datum
-chr(PG_FUNCTION_ARGS)
+chr			(PG_FUNCTION_ARGS)
 {
 	int32		cvalue = PG_GETARG_INT32(0);
 	text	   *result;
diff --git a/src/backend/utils/adt/regexp.c b/src/backend/utils/adt/regexp.c
index 4951c5e4606..66976b9d83e 100644
--- a/src/backend/utils/adt/regexp.c
+++ b/src/backend/utils/adt/regexp.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/regexp.c,v 1.48 2003/08/04 02:40:05 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/regexp.c,v 1.49 2003/08/08 21:42:07 momjian Exp $
  *
  *		Alistair Crooks added the code for the regex caching
  *		agc - cached the regular expressions used - there's a good chance
@@ -73,7 +73,7 @@ typedef struct cached_re_str
 	text	   *cre_pat;		/* original RE (untoasted TEXT form) */
 	int			cre_flags;		/* compile flags: extended,icase etc */
 	regex_t		cre_re;			/* the compiled regular expression */
-}	cached_re_str;
+} cached_re_str;
 
 static int	num_res = 0;		/* # of cached re's */
 static cached_re_str re_array[MAX_CACHED_RES];	/* cached re's */
diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c
index dc0807fc132..49cc73f24e4 100644
--- a/src/backend/utils/adt/ruleutils.c
+++ b/src/backend/utils/adt/ruleutils.c
@@ -3,7 +3,7 @@
  *				back to source text
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/ruleutils.c,v 1.149 2003/08/04 00:43:26 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/ruleutils.c,v 1.150 2003/08/08 21:42:09 momjian Exp $
  *
  *	  This software is copyrighted by Jan Wieck - Hamburg.
  *
@@ -181,15 +181,15 @@ static void get_names_for_var(Var *var, deparse_context *context,
 				  char **schemaname, char **refname, char **attname);
 static RangeTblEntry *find_rte_by_refname(const char *refname,
 					deparse_context *context);
-static const char *get_simple_binary_op_name(OpExpr * expr);
+static const char *get_simple_binary_op_name(OpExpr *expr);
 static bool isSimpleNode(Node *node, Node *parentNode, int prettyFlags);
 static void appendStringInfoSpaces(StringInfo buf, int count);
 static void appendContextKeyword(deparse_context *context, const char *str,
 					 int indentBefore, int indentAfter, int indentPlus);
 static void get_rule_expr(Node *node, deparse_context *context,
 			  bool showimplicit);
-static void get_oper_expr(OpExpr * expr, deparse_context *context);
-static void get_func_expr(FuncExpr * expr, deparse_context *context,
+static void get_oper_expr(OpExpr *expr, deparse_context *context);
+static void get_func_expr(FuncExpr *expr, deparse_context *context,
 			  bool showimplicit);
 static void get_agg_expr(Aggref *aggref, deparse_context *context);
 static Node *strip_type_coercion(Node *expr, Oid resultType);
@@ -2439,7 +2439,7 @@ find_rte_by_refname(const char *refname, deparse_context *context)
  * will return single char binary operator name, or NULL if it's not
  */
 static const char *
-get_simple_binary_op_name(OpExpr * expr)
+get_simple_binary_op_name(OpExpr *expr)
 {
 	List	   *args = expr->args;
 
@@ -3235,7 +3235,7 @@ get_rule_expr(Node *node, deparse_context *context,
  * get_oper_expr			- Parse back an OpExpr node
  */
 static void
-get_oper_expr(OpExpr * expr, deparse_context *context)
+get_oper_expr(OpExpr *expr, deparse_context *context)
 {
 	StringInfo	buf = context->buf;
 	Oid			opno = expr->opno;
@@ -3298,7 +3298,7 @@ get_oper_expr(OpExpr * expr, deparse_context *context)
  * get_func_expr			- Parse back a FuncExpr node
  */
 static void
-get_func_expr(FuncExpr * expr, deparse_context *context,
+get_func_expr(FuncExpr *expr, deparse_context *context,
 			  bool showimplicit)
 {
 	StringInfo	buf = context->buf;
diff --git a/src/backend/utils/adt/selfuncs.c b/src/backend/utils/adt/selfuncs.c
index 3baa12cc855..67996f23257 100644
--- a/src/backend/utils/adt/selfuncs.c
+++ b/src/backend/utils/adt/selfuncs.c
@@ -15,7 +15,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/selfuncs.c,v 1.144 2003/08/04 02:40:05 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/selfuncs.c,v 1.145 2003/08/08 21:42:10 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -2030,7 +2030,7 @@ estimate_num_groups(Query *root, List *groupExprs, double input_rows)
 	{							/* varinfos is a List of these */
 		Var		   *var;
 		double		ndistinct;
-	}			MyVarInfo;
+	} MyVarInfo;
 
 	/* We should not be called unless query has GROUP BY (or DISTINCT) */
 	Assert(groupExprs != NIL);
diff --git a/src/backend/utils/adt/timestamp.c b/src/backend/utils/adt/timestamp.c
index b8a5e3fcb19..e76ec646690 100644
--- a/src/backend/utils/adt/timestamp.c
+++ b/src/backend/utils/adt/timestamp.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/timestamp.c,v 1.91 2003/08/08 00:10:31 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/timestamp.c,v 1.92 2003/08/08 21:42:10 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -1307,11 +1307,12 @@ timestamp_cmp_internal(Timestamp dt1, Timestamp dt2)
 #ifdef HAVE_INT64_TIMESTAMP
 	return ((dt1 < dt2) ? -1 : ((dt1 > dt2) ? 1 : 0));
 #else
+
 	/*
 	 * When using float representation, we have to be wary of NaNs.
 	 *
-	 * We consider all NANs to be equal and larger than any non-NAN. This
-	 * is somewhat arbitrary; the important thing is to have a consistent
+	 * We consider all NANs to be equal and larger than any non-NAN. This is
+	 * somewhat arbitrary; the important thing is to have a consistent
 	 * sort order.
 	 */
 	if (isnan(dt1))
diff --git a/src/backend/utils/error/elog.c b/src/backend/utils/error/elog.c
index ccbb74bb4ad..0a4d85436d1 100644
--- a/src/backend/utils/error/elog.c
+++ b/src/backend/utils/error/elog.c
@@ -37,7 +37,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/error/elog.c,v 1.118 2003/08/04 02:40:06 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/error/elog.c,v 1.119 2003/08/08 21:42:11 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -115,7 +115,7 @@ typedef struct ErrorData
 	char	   *context;		/* context message */
 	int			cursorpos;		/* cursor index into query string */
 	int			saved_errno;	/* errno at entry */
-}	ErrorData;
+} ErrorData;
 
 /* We provide a small stack of ErrorData records for re-entrant cases */
 #define ERRORDATA_STACK_SIZE  5
@@ -138,9 +138,9 @@ static int	recursion_depth = 0;	/* to detect actual recursion */
 	} while (0)
 
 
-static void send_message_to_server_log(ErrorData * edata);
-static void send_message_to_frontend(ErrorData * edata);
-static char *expand_fmt_string(const char *fmt, ErrorData * edata);
+static void send_message_to_server_log(ErrorData *edata);
+static void send_message_to_frontend(ErrorData *edata);
+static char *expand_fmt_string(const char *fmt, ErrorData *edata);
 static const char *useful_strerror(int errnum);
 static const char *error_severity(int elevel);
 static const char *print_timestamp(void);
@@ -1024,7 +1024,7 @@ write_syslog(int level, const char *line)
  * Write error report to server's log
  */
 static void
-send_message_to_server_log(ErrorData * edata)
+send_message_to_server_log(ErrorData *edata)
 {
 	StringInfoData buf;
 
@@ -1151,7 +1151,7 @@ send_message_to_server_log(ErrorData * edata)
  * Write error report to client
  */
 static void
-send_message_to_frontend(ErrorData * edata)
+send_message_to_frontend(ErrorData *edata)
 {
 	StringInfoData msgbuf;
 
@@ -1289,7 +1289,7 @@ send_message_to_frontend(ErrorData * edata)
  * The result is a palloc'd string.
  */
 static char *
-expand_fmt_string(const char *fmt, ErrorData * edata)
+expand_fmt_string(const char *fmt, ErrorData *edata)
 {
 	StringInfoData buf;
 	const char *cp;
diff --git a/src/backend/utils/misc/help_config.c b/src/backend/utils/misc/help_config.c
index ed117bef18d..b056a71a3b2 100644
--- a/src/backend/utils/misc/help_config.c
+++ b/src/backend/utils/misc/help_config.c
@@ -25,7 +25,7 @@
  * Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/misc/help_config.c,v 1.4 2003/08/04 00:43:27 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/misc/help_config.c,v 1.5 2003/08/08 21:42:24 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -117,11 +117,11 @@ typedef union
 	struct config_real real;
 	struct config_int integer;
 	struct config_string string;
-}	mixedStruct;
+} mixedStruct;
 
 
 /* function prototypes */
-static bool varMatches(mixedStruct * structToTest);
+static bool varMatches(mixedStruct *structToTest);
 static int	compareMixedStructs(const void *, const void *);
 static mixedStruct **varsToDisplay(int *resultListSize);
 static const char *usageErrMsg(void);
@@ -129,8 +129,8 @@ static void helpMessage(void);
 static void listAllGroups(void);
 static void printGenericHead(struct config_generic structToPrint);
 static void printGenericFoot(struct config_generic structToPrint);
-static void printMixedStruct(mixedStruct * structToPrint);
-static bool displayStruct(mixedStruct * structToDisplay);
+static void printMixedStruct(mixedStruct *structToPrint);
+static bool displayStruct(mixedStruct *structToDisplay);
 
 
 /*
@@ -275,7 +275,7 @@ varsToDisplay(int *resultListSize)
  *	+ It's flag bits are set to GUC_DISALLOW_IN_FILE
  */
 static bool
-displayStruct(mixedStruct * structToDisplay)
+displayStruct(mixedStruct *structToDisplay)
 {
 	if (structToDisplay->generic.flags & (GUC_NO_SHOW_ALL |
 										  GUC_NOT_IN_SAMPLE |
@@ -292,7 +292,7 @@ displayStruct(mixedStruct * structToDisplay)
  * be returned to the user.
  */
 static bool
-varMatches(mixedStruct * structToTest)
+varMatches(mixedStruct *structToTest)
 {
 	bool		matches = false;
 	bool		specificSearch = false; /* This is true if the user
@@ -347,7 +347,7 @@ varMatches(mixedStruct * structToTest)
  * a different format, depending on what the user wants to see.
  */
 static void
-printMixedStruct(mixedStruct * structToPrint)
+printMixedStruct(mixedStruct *structToPrint)
 {
 	printGenericHead(structToPrint->generic);