diff --git a/src/backend/access/gist/gist.c b/src/backend/access/gist/gist.c
index 4b239c76c8..8f23d14d79 100644
--- a/src/backend/access/gist/gist.c
+++ b/src/backend/access/gist/gist.c
@@ -4,13 +4,14 @@
  *	  interface routines for the postgres GiST index access method.
  *
  *
+ * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/gist/gist.c,v 1.76 2001/05/15 14:14:49 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/gist/gist.c,v 1.77 2001/05/30 19:53:39 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
-
 #include "postgres.h"
 
 #include "access/genam.h"
@@ -22,9 +23,9 @@
 #include "executor/executor.h"
 #include "miscadmin.h"
 #include "utils/syscache.h"
-
 #include "access/xlogutils.h"
 
+
 /* result's status */
 #define INSERTED	0x01
 #define SPLITED		0x02
@@ -78,9 +79,9 @@ static void gistcentryinit(GISTSTATE *giststate,
 			   OffsetNumber o, int b, bool l);
 
 #undef GISTDEBUG
+
 #ifdef GISTDEBUG
 static void gist_dumptree(Relation r, int level, BlockNumber blk, OffsetNumber coff);
-
 #endif
 
 /*
diff --git a/src/backend/access/gist/gistget.c b/src/backend/access/gist/gistget.c
index d6fac6f4e2..f922da750d 100644
--- a/src/backend/access/gist/gistget.c
+++ b/src/backend/access/gist/gistget.c
@@ -4,20 +4,20 @@
  *	  fetch tuples from a GiST scan.
  *
  *
+ * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  /usr/local/devel/pglite/cvs/src/backend/access/gisr/gistget.c,v 1.9.1 1996/11/21 01:00:00 vadim Exp
+ *	  $Header: /cvsroot/pgsql/src/backend/access/gist/gistget.c,v 1.27 2001/05/30 19:53:40 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
-
 #include "postgres.h"
 
 #include "access/gist.h"
 #include "executor/execdebug.h"
 
 
-
 static OffsetNumber gistfindnext(IndexScanDesc s, Page p, OffsetNumber n,
 			 ScanDirection dir);
 static RetrieveIndexResult gistscancache(IndexScanDesc s, ScanDirection dir);
diff --git a/src/backend/access/gist/gistscan.c b/src/backend/access/gist/gistscan.c
index ea6114033e..bcabd6caf2 100644
--- a/src/backend/access/gist/gistscan.c
+++ b/src/backend/access/gist/gistscan.c
@@ -1,15 +1,17 @@
 /*-------------------------------------------------------------------------
  *
  * gistscan.c
- *	  routines to manage scans on index relations
+ *	  routines to manage scans on GiST index relations
  *
  *
+ * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
  * IDENTIFICATION
- *	  /usr/local/devel/pglite/cvs/src/backend/access/gist/gistscan.c,v 1.7 1995/06/14 00:10:05 jolly Exp
+ *	  $Header: /cvsroot/pgsql/src/backend/access/gist/gistscan.c,v 1.34 2001/05/30 19:53:40 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
-
 #include "postgres.h"
 
 #include "access/genam.h"
diff --git a/src/backend/access/gist/giststrat.c b/src/backend/access/gist/giststrat.c
index 31ef31dedf..e0bae48a3c 100644
--- a/src/backend/access/gist/giststrat.c
+++ b/src/backend/access/gist/giststrat.c
@@ -3,21 +3,21 @@
  * giststrat.c
  *	  strategy map data for GiSTs.
  *
+ *
  * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- *
  * IDENTIFICATION
- *	  /usr/local/devel/pglite/cvs/src/backend/access/gist/giststrat.c,v 1.4 1995/06/14 00:10:05 jolly Exp
+ *	  $Header: /cvsroot/pgsql/src/backend/access/gist/Attic/giststrat.c,v 1.17 2001/05/30 19:53:40 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
-
 #include "postgres.h"
 
 #include "access/gist.h"
 #include "access/istrat.h"
 
+
 /*
  *	Note:  negate, commute, and negatecommute all assume that operators are
  *		   ordered as follows in the strategy map:
@@ -71,6 +71,12 @@ static StrategyNumber GISTNegateCommute[GISTNStrategies] = {
  * TermData) -- such logic must be encoded in the user's Consistent function.
  */
 
+static StrategyExpression GISTEvaluationExpressions[GISTNStrategies] = {
+	NULL,
+	NULL,
+	NULL
+};
+
 /*
  *	If you were sufficiently attentive to detail, you would go through
  *	the ExpressionData pain above for every one of the strategies
@@ -92,9 +98,10 @@ static StrategyEvaluationData GISTEvaluationData = {
 	(StrategyTransformMap) GISTNegate,	/* how to do (not qual) */
 	(StrategyTransformMap) GISTCommute, /* how to swap operands */
 	(StrategyTransformMap) GISTNegateCommute,	/* how to do both */
-	{NULL}
+	GISTEvaluationExpressions
 };
 
+
 StrategyNumber
 RelationGetGISTStrategy(Relation r,
 						AttrNumber attnum,
diff --git a/src/backend/access/hash/hashstrat.c b/src/backend/access/hash/hashstrat.c
index a423e720c8..fc5df2372d 100644
--- a/src/backend/access/hash/hashstrat.c
+++ b/src/backend/access/hash/hashstrat.c
@@ -1,46 +1,50 @@
 /*-------------------------------------------------------------------------
  *
- * btstrat.c
- *	  Srategy map entries for the btree indexed access method
+ * hashstrat.c
+ *	  Srategy map entries for the hash indexed access method
  *
  * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/hash/Attic/hashstrat.c,v 1.17 2001/01/24 19:42:47 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/hash/Attic/hashstrat.c,v 1.18 2001/05/30 19:53:40 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
-
 #include "postgres.h"
 
+#include "access/hash.h"
+
 
 /*
  *	only one valid strategy for hash tables: equality.
  */
 
 #ifdef NOT_USED
-static StrategyNumber HTNegate[1] = {
+
+static StrategyNumber HTNegate[HTMaxStrategyNumber] = {
 	InvalidStrategy
 };
 
-static StrategyNumber HTCommute[1] = {
+static StrategyNumber HTCommute[HTMaxStrategyNumber] = {
 	HTEqualStrategyNumber
 };
 
-static StrategyNumber HTNegateCommute[1] = {
+static StrategyNumber HTNegateCommute[HTMaxStrategyNumber] = {
 	InvalidStrategy
 };
 
-static StrategyEvaluationData HTEvaluationData = {
-	/* XXX static for simplicity */
+static StrategyExpression HTEvaluationExpressions[HTMaxStrategyNumber] = {
+	NULL
+};
 
+static StrategyEvaluationData HTEvaluationData = {
 	HTMaxStrategyNumber,
 	(StrategyTransformMap) HTNegate,
 	(StrategyTransformMap) HTCommute,
 	(StrategyTransformMap) HTNegateCommute,
-	{NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL}
+	HTEvaluationExpressions
 };
 
 #endif
diff --git a/src/backend/access/index/istrat.c b/src/backend/access/index/istrat.c
index 3b01639206..8cd1284972 100644
--- a/src/backend/access/index/istrat.c
+++ b/src/backend/access/index/istrat.c
@@ -9,11 +9,10 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/index/Attic/istrat.c,v 1.49 2001/03/22 03:59:13 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/index/Attic/istrat.c,v 1.50 2001/05/30 19:53:40 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
-
 #include "postgres.h"
 
 #include "access/heapam.h"
@@ -37,7 +36,6 @@ static bool StrategyOperatorIsValid(StrategyOperator operator,
 						StrategyNumber maxStrategy);
 static bool StrategyTermIsValid(StrategyTerm term,
 					StrategyNumber maxStrategy);
-
 #endif
 
 
@@ -188,19 +186,13 @@ StrategyEvaluationIsValid(StrategyEvaluation evaluation)
 		!StrategyTransformMapIsValid(evaluation->negateTransform) ||
 		!StrategyTransformMapIsValid(evaluation->commuteTransform) ||
 		!StrategyTransformMapIsValid(evaluation->negateCommuteTransform))
-	{
-
 		return false;
-	}
 
 	for (index = 0; index < evaluation->maxStrategy; index += 1)
 	{
 		if (!StrategyExpressionIsValid(evaluation->expression[index],
 									   evaluation->maxStrategy))
-		{
-
 			return false;
-		}
 	}
 	return true;
 }
@@ -268,6 +260,8 @@ StrategyTermEvaluate(StrategyTerm term,
 
 /* ----------------
  *		RelationGetStrategy
+ *
+ * Identify strategy number that describes given procedure, if there is one.
  * ----------------
  */
 StrategyNumber
@@ -286,8 +280,7 @@ RelationGetStrategy(Relation relation,
 	numattrs = RelationGetNumberOfAttributes(relation);
 
 	Assert(relation->rd_rel->relkind == RELKIND_INDEX); /* XXX use accessor */
-	Assert(AttributeNumberIsValid(attributeNumber));
-	Assert((attributeNumber >= 1) && (attributeNumber < 1 + numattrs));
+	Assert((attributeNumber >= 1) && (attributeNumber <= numattrs));
 
 	Assert(StrategyEvaluationIsValid(evaluation));
 	Assert(RegProcedureIsValid(procedure));
@@ -332,7 +325,6 @@ RelationGetStrategy(Relation relation,
 			elog(FATAL, "RelationGetStrategy: impossible case %d", entry->sk_flags);
 	}
 
-
 	if (!StrategyNumberIsInBounds(strategy, evaluation->maxStrategy))
 	{
 		if (!StrategyNumberIsValid(strategy))
@@ -391,7 +383,6 @@ RelationInvokeStrategy(Relation relation,
 	newStrategy = evaluation->negateTransform->strategy[strategy - 1];
 	if (newStrategy != strategy && StrategyNumberIsValid(newStrategy))
 	{
-
 		entry = StrategyMapGetScanKeyEntry(strategyMap, newStrategy);
 
 		if (RegProcedureIsValid(entry->sk_procedure))
@@ -406,7 +397,6 @@ RelationInvokeStrategy(Relation relation,
 	newStrategy = evaluation->commuteTransform->strategy[strategy - 1];
 	if (newStrategy != strategy && StrategyNumberIsValid(newStrategy))
 	{
-
 		entry = StrategyMapGetScanKeyEntry(strategyMap, newStrategy);
 
 		if (RegProcedureIsValid(entry->sk_procedure))
@@ -421,7 +411,6 @@ RelationInvokeStrategy(Relation relation,
 	newStrategy = evaluation->negateCommuteTransform->strategy[strategy - 1];
 	if (newStrategy != strategy && StrategyNumberIsValid(newStrategy))
 	{
-
 		entry = StrategyMapGetScanKeyEntry(strategyMap, newStrategy);
 
 		if (RegProcedureIsValid(entry->sk_procedure))
@@ -463,8 +452,6 @@ RelationInvokeStrategy(Relation relation,
 
 	/* not reached, just to make compiler happy */
 	return FALSE;
-
-
 }
 
 #endif
@@ -614,16 +601,16 @@ IndexSupportInitialize(IndexStrategy indexStrategy,
 							   ObjectIdGetDatum(accessMethodObjectId));
 
 		ScanKeyEntryInitialize(&entry[1], 0, Anum_pg_amproc_amopclaid,
-							   F_OIDEQ, 0);
+							   F_OIDEQ,
+							   InvalidOid);	/* will set below */
 
 		relation = heap_openr(AccessMethodProcedureRelationName,
 							  AccessShareLock);
 
 		for (attNumber = 1; attNumber <= maxAttributeNumber; attNumber++)
 		{
-			int16		support;
-			Form_pg_amproc aform;
 			RegProcedure *loc;
+			StrategyNumber support;
 
 			loc = &indexSupport[((attNumber - 1) * maxSupportNumber)];
 
@@ -637,8 +624,12 @@ IndexSupportInitialize(IndexStrategy indexStrategy,
 
 			while (HeapTupleIsValid(tuple = heap_getnext(scan, 0)))
 			{
+				Form_pg_amproc aform;
+
 				aform = (Form_pg_amproc) GETSTRUCT(tuple);
-				loc[(aform->amprocnum - 1)] = aform->amproc;
+				support = aform->amprocnum;
+				Assert(support > 0 && support <= maxSupportNumber);
+				loc[support - 1] = aform->amproc;
 			}
 
 			heap_endscan(scan);
@@ -708,7 +699,6 @@ IndexStrategyDisplay(IndexStrategy indexStrategy,
 	for (attributeNumber = 1; attributeNumber <= numberOfAttributes;
 		 attributeNumber += 1)
 	{
-
 		strategyMap = IndexStrategyGetStrategyMap(indexStrategy,
 												  numberOfStrategies,
 												  attributeNumber);
@@ -717,7 +707,6 @@ IndexStrategyDisplay(IndexStrategy indexStrategy,
 			 strategyNumber <= AMStrategies(numberOfStrategies);
 			 strategyNumber += 1)
 		{
-
 			printf(":att %d\t:str %d\t:opr 0x%x(%d)\n",
 				   attributeNumber, strategyNumber,
 				   strategyMap->entry[strategyNumber - 1].sk_procedure,
diff --git a/src/backend/access/nbtree/nbtstrat.c b/src/backend/access/nbtree/nbtstrat.c
index ba4850dc78..4045496979 100644
--- a/src/backend/access/nbtree/nbtstrat.c
+++ b/src/backend/access/nbtree/nbtstrat.c
@@ -1,14 +1,14 @@
 /*-------------------------------------------------------------------------
  *
- * btstrat.c
- *	  Srategy map entries for the btree indexed access method
+ * nbtstrat.c
+ *	  Strategy map entries for the btree indexed access method
  *
  * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/nbtree/Attic/nbtstrat.c,v 1.13 2001/01/24 19:42:49 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/nbtree/Attic/nbtstrat.c,v 1.14 2001/05/30 19:53:40 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -23,7 +23,7 @@
  *		StrategyNegate, StrategyCommute, and StrategyNegateCommute
  *		assume <, <=, ==, >=, > ordering.
  */
-static StrategyNumber BTNegate[5] = {
+static StrategyNumber BTNegate[BTMaxStrategyNumber] = {
 	BTGreaterEqualStrategyNumber,
 	BTGreaterStrategyNumber,
 	InvalidStrategy,
@@ -31,7 +31,7 @@ static StrategyNumber BTNegate[5] = {
 	BTLessEqualStrategyNumber
 };
 
-static StrategyNumber BTCommute[5] = {
+static StrategyNumber BTCommute[BTMaxStrategyNumber] = {
 	BTGreaterStrategyNumber,
 	BTGreaterEqualStrategyNumber,
 	InvalidStrategy,
@@ -39,7 +39,7 @@ static StrategyNumber BTCommute[5] = {
 	BTLessStrategyNumber
 };
 
-static StrategyNumber BTNegateCommute[5] = {
+static StrategyNumber BTNegateCommute[BTMaxStrategyNumber] = {
 	BTLessEqualStrategyNumber,
 	BTLessStrategyNumber,
 	InvalidStrategy,
@@ -87,16 +87,20 @@ static StrategyTerm BTEqualExpressionData[] = {
 	NULL
 };
 
+static StrategyExpression BTEvaluationExpressions[BTMaxStrategyNumber] = {
+	NULL,
+	NULL,
+	(StrategyExpression) BTEqualExpressionData,
+	NULL,
+	NULL
+};
+
 static StrategyEvaluationData BTEvaluationData = {
-	/* XXX static for simplicity */
-
 	BTMaxStrategyNumber,
-	(StrategyTransformMap) BTNegate,	/* XXX */
-	(StrategyTransformMap) BTCommute,	/* XXX */
-	(StrategyTransformMap) BTNegateCommute,		/* XXX */
-
-	{NULL, NULL, (StrategyExpression) BTEqualExpressionData, NULL, NULL,
-	NULL, NULL, NULL, NULL, NULL, NULL, NULL}
+	(StrategyTransformMap) BTNegate,
+	(StrategyTransformMap) BTCommute,
+	(StrategyTransformMap) BTNegateCommute,
+	BTEvaluationExpressions
 };
 
 /* ----------------------------------------------------------------
diff --git a/src/backend/access/rtree/rtstrat.c b/src/backend/access/rtree/rtstrat.c
index e176b064f9..74ee6a39a4 100644
--- a/src/backend/access/rtree/rtstrat.c
+++ b/src/backend/access/rtree/rtstrat.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtstrat.c,v 1.16 2001/01/24 19:42:50 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtstrat.c,v 1.17 2001/05/30 19:53:40 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -96,7 +96,7 @@ static StrategyNumber RTNegateCommute[RTNStrategies] = {
  *	Early in the development of the POSTGRES access methods, it was believed
  *	that writing functions was harder than writing arrays.	This is wrong;
  *	TermData is hard to understand and hard to get right.  In general, when
- *	someone populates a new operator class, the populate it completely.  If
+ *	someone populates a new operator class, they populate it completely.  If
  *	Mike Hirohama had forced Cimarron Taylor to populate the strategy map
  *	for btree int2_ops completely in 1988, you wouldn't have to deal with
  *	all this now.  Too bad for you.
@@ -157,24 +157,23 @@ static StrategyTerm RTEqualExpressionData[] = {
  *	in the access methods just isn't worth the trouble, though.
  */
 
+static StrategyExpression RTEvaluationExpressions[RTNStrategies] = {
+	NULL,						/* express left */
+	NULL,						/* express overleft */
+	NULL,						/* express overlap */
+	NULL,						/* express overright */
+	NULL,						/* express right */
+	(StrategyExpression) RTEqualExpressionData,	/* express same */
+	NULL,						/* express contains */
+	NULL						/* express contained-by */
+};
+
 static StrategyEvaluationData RTEvaluationData = {
 	RTNStrategies,				/* # of strategies */
 	(StrategyTransformMap) RTNegate,	/* how to do (not qual) */
 	(StrategyTransformMap) RTCommute,	/* how to swap operands */
 	(StrategyTransformMap) RTNegateCommute,		/* how to do both */
-	{
-		NULL,					/* express left */
-		NULL,					/* express overleft */
-		NULL,					/* express over */
-		NULL,					/* express overright */
-		NULL,					/* express right */
-		(StrategyExpression) RTEqualExpressionData,		/* express same */
-		NULL,					/* express contains */
-		NULL,					/* express contained-by */
-		NULL,
-		NULL,
-		NULL
-	}
+	RTEvaluationExpressions
 };
 
 /*
diff --git a/src/include/access/gist.h b/src/include/access/gist.h
index f3498ffd2b..694a628c4a 100644
--- a/src/include/access/gist.h
+++ b/src/include/access/gist.h
@@ -4,8 +4,10 @@
  *	  common declarations for the GiST access method code.
  *
  *
+ * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
  *
- *
+ * $Id: gist.h,v 1.27 2001/05/30 19:53:39 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -18,22 +20,15 @@
 #include "access/xlog.h"
 
 /*
-** You can have as many strategies as you please in GiSTs, as
-** long as your consistent method can handle them
-**
-** But strat.h->StrategyEvaluationData->StrategyExpression	expression[12]
-** - so 12 is real max # of strategies, or StrategyEvaluationIsValid
-** crashes backend...			- vadim 05/21/97
-
+ * You can have as many strategies as you please in GiSTs,
+ * as long as your consistent method can handle them.
+ * The system doesn't really care what they are.
+ */
 #define GISTNStrategies					100
 
-*/
-#define GISTNStrategies					12
-
 /*
-** Helper routines
-*/
-#define GISTNProcs						8
+ * amproc indexes for GiST indexes.
+ */
 #define GIST_CONSISTENT_PROC			1
 #define GIST_UNION_PROC					2
 #define GIST_COMPRESS_PROC				3
@@ -41,8 +36,12 @@
 #define GIST_PENALTY_PROC				5
 #define GIST_PICKSPLIT_PROC				6
 #define GIST_EQUAL_PROC					7
-#define GIST_INFO_PROC					8
+#define GISTNProcs						7
 
+
+/*
+ * Page opaque data in a GiST index page.
+ */
 #define F_LEAF			(1 << 0)
 
 typedef struct GISTPageOpaqueData
@@ -57,7 +56,6 @@ typedef GISTPageOpaqueData *GISTPageOpaque;
 /*
  *	When we descend a tree, we keep a stack of parent pointers.
  */
-
 typedef struct GISTSTACK
 {
 	struct GISTSTACK *gs_parent;
@@ -80,10 +78,9 @@ typedef struct GISTSTATE
 
 
 /*
-**	When we're doing a scan, we need to keep track of the parent stack
-**	for the marked and current items.
-*/
-
+ *	When we're doing a scan, we need to keep track of the parent stack
+ *	for the marked and current items.
+ */
 typedef struct GISTScanOpaqueData
 {
 	struct GISTSTACK *s_stack;
@@ -95,12 +92,11 @@ typedef struct GISTScanOpaqueData
 typedef GISTScanOpaqueData *GISTScanOpaque;
 
 /*
-**	When we're doing a scan and updating a tree at the same time, the
-**	updates may affect the scan.  We use the flags entry of the scan's
-**	opaque space to record our actual position in response to updates
-**	that we can't handle simply by adjusting pointers.
-*/
-
+ *	When we're doing a scan and updating a tree at the same time, the
+ *	updates may affect the scan.  We use the flags entry of the scan's
+ *	opaque space to record our actual position in response to updates
+ *	that we can't handle simply by adjusting pointers.
+ */
 #define GS_CURBEFORE	((uint16) (1 << 0))
 #define GS_MRKBEFORE	((uint16) (1 << 1))
 
@@ -108,20 +104,19 @@ typedef GISTScanOpaqueData *GISTScanOpaque;
 #define GISTP_ROOT				0
 
 /*
-**	When we update a relation on which we're doing a scan, we need to
-**	check the scan and fix it if the update affected any of the pages it
-**	touches.  Otherwise, we can miss records that we should see.  The only
-**	times we need to do this are for deletions and splits.	See the code in
-**	gistscan.c for how the scan is fixed. These two constants tell us what sort
-**	of operation changed the index.
-*/
-
+ *	When we update a relation on which we're doing a scan, we need to
+ *	check the scan and fix it if the update affected any of the pages it
+ *	touches.  Otherwise, we can miss records that we should see.  The only
+ *	times we need to do this are for deletions and splits.	See the code in
+ *	gistscan.c for how the scan is fixed. These two constants tell us what sort
+ *	of operation changed the index.
+ */
 #define GISTOP_DEL		0
 #define GISTOP_SPLIT	1
 
 /*
-** This is the Split Vector to be returned by the PickSplit method.
-*/
+ * This is the Split Vector to be returned by the PickSplit method.
+ */
 typedef struct GIST_SPLITVEC
 {
 	OffsetNumber *spl_left;		/* array of entries that go left */
@@ -133,11 +128,11 @@ typedef struct GIST_SPLITVEC
 } GIST_SPLITVEC;
 
 /*
-** An entry on a GiST node.  Contains the key (pred), as well as
-** its own location (rel,page,offset) which can supply the matching
-** pointer.  The size of the pred is in bytes, and leafkey is a flag to
-** tell us if the entry is in a leaf node.
-*/
+ * An entry on a GiST node.  Contains the key (pred), as well as
+ * its own location (rel,page,offset) which can supply the matching
+ * pointer.  The size of the pred is in bytes, and leafkey is a flag to
+ * tell us if the entry is in a leaf node.
+ */
 typedef struct GISTENTRY
 {
 	char	   *pred;
@@ -149,10 +144,10 @@ typedef struct GISTENTRY
 } GISTENTRY;
 
 /*
-** macro to initialize a GISTENTRY
-*/
+ * macro to initialize a GISTENTRY
+ */
 #define gistentryinit(e, pr, r, pg, o, b, l)\
-   do {(e).pred = pr; (e).rel = r; (e).page = pg; (e).offset = o; (e).bytes = b; (e).leafkey = l;} while (0)
+   do {(e).pred = (pr); (e).rel = (r); (e).page = (pg); (e).offset = (o); (e).bytes = (b); (e).leafkey = (l);} while (0)
 
 /* defined in gist.c */
 #define TRLOWER(tr) (((tr)->bytes))
@@ -160,12 +155,11 @@ typedef struct GISTENTRY
 
 typedef struct txtrange
 {
-
+	int32		vl_len;
 	/*
 	 * flag: NINF means that lower is negative infinity; PINF means that *
 	 * upper is positive infinity.	0 means that both are numbers.
 	 */
-	int32		vl_len;
 	int32		flag;
 	char		bytes[2];
 } TXTRANGE;
@@ -174,7 +168,6 @@ typedef struct intrange
 {
 	int			lower;
 	int			upper;
-
 	/*
 	 * flag: NINF means that lower is negative infinity; PINF means that *
 	 * upper is positive infinity.	0 means that both are numbers.
@@ -190,7 +183,8 @@ extern void gistfreestack(GISTSTACK *s);
 extern void initGISTstate(GISTSTATE *giststate, Relation index);
 extern void gistdentryinit(GISTSTATE *giststate, GISTENTRY *e, char *pr,
 			   Relation r, Page pg, OffsetNumber o, int b, bool l);
-extern StrategyNumber RelationGetGISTStrategy(Relation, AttrNumber, RegProcedure);
+extern StrategyNumber RelationGetGISTStrategy(Relation, AttrNumber,
+											  RegProcedure);
 
 extern void gist_redo(XLogRecPtr lsn, XLogRecord *record);
 extern void gist_undo(XLogRecPtr lsn, XLogRecord *record);
diff --git a/src/include/access/gistscan.h b/src/include/access/gistscan.h
index 98498965f7..d4f9403c10 100644
--- a/src/include/access/gistscan.h
+++ b/src/include/access/gistscan.h
@@ -1,11 +1,13 @@
 /*-------------------------------------------------------------------------
  *
  * gistscan.h
- *	  routines defined in access/gisr/gistscan.c
+ *	  routines defined in access/gist/gistscan.c
  *
  *
+ * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
  *
- * rtscan.h,v 1.2 1995/06/14 00:06:58 jolly Exp
+ * $Id: gistscan.h,v 1.15 2001/05/30 19:53:39 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
diff --git a/src/include/access/rtree.h b/src/include/access/rtree.h
index 4be5c83d53..210e873981 100644
--- a/src/include/access/rtree.h
+++ b/src/include/access/rtree.h
@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: rtree.h,v 1.22 2001/03/22 04:00:30 momjian Exp $
+ * $Id: rtree.h,v 1.23 2001/05/30 19:53:39 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -107,7 +107,7 @@ extern void freestack(RTSTACK *s);
 
 /*
  *		RTree code.
- *		Defined in access/index-rtree/
+ *		Defined in access/rtree/
  */
 extern Datum rtinsert(PG_FUNCTION_ARGS);
 extern Datum rtdelete(PG_FUNCTION_ARGS);
@@ -130,7 +130,7 @@ extern void rtree_desc(char *buf, uint8 xl_info, char *rec);
 extern void rtadjscans(Relation r, int op, BlockNumber blkno,
 		   OffsetNumber offnum);
 
-/* rtstrat.h */
+/* rtstrat.c */
 extern RegProcedure RTMapOperator(Relation r, AttrNumber attnum,
 			  RegProcedure proc);
 
diff --git a/src/include/access/strat.h b/src/include/access/strat.h
index b35ecca590..ffe63926cf 100644
--- a/src/include/access/strat.h
+++ b/src/include/access/strat.h
@@ -8,7 +8,7 @@
  * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: strat.h,v 1.21 2001/03/22 06:16:20 momjian Exp $
+ * $Id: strat.h,v 1.22 2001/05/30 19:53:39 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -17,6 +17,7 @@
 
 #include "access/skey.h"
 
+
 typedef uint16 StrategyNumber;
 
 #define InvalidStrategy 0
@@ -24,29 +25,14 @@ typedef uint16 StrategyNumber;
 typedef struct StrategyTransformMapData
 {
 	StrategyNumber strategy[1]; /* VARIABLE LENGTH ARRAY */
-} StrategyTransformMapData;		/* VARIABLE LENGTH
-
-								 *
-								 *
-								 *
-								 *
-								 *
-								 *
-								 *
-								 *
-								 *
-								 *
-								 *
-								 *
-								 *
-								 * STRUCTURE */
+} StrategyTransformMapData;		/* VARIABLE LENGTH STRUCTURE */
 
 typedef StrategyTransformMapData *StrategyTransformMap;
 
 typedef struct StrategyOperatorData
 {
 	StrategyNumber strategy;
-	bits16		flags;			/* scan qualification flags h/skey.h */
+	bits16		flags;			/* scan qualification flags, see skey.h */
 } StrategyOperatorData;
 
 typedef StrategyOperatorData *StrategyOperator;
@@ -54,7 +40,7 @@ typedef StrategyOperatorData *StrategyOperator;
 typedef struct StrategyTermData
 {								/* conjunctive term */
 	uint16		degree;
-	StrategyOperatorData operatorData[1];		/* VARIABLE LENGTH */
+	StrategyOperatorData operatorData[1];	/* VARIABLE LENGTH ARRAY */
 } StrategyTermData;				/* VARIABLE LENGTH STRUCTURE */
 
 typedef StrategyTermData *StrategyTerm;
@@ -69,11 +55,12 @@ typedef StrategyExpressionData *StrategyExpression;
 typedef struct StrategyEvaluationData
 {
 	StrategyNumber maxStrategy;
+	/* each of these must point to an array of maxStrategy elements: */
 	StrategyTransformMap negateTransform;
 	StrategyTransformMap commuteTransform;
 	StrategyTransformMap negateCommuteTransform;
-	StrategyExpression expression[12];	/* XXX VARIABLE LENGTH */
-} StrategyEvaluationData;		/* VARIABLE LENGTH STRUCTURE */
+	StrategyExpression *expression;
+} StrategyEvaluationData;
 
 typedef StrategyEvaluationData *StrategyEvaluation;