pgindent run. Make it all clean.

555 files changed, 32742 insertions, 28338 deletions

diff --git a/contrib/cube/buffer.c b/contrib/cube/buffer.c
index 0bcc2d19b5..bab7ae303c 100644
--- a/contrib/cube/buffer.c
+++ b/contrib/cube/buffer.c
@@ -4,76 +4,81 @@
 
 #include "utils/elog.h"
 
-static char *       PARSE_BUFFER;
-static char *       PARSE_BUFFER_PTR; 
-static unsigned int PARSE_BUFFER_SIZE; 
+static char *PARSE_BUFFER;
+static char *PARSE_BUFFER_PTR;
+static unsigned int PARSE_BUFFER_SIZE;
 static unsigned int SCANNER_POS;
 
-void         set_parse_buffer( char* s );
-void         reset_parse_buffer( void );
-int          read_parse_buffer( void );
-char *       parse_buffer( void );
-char *       parse_buffer_ptr( void );
-unsigned int parse_buffer_curr_char( void );
-unsigned int parse_buffer_size( void );
-unsigned int parse_buffer_pos( void );
+void		set_parse_buffer(char *s);
+void		reset_parse_buffer(void);
+int			read_parse_buffer(void);
+char	   *parse_buffer(void);
+char	   *parse_buffer_ptr(void);
+unsigned int parse_buffer_curr_char(void);
+unsigned int parse_buffer_size(void);
+unsigned int parse_buffer_pos(void);
 
-extern void cube_flush_scanner_buffer(void); /* defined in cubescan.l */
+extern void cube_flush_scanner_buffer(void);	/* defined in cubescan.l */
 
-void set_parse_buffer( char* s )
+void
+set_parse_buffer(char *s)
 {
-  PARSE_BUFFER = s;
-  PARSE_BUFFER_SIZE = strlen(s);
-  if ( PARSE_BUFFER_SIZE == 0 ) {
-    elog(ERROR, "cube_in: can't parse an empty string");
-  }
-  PARSE_BUFFER_PTR = PARSE_BUFFER;
-  SCANNER_POS = 0;
+	PARSE_BUFFER = s;
+	PARSE_BUFFER_SIZE = strlen(s);
+	if (PARSE_BUFFER_SIZE == 0)
+		elog(ERROR, "cube_in: can't parse an empty string");
+	PARSE_BUFFER_PTR = PARSE_BUFFER;
+	SCANNER_POS = 0;
 }
 
-void reset_parse_buffer( void )
+void
+reset_parse_buffer(void)
 {
-  PARSE_BUFFER_PTR = PARSE_BUFFER;
-  SCANNER_POS = 0;
-  cube_flush_scanner_buffer();
+	PARSE_BUFFER_PTR = PARSE_BUFFER;
+	SCANNER_POS = 0;
+	cube_flush_scanner_buffer();
 }
 
-int read_parse_buffer( void )
+int
+read_parse_buffer(void)
 {
-  int c;
-  /*
-  c = *PARSE_BUFFER_PTR++;
-  SCANNER_POS++;
-  */
-  c = PARSE_BUFFER[SCANNER_POS];
-  if(SCANNER_POS < PARSE_BUFFER_SIZE)
-    SCANNER_POS++;
-  return c;
+	int			c;
+
+	/*
+	 * c = *PARSE_BUFFER_PTR++; SCANNER_POS++;
+	 */
+	c = PARSE_BUFFER[SCANNER_POS];
+	if (SCANNER_POS < PARSE_BUFFER_SIZE)
+		SCANNER_POS++;
+	return c;
 }
 
-char * parse_buffer( void )
+char *
+parse_buffer(void)
 {
-  return PARSE_BUFFER;
+	return PARSE_BUFFER;
 }
 
-unsigned int parse_buffer_curr_char( void )
+unsigned int
+parse_buffer_curr_char(void)
 {
-  return PARSE_BUFFER[SCANNER_POS];
+	return PARSE_BUFFER[SCANNER_POS];
 }
 
-char * parse_buffer_ptr( void )
+char *
+parse_buffer_ptr(void)
 {
-  return PARSE_BUFFER_PTR;
+	return PARSE_BUFFER_PTR;
 }
 
-unsigned int parse_buffer_pos( void )
+unsigned int
+parse_buffer_pos(void)
 {
-  return SCANNER_POS;
+	return SCANNER_POS;
 }
 
-unsigned int parse_buffer_size( void )
+unsigned int
+parse_buffer_size(void)
 {
-  return PARSE_BUFFER_SIZE;
+	return PARSE_BUFFER_SIZE;
 }
-
-
diff --git a/contrib/cube/buffer.h b/contrib/cube/buffer.h
index fd41a7b69b..eef9124dac 100644
--- a/contrib/cube/buffer.h
+++ b/contrib/cube/buffer.h
@@ -1,8 +1,8 @@
-extern void set_parse_buffer( char* s );
-extern void reset_parse_buffer( void );
-extern int read_parse_buffer( void );
-extern char * parse_buffer( void );
-extern char * parse_buffer_ptr( void );
-extern unsigned int parse_buffer_curr_char( void );
-extern unsigned int parse_buffer_pos( void );
-extern unsigned int parse_buffer_size( void );
+extern void set_parse_buffer(char *s);
+extern void reset_parse_buffer(void);
+extern int	read_parse_buffer(void);
+extern char *parse_buffer(void);
+extern char *parse_buffer_ptr(void);
+extern unsigned int parse_buffer_curr_char(void);
+extern unsigned int parse_buffer_pos(void);
+extern unsigned int parse_buffer_size(void);
diff --git a/contrib/cube/cube.c b/contrib/cube/cube.c
index 35ac34f0b0..4d6169a480 100644
--- a/contrib/cube/cube.c
+++ b/contrib/cube/cube.c
@@ -16,67 +16,67 @@
 
 #include "cubedata.h"
 
-#define max(a,b)        ((a) >  (b) ? (a) : (b))
-#define min(a,b)        ((a) <= (b) ? (a) : (b))
-#define abs(a)          ((a) <  (0) ? (-a) : (a))
+#define max(a,b)		((a) >	(b) ? (a) : (b))
+#define min(a,b)		((a) <= (b) ? (a) : (b))
+#define abs(a)			((a) <	(0) ? (-a) : (a))
 
-extern void  set_parse_buffer(char *str);
-extern int   cube_yyparse();
+extern void set_parse_buffer(char *str);
+extern int	cube_yyparse();
 
 /*
 ** Input/Output routines
 */
-NDBOX *      cube_in(char *str);
-char *       cube_out(NDBOX *cube);
+NDBOX	   *cube_in(char *str);
+char	   *cube_out(NDBOX * cube);
 
 
-/* 
+/*
 ** GiST support methods
 */
-bool             g_cube_consistent(GISTENTRY *entry, NDBOX *query, StrategyNumber strategy); 
-GISTENTRY *      g_cube_compress(GISTENTRY *entry);
-GISTENTRY *      g_cube_decompress(GISTENTRY *entry);
-float *          g_cube_penalty(GISTENTRY *origentry, GISTENTRY *newentry, float *result);
-GIST_SPLITVEC *  g_cube_picksplit(bytea *entryvec, GIST_SPLITVEC *v);
-bool             g_cube_leaf_consistent(NDBOX *key, NDBOX *query, StrategyNumber strategy);
-bool             g_cube_internal_consistent(NDBOX *key, NDBOX *query, StrategyNumber strategy);
-NDBOX *          g_cube_union(bytea *entryvec, int *sizep);
-NDBOX *          g_cube_binary_union(NDBOX *r1, NDBOX *r2, int *sizep);
-bool *           g_cube_same(NDBOX *b1, NDBOX *b2, bool *result);
+bool		g_cube_consistent(GISTENTRY *entry, NDBOX * query, StrategyNumber strategy);
+GISTENTRY  *g_cube_compress(GISTENTRY *entry);
+GISTENTRY  *g_cube_decompress(GISTENTRY *entry);
+float	   *g_cube_penalty(GISTENTRY *origentry, GISTENTRY *newentry, float *result);
+GIST_SPLITVEC *g_cube_picksplit(bytea *entryvec, GIST_SPLITVEC *v);
+bool		g_cube_leaf_consistent(NDBOX * key, NDBOX * query, StrategyNumber strategy);
+bool		g_cube_internal_consistent(NDBOX * key, NDBOX * query, StrategyNumber strategy);
+NDBOX	   *g_cube_union(bytea *entryvec, int *sizep);
+NDBOX	   *g_cube_binary_union(NDBOX * r1, NDBOX * r2, int *sizep);
+bool	   *g_cube_same(NDBOX * b1, NDBOX * b2, bool *result);
 
 /*
 ** R-tree suport functions
 */
-bool         cube_same(NDBOX *a, NDBOX *b);
-bool         cube_different(NDBOX *a, NDBOX *b);
-bool         cube_contains(NDBOX *a, NDBOX *b);
-bool         cube_contained (NDBOX *a, NDBOX *b);
-bool         cube_overlap(NDBOX *a, NDBOX *b);
-NDBOX *      cube_union(NDBOX *a, NDBOX *b);
-NDBOX *      cube_inter(NDBOX *a, NDBOX *b);
-float *      cube_size(NDBOX *a);
-void         rt_cube_size(NDBOX *a, float *sz);
+bool		cube_same(NDBOX * a, NDBOX * b);
+bool		cube_different(NDBOX * a, NDBOX * b);
+bool		cube_contains(NDBOX * a, NDBOX * b);
+bool		cube_contained(NDBOX * a, NDBOX * b);
+bool		cube_overlap(NDBOX * a, NDBOX * b);
+NDBOX	   *cube_union(NDBOX * a, NDBOX * b);
+NDBOX	   *cube_inter(NDBOX * a, NDBOX * b);
+float	   *cube_size(NDBOX * a);
+void		rt_cube_size(NDBOX * a, float *sz);
 
 /*
 ** These make no sense for this type, but R-tree wants them
 */
-bool         cube_over_left(NDBOX *a, NDBOX *b);
-bool         cube_over_right(NDBOX *a, NDBOX *b);
-bool         cube_left(NDBOX *a, NDBOX *b);
-bool         cube_right(NDBOX *a, NDBOX *b);
+bool		cube_over_left(NDBOX * a, NDBOX * b);
+bool		cube_over_right(NDBOX * a, NDBOX * b);
+bool		cube_left(NDBOX * a, NDBOX * b);
+bool		cube_right(NDBOX * a, NDBOX * b);
 
 /*
 ** miscellaneous
 */
-bool         cube_lt(NDBOX *a, NDBOX *b);
-bool         cube_gt(NDBOX *a, NDBOX *b);
-float *      cube_distance(NDBOX *a, NDBOX *b);
+bool		cube_lt(NDBOX * a, NDBOX * b);
+bool		cube_gt(NDBOX * a, NDBOX * b);
+float	   *cube_distance(NDBOX * a, NDBOX * b);
 
-/* 
+/*
 ** Auxiliary funxtions
 */
-static       float distance_1D(float a1, float a2, float b1, float b2);
-static       NDBOX *swap_corners (NDBOX *a);
+static float distance_1D(float a1, float a2, float b1, float b2);
+static NDBOX *swap_corners(NDBOX * a);
 
 
 /*****************************************************************************
@@ -88,68 +88,71 @@ static       NDBOX *swap_corners (NDBOX *a);
 NDBOX *
 cube_in(char *str)
 {
-  void * result;
+	void	   *result;
 
-  set_parse_buffer( str );
+	set_parse_buffer(str);
 
-  if ( cube_yyparse(&result) != 0 ) {
-    return NULL;
-  } 
+	if (cube_yyparse(&result) != 0)
+		return NULL;
 
-  return ( (NDBOX *)result );
+	return ((NDBOX *) result);
 }
 
 /*
  * You might have noticed a slight inconsistency between the following
  * declaration and the SQL definition:
- *     CREATE FUNCTION cube_out(opaque) RETURNS opaque ...
+ *	   CREATE FUNCTION cube_out(opaque) RETURNS opaque ...
  * The reason is that the argument pass into cube_out is really just a
  * pointer. POSTGRES thinks all output functions are:
- *     char *out_func(char *);
+ *	   char *out_func(char *);
  */
 char *
-cube_out(NDBOX *cube)
+cube_out(NDBOX * cube)
 {
-    char *result;
-    char *p;
-    int equal = 1;
-    int dim = cube->dim;
-    int i;
-
-    if (cube == NULL)
-	return(NULL);
-
-    p = result = (char *) palloc(100);
-
-    /* while printing the first (LL) corner, check if it is equal
-    to the scond one */
-    p += sprintf(p, "(");
-    for ( i=0; i < dim; i++ ) {
-      p += sprintf(p, "%g", cube->x[i]);
-      p += sprintf(p, ", ");
-      if ( cube->x[i] != cube->x[i+dim] ) {
-	equal = 0;
-      }
-    }
-    p -= 2; /* get rid of the last ", " */
-    p += sprintf(p, ")");
-
-    if ( !equal ) {
-    p += sprintf(p, ",(");
-      for ( i=dim; i < dim * 2; i++ ) {
-	p += sprintf(p, "%g", cube->x[i]);
-	p += sprintf(p, ", ");
-      }
-      p -= 2; 
-      p += sprintf(p, ")");
-    }
-      
-    return(result);
+	char	   *result;
+	char	   *p;
+	int			equal = 1;
+	int			dim = cube->dim;
+	int			i;
+
+	if (cube == NULL)
+		return (NULL);
+
+	p = result = (char *) palloc(100);
+
+	/*
+	 * while printing the first (LL) corner, check if it is equal to the
+	 * scond one
+	 */
+	p += sprintf(p, "(");
+	for (i = 0; i < dim; i++)
+	{
+		p += sprintf(p, "%g", cube->x[i]);
+		p += sprintf(p, ", ");
+		if (cube->x[i] != cube->x[i + dim])
+			equal = 0;
+	}
+	p -= 2;						/* get rid of the last ", " */
+	p += sprintf(p, ")");
+
+	if (!equal)
+	{
+		p += sprintf(p, ",(");
+		for (i = dim; i < dim * 2; i++)
+		{
+			p += sprintf(p, "%g", cube->x[i]);
+			p += sprintf(p, ", ");
+		}
+		p -= 2;
+		p += sprintf(p, ")");
+	}
+
+	return (result);
 }
 
 
 /*****************************************************************************
- *                         GiST functions
+ *						   GiST functions
  *****************************************************************************/
 
 /*
@@ -158,19 +161,20 @@ cube_out(NDBOX *cube)
 ** the predicate x op query == FALSE, where op is the oper
 ** corresponding to strategy in the pg_amop table.
 */
-bool 
+bool
 g_cube_consistent(GISTENTRY *entry,
-	       NDBOX *query,
-	       StrategyNumber strategy)
+				  NDBOX * query,
+				  StrategyNumber strategy)
 {
-    /*
-    ** if entry is not leaf, use g_cube_internal_consistent,
-    ** else use g_cube_leaf_consistent
-    */
-    if (GIST_LEAF(entry))
-      return(g_cube_leaf_consistent((NDBOX *)(entry->pred), query, strategy));
-    else
-      return(g_cube_internal_consistent((NDBOX *)(entry->pred), query, strategy));
+
+	/*
+	 * * if entry is not leaf, use g_cube_internal_consistent, * else use
+	 * g_cube_leaf_consistent
+	 */
+	if (GIST_LEAF(entry))
+		return (g_cube_leaf_consistent((NDBOX *) (entry->pred), query, strategy));
+	else
+		return (g_cube_internal_consistent((NDBOX *) (entry->pred), query, strategy));
 }
 
 
@@ -181,48 +185,55 @@ g_cube_consistent(GISTENTRY *entry,
 NDBOX *
 g_cube_union(bytea *entryvec, int *sizep)
 {
-    int numranges, i;
-    NDBOX *out = (NDBOX *)NULL;
-    NDBOX *tmp;
-
-    /*
-    fprintf(stderr, "union\n");
-    */
-    numranges = (VARSIZE(entryvec) - VARHDRSZ)/sizeof(GISTENTRY); 
-    tmp = (NDBOX *)(((GISTENTRY *)(VARDATA(entryvec)))[0]).pred;
-    /*
-    *sizep = sizeof(NDBOX); -- NDBOX has variable size
-    */
-    *sizep = tmp->size;
-
-    for (i = 1; i < numranges; i++) {
-      out = g_cube_binary_union(tmp, (NDBOX *)
-				 (((GISTENTRY *)(VARDATA(entryvec)))[i]).pred,
-				 sizep);
-      /*
-	fprintf(stderr, "\t%s ^ %s -> %s\n", cube_out(tmp), cube_out((NDBOX *)(((GISTENTRY *)(VARDATA(entryvec)))[i]).pred), cube_out(out));
-      */
-      if (i > 1) pfree(tmp);
-      tmp = out;
-    }
-
-    return(out);
+	int			numranges,
+				i;
+	NDBOX	   *out = (NDBOX *) NULL;
+	NDBOX	   *tmp;
+
+	/*
+	 * fprintf(stderr, "union\n");
+	 */
+	numranges = (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY);
+	tmp = (NDBOX *) (((GISTENTRY *) (VARDATA(entryvec)))[0]).pred;
+
+	/*
+	 * sizep = sizeof(NDBOX); -- NDBOX has variable size
+	 */
+	*sizep = tmp->size;
+
+	for (i = 1; i < numranges; i++)
+	{
+		out = g_cube_binary_union(tmp, (NDBOX *)
+						   (((GISTENTRY *) (VARDATA(entryvec)))[i]).pred,
+								  sizep);
+
+		/*
+		 * fprintf(stderr, "\t%s ^ %s -> %s\n", cube_out(tmp),
+		 * cube_out((NDBOX *)(((GISTENTRY
+		 * *)(VARDATA(entryvec)))[i]).pred), cube_out(out));
+		 */
+		if (i > 1)
+			pfree(tmp);
+		tmp = out;
+	}
+
+	return (out);
 }
 
 /*
 ** GiST Compress and Decompress methods for boxes
 ** do not do anything.
 */
-GISTENTRY *
+GISTENTRY  *
 g_cube_compress(GISTENTRY *entry)
 {
-    return(entry);
+	return (entry);
 }
 
-GISTENTRY *
+GISTENTRY  *
 g_cube_decompress(GISTENTRY *entry)
 {
-    return(entry);
+	return (entry);
 }
 
 /*
@@ -232,398 +243,448 @@ g_cube_decompress(GISTENTRY *entry)
 float *
 g_cube_penalty(GISTENTRY *origentry, GISTENTRY *newentry, float *result)
 {
-    Datum ud;
-    float tmp1, tmp2;
-    
-    ud = (Datum)cube_union((NDBOX *)(origentry->pred), (NDBOX *)(newentry->pred));
-    rt_cube_size((NDBOX *)ud, &tmp1);
-    rt_cube_size((NDBOX *)(origentry->pred), &tmp2);
-    *result = tmp1 - tmp2;
-    pfree((char *)ud);
-    /*
-    fprintf(stderr, "penalty\n");
-    fprintf(stderr, "\t%g\n", *result);
-    */
-    return(result);
+	Datum		ud;
+	float		tmp1,
+				tmp2;
+
+	ud = (Datum) cube_union((NDBOX *) (origentry->pred), (NDBOX *) (newentry->pred));
+	rt_cube_size((NDBOX *) ud, &tmp1);
+	rt_cube_size((NDBOX *) (origentry->pred), &tmp2);
+	*result = tmp1 - tmp2;
+	pfree((char *) ud);
+
+	/*
+	 * fprintf(stderr, "penalty\n"); fprintf(stderr, "\t%g\n", *result);
+	 */
+	return (result);
 }
 
 
 
 /*
 ** The GiST PickSplit method for boxes
-** We use Guttman's poly time split algorithm 
+** We use Guttman's poly time split algorithm
 */
 GIST_SPLITVEC *
 g_cube_picksplit(bytea *entryvec,
-	      GIST_SPLITVEC *v)
+				 GIST_SPLITVEC *v)
 {
-    OffsetNumber i, j;
-    NDBOX *datum_alpha, *datum_beta;
-    NDBOX *datum_l, *datum_r;
-    NDBOX *union_d, *union_dl, *union_dr;
-    NDBOX *inter_d;
-    bool firsttime;
-    float size_alpha, size_beta, size_union, size_inter;
-    float size_waste, waste;
-    float size_l, size_r;
-    int nbytes;
-    OffsetNumber seed_1 = 0, seed_2 = 0;
-    OffsetNumber *left, *right;
-    OffsetNumber maxoff;
-
-    /*
-    fprintf(stderr, "picksplit\n");
-    */
-    maxoff = ((VARSIZE(entryvec) - VARHDRSZ)/sizeof(GISTENTRY)) - 2;
-    nbytes =  (maxoff + 2) * sizeof(OffsetNumber);
-    v->spl_left = (OffsetNumber *) palloc(nbytes);
-    v->spl_right = (OffsetNumber *) palloc(nbytes);
-    
-    firsttime = true;
-    waste = 0.0;
-    
-    for (i = FirstOffsetNumber; i < maxoff; i = OffsetNumberNext(i)) {
-	datum_alpha = (NDBOX *)(((GISTENTRY *)(VARDATA(entryvec)))[i].pred);
-	for (j = OffsetNumberNext(i); j <= maxoff; j = OffsetNumberNext(j)) {
-	    datum_beta = (NDBOX *)(((GISTENTRY *)(VARDATA(entryvec)))[j].pred);
-	    
-	    /* compute the wasted space by unioning these guys */
-	    /* size_waste = size_union - size_inter; */
-	    union_d = (NDBOX *)cube_union(datum_alpha, datum_beta);
-	    rt_cube_size(union_d, &size_union);
-	    inter_d = (NDBOX *)cube_inter(datum_alpha, datum_beta);
-	    rt_cube_size(inter_d, &size_inter);
-	    size_waste = size_union - size_inter;
-	    
-	    pfree(union_d);
-	    
-	    if (inter_d != (NDBOX *) NULL)
-		pfree(inter_d);
-	    
-	    /*
-	     *  are these a more promising split than what we've
-	     *  already seen?
-	     */
-	    
-	    if (size_waste > waste || firsttime) {
-		waste = size_waste;
-		seed_1 = i;
-		seed_2 = j;
-		firsttime = false;
-	    }
-	}
-    }
-    
-    left = v->spl_left;
-    v->spl_nleft = 0;
-    right = v->spl_right;
-    v->spl_nright = 0;
-    
-    datum_alpha = (NDBOX *)(((GISTENTRY *)(VARDATA(entryvec)))[seed_1].pred);
-    datum_l = (NDBOX *)cube_union(datum_alpha, datum_alpha);
-    rt_cube_size((NDBOX *)datum_l, &size_l);
-    datum_beta = (NDBOX *)(((GISTENTRY *)(VARDATA(entryvec)))[seed_2].pred);;
-    datum_r = (NDBOX *)cube_union(datum_beta, datum_beta);
-    rt_cube_size((NDBOX *)datum_r, &size_r);
-    
-    /*
-     *  Now split up the regions between the two seeds.  An important
-     *  property of this split algorithm is that the split vector v
-     *  has the indices of items to be split in order in its left and
-     *  right vectors.  We exploit this property by doing a merge in
-     *  the code that actually splits the page.
-     *
-     *  For efficiency, we also place the new index tuple in this loop.
-     *  This is handled at the very end, when we have placed all the
-     *  existing tuples and i == maxoff + 1.
-     */
-    
-    maxoff = OffsetNumberNext(maxoff);
-    for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) {
-	
+	OffsetNumber i,
+				j;
+	NDBOX	   *datum_alpha,
+			   *datum_beta;
+	NDBOX	   *datum_l,
+			   *datum_r;
+	NDBOX	   *union_d,
+			   *union_dl,
+			   *union_dr;
+	NDBOX	   *inter_d;
+	bool		firsttime;
+	float		size_alpha,
+				size_beta,
+				size_union,
+				size_inter;
+	float		size_waste,
+				waste;
+	float		size_l,
+				size_r;
+	int			nbytes;
+	OffsetNumber seed_1 = 0,
+				seed_2 = 0;
+	OffsetNumber *left,
+			   *right;
+	OffsetNumber maxoff;
+
 	/*
-	 *  If we've already decided where to place this item, just
-	 *  put it on the right list.  Otherwise, we need to figure
-	 *  out which page needs the least enlargement in order to
-	 *  store the item.
+	 * fprintf(stderr, "picksplit\n");
 	 */
-	
-	if (i == seed_1) {
-	    *left++ = i;
-	    v->spl_nleft++;
-	    continue;
-	} else if (i == seed_2) {
-	    *right++ = i;
-	    v->spl_nright++;
-	    continue;
+	maxoff = ((VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY)) - 2;
+	nbytes = (maxoff + 2) * sizeof(OffsetNumber);
+	v->spl_left = (OffsetNumber *) palloc(nbytes);
+	v->spl_right = (OffsetNumber *) palloc(nbytes);
+
+	firsttime = true;
+	waste = 0.0;
+
+	for (i = FirstOffsetNumber; i < maxoff; i = OffsetNumberNext(i))
+	{
+		datum_alpha = (NDBOX *) (((GISTENTRY *) (VARDATA(entryvec)))[i].pred);
+		for (j = OffsetNumberNext(i); j <= maxoff; j = OffsetNumberNext(j))
+		{
+			datum_beta = (NDBOX *) (((GISTENTRY *) (VARDATA(entryvec)))[j].pred);
+
+			/* compute the wasted space by unioning these guys */
+			/* size_waste = size_union - size_inter; */
+			union_d = (NDBOX *) cube_union(datum_alpha, datum_beta);
+			rt_cube_size(union_d, &size_union);
+			inter_d = (NDBOX *) cube_inter(datum_alpha, datum_beta);
+			rt_cube_size(inter_d, &size_inter);
+			size_waste = size_union - size_inter;
+
+			pfree(union_d);
+
+			if (inter_d != (NDBOX *) NULL)
+				pfree(inter_d);
+
+			/*
+			 * are these a more promising split than what we've already
+			 * seen?
+			 */
+
+			if (size_waste > waste || firsttime)
+			{
+				waste = size_waste;
+				seed_1 = i;
+				seed_2 = j;
+				firsttime = false;
+			}
+		}
 	}
-	
-	/* okay, which page needs least enlargement? */ 
-	datum_alpha = (NDBOX *)(((GISTENTRY *)(VARDATA(entryvec)))[i].pred);
-	union_dl = (NDBOX *)cube_union(datum_l, datum_alpha);
-	union_dr = (NDBOX *)cube_union(datum_r, datum_alpha);
-	rt_cube_size((NDBOX *)union_dl, &size_alpha);
-	rt_cube_size((NDBOX *)union_dr, &size_beta);
-	
-	/* pick which page to add it to */
-	if (size_alpha - size_l < size_beta - size_r) {
-	    pfree(datum_l);
-	    pfree(union_dr);
-	    datum_l = union_dl;
-	    size_l = size_alpha;
-	    *left++ = i;
-	    v->spl_nleft++;
-	} else {
-	    pfree(datum_r);
-	    pfree(union_dl);
-	    datum_r = union_dr;
-	    size_r = size_alpha;
-	    *right++ = i;
-	    v->spl_nright++;
+
+	left = v->spl_left;
+	v->spl_nleft = 0;
+	right = v->spl_right;
+	v->spl_nright = 0;
+
+	datum_alpha = (NDBOX *) (((GISTENTRY *) (VARDATA(entryvec)))[seed_1].pred);
+	datum_l = (NDBOX *) cube_union(datum_alpha, datum_alpha);
+	rt_cube_size((NDBOX *) datum_l, &size_l);
+	datum_beta = (NDBOX *) (((GISTENTRY *) (VARDATA(entryvec)))[seed_2].pred);;
+	datum_r = (NDBOX *) cube_union(datum_beta, datum_beta);
+	rt_cube_size((NDBOX *) datum_r, &size_r);
+
+	/*
+	 * Now split up the regions between the two seeds.	An important
+	 * property of this split algorithm is that the split vector v has the
+	 * indices of items to be split in order in its left and right
+	 * vectors.  We exploit this property by doing a merge in the code
+	 * that actually splits the page.
+	 *
+	 * For efficiency, we also place the new index tuple in this loop. This
+	 * is handled at the very end, when we have placed all the existing
+	 * tuples and i == maxoff + 1.
+	 */
+
+	maxoff = OffsetNumberNext(maxoff);
+	for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
+	{
+
+		/*
+		 * If we've already decided where to place this item, just put it
+		 * on the right list.  Otherwise, we need to figure out which page
+		 * needs the least enlargement in order to store the item.
+		 */
+
+		if (i == seed_1)
+		{
+			*left++ = i;
+			v->spl_nleft++;
+			continue;
+		}
+		else if (i == seed_2)
+		{
+			*right++ = i;
+			v->spl_nright++;
+			continue;
+		}
+
+		/* okay, which page needs least enlargement? */
+		datum_alpha = (NDBOX *) (((GISTENTRY *) (VARDATA(entryvec)))[i].pred);
+		union_dl = (NDBOX *) cube_union(datum_l, datum_alpha);
+		union_dr = (NDBOX *) cube_union(datum_r, datum_alpha);
+		rt_cube_size((NDBOX *) union_dl, &size_alpha);
+		rt_cube_size((NDBOX *) union_dr, &size_beta);
+
+		/* pick which page to add it to */
+		if (size_alpha - size_l < size_beta - size_r)
+		{
+			pfree(datum_l);
+			pfree(union_dr);
+			datum_l = union_dl;
+			size_l = size_alpha;
+			*left++ = i;
+			v->spl_nleft++;
+		}
+		else
+		{
+			pfree(datum_r);
+			pfree(union_dl);
+			datum_r = union_dr;
+			size_r = size_alpha;
+			*right++ = i;
+			v->spl_nright++;
+		}
 	}
-    }
-    *left = *right = FirstOffsetNumber;	/* sentinel value, see dosplit() */
-    
-    v->spl_ldatum = (char *)datum_l;
-    v->spl_rdatum = (char *)datum_r;
+	*left = *right = FirstOffsetNumber; /* sentinel value, see dosplit() */
 
-    return v;
+	v->spl_ldatum = (char *) datum_l;
+	v->spl_rdatum = (char *) datum_r;
+
+	return v;
 }
 
 /*
 ** Equality method
 */
 bool *
-g_cube_same(NDBOX *b1, NDBOX *b2, bool *result)
+g_cube_same(NDBOX * b1, NDBOX * b2, bool *result)
 {
-  if (cube_same(b1, b2))
-    *result = TRUE;
-  else *result = FALSE;
-  /*
-  fprintf(stderr, "same: %s\n", (*result ? "TRUE" : "FALSE" ));
-  */
-  return(result);
+	if (cube_same(b1, b2))
+		*result = TRUE;
+	else
+		*result = FALSE;
+
+	/*
+	 * fprintf(stderr, "same: %s\n", (*result ? "TRUE" : "FALSE" ));
+	 */
+	return (result);
 }
 
-/* 
+/*
 ** SUPPORT ROUTINES
 */
-bool 
-g_cube_leaf_consistent(NDBOX *key,
-		     NDBOX *query,
-		     StrategyNumber strategy)
+bool
+g_cube_leaf_consistent(NDBOX * key,
+					   NDBOX * query,
+					   StrategyNumber strategy)
 {
-  bool retval;
-
-  /*
-  fprintf(stderr, "leaf_consistent, %d\n", strategy);
-  */
-  switch(strategy) {
-  case RTLeftStrategyNumber:
-    retval = (bool)cube_left(key, query);
-    break;
-  case RTOverLeftStrategyNumber:
-    retval = (bool)cube_over_left(key,query);
-    break;
-  case RTOverlapStrategyNumber:
-    retval = (bool)cube_overlap(key, query);
-    break;
-  case RTOverRightStrategyNumber:
-    retval = (bool)cube_over_right(key, query);
-    break;
-  case RTRightStrategyNumber:
-    retval = (bool)cube_right(key, query);
-    break;
-  case RTSameStrategyNumber:
-    retval = (bool)cube_same(key, query);
-    break;
-  case RTContainsStrategyNumber:
-    retval = (bool)cube_contains(key, query);
-    break;
-  case RTContainedByStrategyNumber:
-    retval = (bool)cube_contained(key,query);
-    break;
-  default:
-    retval = FALSE;
-  }
-  return(retval);
+	bool		retval;
+
+	/*
+	 * fprintf(stderr, "leaf_consistent, %d\n", strategy);
+	 */
+	switch (strategy)
+	{
+		case RTLeftStrategyNumber:
+			retval = (bool) cube_left(key, query);
+			break;
+		case RTOverLeftStrategyNumber:
+			retval = (bool) cube_over_left(key, query);
+			break;
+		case RTOverlapStrategyNumber:
+			retval = (bool) cube_overlap(key, query);
+			break;
+		case RTOverRightStrategyNumber:
+			retval = (bool) cube_over_right(key, query);
+			break;
+		case RTRightStrategyNumber:
+			retval = (bool) cube_right(key, query);
+			break;
+		case RTSameStrategyNumber:
+			retval = (bool) cube_same(key, query);
+			break;
+		case RTContainsStrategyNumber:
+			retval = (bool) cube_contains(key, query);
+			break;
+		case RTContainedByStrategyNumber:
+			retval = (bool) cube_contained(key, query);
+			break;
+		default:
+			retval = FALSE;
+	}
+	return (retval);
 }
 
-bool 
-g_cube_internal_consistent(NDBOX *key,
-			NDBOX *query,
-			StrategyNumber strategy)
+bool
+g_cube_internal_consistent(NDBOX * key,
+						   NDBOX * query,
+						   StrategyNumber strategy)
 {
-  bool retval;
-  
-  /*
-  fprintf(stderr, "internal_consistent, %d\n", strategy);
-  */
-  switch(strategy) {
-  case RTLeftStrategyNumber:
-  case RTOverLeftStrategyNumber:
-    retval = (bool)cube_over_left(key,query);
-    break;
-  case RTOverlapStrategyNumber:
-    retval = (bool)cube_overlap(key, query);
-    break;
-  case RTOverRightStrategyNumber:
-  case RTRightStrategyNumber:
-    retval = (bool)cube_right(key, query);
-    break;
-  case RTSameStrategyNumber:
-  case RTContainsStrategyNumber:
-    retval = (bool)cube_contains(key, query);
-    break;
-  case RTContainedByStrategyNumber:
-    retval = (bool)cube_overlap(key, query);
-    break;
-  default:
-    retval = FALSE;
-    }
-  return(retval);
+	bool		retval;
+
+	/*
+	 * fprintf(stderr, "internal_consistent, %d\n", strategy);
+	 */
+	switch (strategy)
+	{
+		case RTLeftStrategyNumber:
+		case RTOverLeftStrategyNumber:
+			retval = (bool) cube_over_left(key, query);
+			break;
+		case RTOverlapStrategyNumber:
+			retval = (bool) cube_overlap(key, query);
+			break;
+		case RTOverRightStrategyNumber:
+		case RTRightStrategyNumber:
+			retval = (bool) cube_right(key, query);
+			break;
+		case RTSameStrategyNumber:
+		case RTContainsStrategyNumber:
+			retval = (bool) cube_contains(key, query);
+			break;
+		case RTContainedByStrategyNumber:
+			retval = (bool) cube_overlap(key, query);
+			break;
+		default:
+			retval = FALSE;
+	}
+	return (retval);
 }
 
 NDBOX *
-g_cube_binary_union(NDBOX *r1, NDBOX *r2, int *sizep)
+g_cube_binary_union(NDBOX * r1, NDBOX * r2, int *sizep)
 {
-    NDBOX *retval;
+	NDBOX	   *retval;
 
-    retval = cube_union(r1, r2);
-    *sizep = retval->size;
+	retval = cube_union(r1, r2);
+	*sizep = retval->size;
 
-    return (retval);
+	return (retval);
 }
 
 
 /* cube_union */
-NDBOX *cube_union(NDBOX *box_a, NDBOX *box_b)
+NDBOX *
+cube_union(NDBOX * box_a, NDBOX * box_b)
 {
-  int i;
-  NDBOX *result;
-  NDBOX *a = swap_corners(box_a);
-  NDBOX *b = swap_corners(box_b);
-
-  if ( a->dim >= b->dim ) {
-    result = palloc(a->size);
-    result->size = a->size;
-    result->dim = a->dim;
-  }
-  else {
-    result = palloc(b->size);
-    result->size = b->size;
-    result->dim = b->dim;
-  }
-
-  /* swap the box pointers if needed */
-  if ( a->dim < b->dim ) {
-    NDBOX * tmp = b; b = a; a = tmp;
-  }
-
-  /* use the potentially smaller of the two boxes (b) to fill in 
-     the result, padding absent dimensions with zeroes*/
-  for ( i = 0; i < b->dim; i++ ) {
-    result->x[i] = b->x[i];
-    result->x[i + a->dim] = b->x[i + b->dim];
-  }
-  for ( i = b->dim; i < a->dim; i++ ) {
-    result->x[i] = 0;
-    result->x[i + a->dim] = 0;
-  }
-    
-  /* compute the union */
-  for ( i = 0; i < a->dim; i++ ) {
-    result->x[i] = min(a->x[i], result->x[i]);
-  }
-  for ( i = a->dim; i < a->dim * 2; i++ ) {
-    result->x[i] = max(a->x[i], result->x[i]);
-  }
-
-  pfree(a);
-  pfree(b);
-
-  return(result);
+	int			i;
+	NDBOX	   *result;
+	NDBOX	   *a = swap_corners(box_a);
+	NDBOX	   *b = swap_corners(box_b);
+
+	if (a->dim >= b->dim)
+	{
+		result = palloc(a->size);
+		result->size = a->size;
+		result->dim = a->dim;
+	}
+	else
+	{
+		result = palloc(b->size);
+		result->size = b->size;
+		result->dim = b->dim;
+	}
+
+	/* swap the box pointers if needed */
+	if (a->dim < b->dim)
+	{
+		NDBOX	   *tmp = b;
+
+		b = a;
+		a = tmp;
+	}
+
+	/*
+	 * use the potentially smaller of the two boxes (b) to fill in the
+	 * result, padding absent dimensions with zeroes
+	 */
+	for (i = 0; i < b->dim; i++)
+	{
+		result->x[i] = b->x[i];
+		result->x[i + a->dim] = b->x[i + b->dim];
+	}
+	for (i = b->dim; i < a->dim; i++)
+	{
+		result->x[i] = 0;
+		result->x[i + a->dim] = 0;
+	}
+
+	/* compute the union */
+	for (i = 0; i < a->dim; i++)
+		result->x[i] = min(a->x[i], result->x[i]);
+	for (i = a->dim; i < a->dim * 2; i++)
+		result->x[i] = max(a->x[i], result->x[i]);
+
+	pfree(a);
+	pfree(b);
+
+	return (result);
 }
 
 /* cube_inter */
-NDBOX *cube_inter(NDBOX *box_a, NDBOX *box_b)
+NDBOX *
+cube_inter(NDBOX * box_a, NDBOX * box_b)
 {
-  int i;
-  NDBOX * result;
-  NDBOX *a = swap_corners(box_a);
-  NDBOX *b = swap_corners(box_b);
-  
-  if ( a->dim >= b->dim ) {
-    result = palloc(a->size);
-    result->size = a->size;
-    result->dim = a->dim;
-  }
-  else {
-    result = palloc(b->size);
-    result->size = b->size;
-    result->dim = b->dim;
-  }
-
-  /* swap the box pointers if needed */
-  if ( a->dim < b->dim ) {
-    NDBOX * tmp = b; b = a; a = tmp;
-  }
-
-  /* use the potentially  smaller of the two boxes (b) to fill in 
-     the result, padding absent dimensions with zeroes*/
-  for ( i = 0; i < b->dim; i++ ) {
-    result->x[i] = b->x[i];
-    result->x[i + a->dim] = b->x[i + b->dim];
-  }
-  for ( i = b->dim; i < a->dim; i++ ) {
-    result->x[i] = 0;
-    result->x[i + a->dim] = 0;
-  }
-    
-  /* compute the intersection */
-  for ( i = 0; i < a->dim; i++ ) {
-    result->x[i] = max(a->x[i], result->x[i]);
-  }
-  for ( i = a->dim; i < a->dim * 2; i++ ) {
-    result->x[i] = min(a->x[i], result->x[i]);
-  }
-  
-  pfree(a);
-  pfree(b);
-
-  /* Is it OK to return a non-null intersection for non-overlapping boxes? */
-  return(result);
+	int			i;
+	NDBOX	   *result;
+	NDBOX	   *a = swap_corners(box_a);
+	NDBOX	   *b = swap_corners(box_b);
+
+	if (a->dim >= b->dim)
+	{
+		result = palloc(a->size);
+		result->size = a->size;
+		result->dim = a->dim;
+	}
+	else
+	{
+		result = palloc(b->size);
+		result->size = b->size;
+		result->dim = b->dim;
+	}
+
+	/* swap the box pointers if needed */
+	if (a->dim < b->dim)
+	{
+		NDBOX	   *tmp = b;
+
+		b = a;
+		a = tmp;
+	}
+
+	/*
+	 * use the potentially	smaller of the two boxes (b) to fill in the
+	 * result, padding absent dimensions with zeroes
+	 */
+	for (i = 0; i < b->dim; i++)
+	{
+		result->x[i] = b->x[i];
+		result->x[i + a->dim] = b->x[i + b->dim];
+	}
+	for (i = b->dim; i < a->dim; i++)
+	{
+		result->x[i] = 0;
+		result->x[i + a->dim] = 0;
+	}
+
+	/* compute the intersection */
+	for (i = 0; i < a->dim; i++)
+		result->x[i] = max(a->x[i], result->x[i]);
+	for (i = a->dim; i < a->dim * 2; i++)
+		result->x[i] = min(a->x[i], result->x[i]);
+
+	pfree(a);
+	pfree(b);
+
+	/*
+	 * Is it OK to return a non-null intersection for non-overlapping
+	 * boxes?
+	 */
+	return (result);
 }
 
 /* cube_size */
-float *cube_size(NDBOX *a)
+float *
+cube_size(NDBOX * a)
 {
-  int i,j;
-  float *result;
-
-  result = (float *) palloc(sizeof(float));
-  
-  *result = 1.0;
-  for ( i = 0, j = a->dim; i < a->dim; i++,j++ ) {
-    *result=(*result)*abs((a->x[j] - a->x[i]));
-  }
-  
-  return(result);
+	int			i,
+				j;
+	float	   *result;
+
+	result = (float *) palloc(sizeof(float));
+
+	*result = 1.0;
+	for (i = 0, j = a->dim; i < a->dim; i++, j++)
+		*result = (*result) * abs((a->x[j] - a->x[i]));
+
+	return (result);
 }
 
 void
-rt_cube_size(NDBOX *a, float *size)
+rt_cube_size(NDBOX * a, float *size)
 {
-  int i,j;
-  if (a == (NDBOX *) NULL)
-    *size = 0.0;
-  else {
-    *size = 1.0;
-    for ( i = 0, j = a->dim; i < a->dim; i++,j++ ) {
-      *size=(*size)*abs((a->x[j] - a->x[i]));
-    }
-  }
-  return;
+	int			i,
+				j;
+
+	if (a == (NDBOX *) NULL)
+		*size = 0.0;
+	else
+	{
+		*size = 1.0;
+		for (i = 0, j = a->dim; i < a->dim; i++, j++)
+			*size = (*size) * abs((a->x[j] - a->x[i]));
+	}
+	return;
 }
 
 /* The following four methods compare the projections of the boxes
@@ -631,428 +692,489 @@ rt_cube_size(NDBOX *a, float *size)
    larger than 2, but it seems that R-tree requires all its strategies
    map to real functions that return something */
 
-/*  is the right edge of (a) located to the left of 
-    the right edge of (b)? */
-bool cube_over_left(NDBOX *box_a, NDBOX *box_b)
+/*	is the right edge of (a) located to the left of
+	the right edge of (b)? */
+bool
+cube_over_left(NDBOX * box_a, NDBOX * box_b)
 {
-  NDBOX *a;
-  NDBOX *b;
-  
-  if ( (box_a==NULL) || (box_b==NULL) )
-    return(FALSE);
+	NDBOX	   *a;
+	NDBOX	   *b;
+
+	if ((box_a == NULL) || (box_b == NULL))
+		return (FALSE);
 
-  a = swap_corners(box_a);
-  b = swap_corners(box_b);
+	a = swap_corners(box_a);
+	b = swap_corners(box_b);
 
-  return( a->x[a->dim - 1] <= b->x[b->dim - 1] && !cube_left(a, b) && !cube_right(a, b) );
+	return (a->x[a->dim - 1] <= b->x[b->dim - 1] && !cube_left(a, b) && !cube_right(a, b));
 }
 
-/*  is the left edge of (a) located to the right of 
-    the left edge of (b)? */
-bool cube_over_right(NDBOX *box_a, NDBOX *box_b)
+/*	is the left edge of (a) located to the right of
+	the left edge of (b)? */
+bool
+cube_over_right(NDBOX * box_a, NDBOX * box_b)
 {
-  NDBOX *a;
-  NDBOX *b;
-  
-  if ( (box_a==NULL) || (box_b==NULL) )
-    return(FALSE);
+	NDBOX	   *a;
+	NDBOX	   *b;
 
-  a = swap_corners(box_a);
-  b = swap_corners(box_b);
+	if ((box_a == NULL) || (box_b == NULL))
+		return (FALSE);
 
-  return( a->x[a->dim - 1] >= b->x[b->dim - 1] && !cube_left(a, b) && !cube_right(a, b) );
+	a = swap_corners(box_a);
+	b = swap_corners(box_b);
+
+	return (a->x[a->dim - 1] >= b->x[b->dim - 1] && !cube_left(a, b) && !cube_right(a, b));
 }
 
 
 /* return 'true' if the projection of 'a' is
    entirely on the left of the projection of 'b' */
-bool cube_left(NDBOX *box_a, NDBOX *box_b)
+bool
+cube_left(NDBOX * box_a, NDBOX * box_b)
 {
-  NDBOX *a;
-  NDBOX *b;
-  
-  if ( (box_a==NULL) || (box_b==NULL) )
-    return(FALSE);
+	NDBOX	   *a;
+	NDBOX	   *b;
+
+	if ((box_a == NULL) || (box_b == NULL))
+		return (FALSE);
 
-  a = swap_corners(box_a);
-  b = swap_corners(box_b);
+	a = swap_corners(box_a);
+	b = swap_corners(box_b);
 
-  return( a->x[a->dim - 1] < b->x[0]);
+	return (a->x[a->dim - 1] < b->x[0]);
 }
 
 /* return 'true' if the projection of 'a' is
    entirely on the right  of the projection of 'b' */
-bool cube_right(NDBOX *box_a, NDBOX *box_b)
+bool
+cube_right(NDBOX * box_a, NDBOX * box_b)
 {
-  NDBOX *a;
-  NDBOX *b;
-  
-  if ( (box_a==NULL) || (box_b==NULL) )
-    return(FALSE);
+	NDBOX	   *a;
+	NDBOX	   *b;
 
-  a = swap_corners(box_a);
-  b = swap_corners(box_b);
+	if ((box_a == NULL) || (box_b == NULL))
+		return (FALSE);
 
-  return( a->x[0] > b->x[b->dim - 1]);
+	a = swap_corners(box_a);
+	b = swap_corners(box_b);
+
+	return (a->x[0] > b->x[b->dim - 1]);
 }
 
 /* make up a metric in which one box will be 'lower' than the other
    -- this can be useful for srting and to determine uniqueness */
-bool cube_lt(NDBOX *box_a, NDBOX *box_b)
+bool
+cube_lt(NDBOX * box_a, NDBOX * box_b)
 {
-  int i;
-  int dim;
-  NDBOX *a;
-  NDBOX *b;
-  
-  if ( (box_a==NULL) || (box_b==NULL) )
-    return(FALSE);
-
-  a = swap_corners(box_a);
-  b = swap_corners(box_b);
-  dim = min(a->dim, b->dim);
-
-  /* if all common dimensions are equal, the cube with more dimensions wins */
-  if ( cube_same(a, b) ) {
-    if (a->dim < b->dim) {
-      return(TRUE);
-    }
-    else {
-      return(FALSE);
-    }
-  }
-
-  /* compare the common dimensions */
-  for ( i = 0; i < dim; i++ ) {
-    if ( a->x[i] > b->x[i] )
-      return(FALSE); 
-    if ( a->x[i] < b->x[i] )
-      return(TRUE); 
-  }
-  for ( i = 0; i < dim; i++ ) {
-    if ( a->x[i + a->dim] > b->x[i + b->dim] )
-      return(FALSE); 
-    if ( a->x[i + a->dim] < b->x[i + b->dim] )
-      return(TRUE); 
-  }
-
-  /* compare extra dimensions to zero */
-  if ( a->dim > b->dim ) {
-    for ( i = dim; i < a->dim; i++ ) {
-      if ( a->x[i] > 0 )
-	return(FALSE); 
-      if ( a->x[i] < 0 )
-	return(TRUE); 
-    }
-    for ( i = 0; i < dim; i++ ) {
-      if ( a->x[i + a->dim] > 0 )
-	return(FALSE); 
-      if ( a->x[i + a->dim] < 0 )
-	return(TRUE); 
-    }
-  }
-  if ( a->dim < b->dim ) {
-    for ( i = dim; i < b->dim; i++ ) {
-      if ( b->x[i] > 0 )
-	return(TRUE); 
-      if ( b->x[i] < 0 )
-	return(FALSE); 
-    }
-    for ( i = 0; i < dim; i++ ) {
-      if ( b->x[i + b->dim] > 0 )
-	return(TRUE); 
-      if ( b->x[i + b->dim] < 0 )
-	return(FALSE);
-    }
-  }
-    
-  return(FALSE);
+	int			i;
+	int			dim;
+	NDBOX	   *a;
+	NDBOX	   *b;
+
+	if ((box_a == NULL) || (box_b == NULL))
+		return (FALSE);
+
+	a = swap_corners(box_a);
+	b = swap_corners(box_b);
+	dim = min(a->dim, b->dim);
+
+	/*
+	 * if all common dimensions are equal, the cube with more dimensions
+	 * wins
+	 */
+	if (cube_same(a, b))
+	{
+		if (a->dim < b->dim)
+			return (TRUE);
+		else
+			return (FALSE);
+	}
+
+	/* compare the common dimensions */
+	for (i = 0; i < dim; i++)
+	{
+		if (a->x[i] > b->x[i])
+			return (FALSE);
+		if (a->x[i] < b->x[i])
+			return (TRUE);
+	}
+	for (i = 0; i < dim; i++)
+	{
+		if (a->x[i + a->dim] > b->x[i + b->dim])
+			return (FALSE);
+		if (a->x[i + a->dim] < b->x[i + b->dim])
+			return (TRUE);
+	}
+
+	/* compare extra dimensions to zero */
+	if (a->dim > b->dim)
+	{
+		for (i = dim; i < a->dim; i++)
+		{
+			if (a->x[i] > 0)
+				return (FALSE);
+			if (a->x[i] < 0)
+				return (TRUE);
+		}
+		for (i = 0; i < dim; i++)
+		{
+			if (a->x[i + a->dim] > 0)
+				return (FALSE);
+			if (a->x[i + a->dim] < 0)
+				return (TRUE);
+		}
+	}
+	if (a->dim < b->dim)
+	{
+		for (i = dim; i < b->dim; i++)
+		{
+			if (b->x[i] > 0)
+				return (TRUE);
+			if (b->x[i] < 0)
+				return (FALSE);
+		}
+		for (i = 0; i < dim; i++)
+		{
+			if (b->x[i + b->dim] > 0)
+				return (TRUE);
+			if (b->x[i + b->dim] < 0)
+				return (FALSE);
+		}
+	}
+
+	return (FALSE);
 }
 
 
-bool cube_gt(NDBOX *box_a, NDBOX *box_b)
+bool
+cube_gt(NDBOX * box_a, NDBOX * box_b)
 {
-  int i;
-  int dim;
-  NDBOX *a;
-  NDBOX *b;
-  
-  if ( (box_a==NULL) || (box_b==NULL) )
-    return(FALSE);
-
-  a = swap_corners(box_a);
-  b = swap_corners(box_b);
-  dim = min(a->dim, b->dim);
-
-  /* if all common dimensions are equal, the cube with more dimensions wins */
-  if ( cube_same(a, b) ) {
-    if (a->dim > b->dim) {
-      return(TRUE);
-    }
-    else {
-      return(FALSE);
-    }
-  }
-
-  /* compare the common dimensions */
-  for ( i = 0; i < dim; i++ ) {
-    if ( a->x[i] < b->x[i] )
-      return(FALSE); 
-    if ( a->x[i] > b->x[i] )
-      return(TRUE); 
-  }
-  for ( i = 0; i < dim; i++ ) {
-    if ( a->x[i + a->dim] < b->x[i + b->dim] )
-      return(FALSE); 
-    if ( a->x[i + a->dim] > b->x[i + b->dim] )
-      return(TRUE); 
-  }
-
-
-  /* compare extra dimensions to zero */
-  if ( a->dim > b->dim ) {
-    for ( i = dim; i < a->dim; i++ ) {
-      if ( a->x[i] < 0 )
-	return(FALSE); 
-      if ( a->x[i] > 0 )
-	return(TRUE); 
-    }
-    for ( i = 0; i < dim; i++ ) {
-      if ( a->x[i + a->dim] < 0 )
-	return(FALSE); 
-      if ( a->x[i + a->dim] > 0 )
-	return(TRUE); 
-    }
-  }
-  if ( a->dim < b->dim ) {
-    for ( i = dim; i < b->dim; i++ ) {
-      if ( b->x[i] < 0 )
-	return(TRUE); 
-      if ( b->x[i] > 0 )
-	return(FALSE); 
-    }
-    for ( i = 0; i < dim; i++ ) {
-      if ( b->x[i + b->dim] < 0 )
-	return(TRUE); 
-      if ( b->x[i + b->dim] > 0 )
-	return(FALSE);
-    }
-  }
-
-  return(FALSE);
+	int			i;
+	int			dim;
+	NDBOX	   *a;
+	NDBOX	   *b;
+
+	if ((box_a == NULL) || (box_b == NULL))
+		return (FALSE);
+
+	a = swap_corners(box_a);
+	b = swap_corners(box_b);
+	dim = min(a->dim, b->dim);
+
+	/*
+	 * if all common dimensions are equal, the cube with more dimensions
+	 * wins
+	 */
+	if (cube_same(a, b))
+	{
+		if (a->dim > b->dim)
+			return (TRUE);
+		else
+			return (FALSE);
+	}
+
+	/* compare the common dimensions */
+	for (i = 0; i < dim; i++)
+	{
+		if (a->x[i] < b->x[i])
+			return (FALSE);
+		if (a->x[i] > b->x[i])
+			return (TRUE);
+	}
+	for (i = 0; i < dim; i++)
+	{
+		if (a->x[i + a->dim] < b->x[i + b->dim])
+			return (FALSE);
+		if (a->x[i + a->dim] > b->x[i + b->dim])
+			return (TRUE);
+	}
+
+
+	/* compare extra dimensions to zero */
+	if (a->dim > b->dim)
+	{
+		for (i = dim; i < a->dim; i++)
+		{
+			if (a->x[i] < 0)
+				return (FALSE);
+			if (a->x[i] > 0)
+				return (TRUE);
+		}
+		for (i = 0; i < dim; i++)
+		{
+			if (a->x[i + a->dim] < 0)
+				return (FALSE);
+			if (a->x[i + a->dim] > 0)
+				return (TRUE);
+		}
+	}
+	if (a->dim < b->dim)
+	{
+		for (i = dim; i < b->dim; i++)
+		{
+			if (b->x[i] < 0)
+				return (TRUE);
+			if (b->x[i] > 0)
+				return (FALSE);
+		}
+		for (i = 0; i < dim; i++)
+		{
+			if (b->x[i + b->dim] < 0)
+				return (TRUE);
+			if (b->x[i + b->dim] > 0)
+				return (FALSE);
+		}
+	}
+
+	return (FALSE);
 }
 
 
 /* Equal */
-bool cube_same(NDBOX *box_a, NDBOX *box_b)
+bool
+cube_same(NDBOX * box_a, NDBOX * box_b)
 {
-  int i;
-  NDBOX *a;
-  NDBOX *b;
-  
-  if ( (box_a==NULL) || (box_b==NULL) )
-    return(FALSE);
-
-  a = swap_corners(box_a);
-  b = swap_corners(box_b);
-
-  /* swap the box pointers if necessary */
-  if ( a->dim < b->dim ) {
-    NDBOX * tmp = b; b = a; a = tmp;
-  }
-
-  for ( i = 0; i < b->dim; i++ ) {
-    if ( a->x[i] != b->x[i] )
-      return(FALSE);
-    if ( a->x[i + a->dim] != b->x[i + b->dim] )
-      return(FALSE);
-  }
-
-  /* all dimensions of (b) are compared to those of (a);
-     instead of those in (a) absent in (b), compare (a) to zero */
-  for ( i = b->dim; i < a->dim; i++ ) {
-     if ( a->x[i] != 0 )
-      return(FALSE);
-     if ( a->x[i + a->dim] != 0 )
-      return(FALSE);
-  }
-
-  pfree(a);
-  pfree(b);
-
-  return(TRUE);
+	int			i;
+	NDBOX	   *a;
+	NDBOX	   *b;
+
+	if ((box_a == NULL) || (box_b == NULL))
+		return (FALSE);
+
+	a = swap_corners(box_a);
+	b = swap_corners(box_b);
+
+	/* swap the box pointers if necessary */
+	if (a->dim < b->dim)
+	{
+		NDBOX	   *tmp = b;
+
+		b = a;
+		a = tmp;
+	}
+
+	for (i = 0; i < b->dim; i++)
+	{
+		if (a->x[i] != b->x[i])
+			return (FALSE);
+		if (a->x[i + a->dim] != b->x[i + b->dim])
+			return (FALSE);
+	}
+
+	/*
+	 * all dimensions of (b) are compared to those of (a); instead of
+	 * those in (a) absent in (b), compare (a) to zero
+	 */
+	for (i = b->dim; i < a->dim; i++)
+	{
+		if (a->x[i] != 0)
+			return (FALSE);
+		if (a->x[i + a->dim] != 0)
+			return (FALSE);
+	}
+
+	pfree(a);
+	pfree(b);
+
+	return (TRUE);
 }
 
 /* Different */
-bool cube_different(NDBOX *box_a, NDBOX *box_b)
+bool
+cube_different(NDBOX * box_a, NDBOX * box_b)
 {
-  return(!cube_same(box_a, box_b));
+	return (!cube_same(box_a, box_b));
 }
 
 
 /* Contains */
 /* Box(A) CONTAINS Box(B) IFF pt(A) < pt(B) */
-bool cube_contains(NDBOX *box_a, NDBOX *box_b)
+bool
+cube_contains(NDBOX * box_a, NDBOX * box_b)
 {
-  int i;
-  NDBOX *a;
-  NDBOX *b;
-
-  if ( (box_a==NULL) || (box_b==NULL) )
-    return(FALSE);
-
-  a = swap_corners(box_a);
-  b = swap_corners(box_b);
-
-  if ( a->dim < b->dim ) {
-    /* the further comparisons will make sense if the 
-       excess dimensions of (b) were zeroes */
-    for ( i = a->dim; i < b->dim; i++ ) {
-      if ( b->x[i] != 0 )
-	return(FALSE);
-      if ( b->x[i + b->dim] != 0 )
-	return(FALSE);
-    }
-  }
-
-  /* Can't care less about the excess dimensions of (a), if any */
-  for ( i = 0; i < min(a->dim, b->dim); i++ ) {
-    if ( a->x[i] > b->x[i] )
-      return(FALSE);
-    if ( a->x[i + a->dim] < b->x[i + b->dim] )
-      return(FALSE);
-  }
-
-  pfree(a);
-  pfree(b);
-
-  return(TRUE);
+	int			i;
+	NDBOX	   *a;
+	NDBOX	   *b;
+
+	if ((box_a == NULL) || (box_b == NULL))
+		return (FALSE);
+
+	a = swap_corners(box_a);
+	b = swap_corners(box_b);
+
+	if (a->dim < b->dim)
+	{
+
+		/*
+		 * the further comparisons will make sense if the excess
+		 * dimensions of (b) were zeroes
+		 */
+		for (i = a->dim; i < b->dim; i++)
+		{
+			if (b->x[i] != 0)
+				return (FALSE);
+			if (b->x[i + b->dim] != 0)
+				return (FALSE);
+		}
+	}
+
+	/* Can't care less about the excess dimensions of (a), if any */
+	for (i = 0; i < min(a->dim, b->dim); i++)
+	{
+		if (a->x[i] > b->x[i])
+			return (FALSE);
+		if (a->x[i + a->dim] < b->x[i + b->dim])
+			return (FALSE);
+	}
+
+	pfree(a);
+	pfree(b);
+
+	return (TRUE);
 }
 
 /* Contained */
 /* Box(A) Contained by Box(B) IFF Box(B) Contains Box(A) */
-bool cube_contained (NDBOX *a, NDBOX *b)
+bool
+cube_contained(NDBOX * a, NDBOX * b)
 {
-  if (cube_contains(b,a) == TRUE)
-    return(TRUE);
-  else
-    return(FALSE);
+	if (cube_contains(b, a) == TRUE)
+		return (TRUE);
+	else
+		return (FALSE);
 }
 
 /* Overlap */
 /* Box(A) Overlap Box(B) IFF (pt(a)LL < pt(B)UR) && (pt(b)LL < pt(a)UR) */
-bool cube_overlap(NDBOX *box_a, NDBOX *box_b)
+bool
+cube_overlap(NDBOX * box_a, NDBOX * box_b)
 {
-  int i;
-  NDBOX *a;
-  NDBOX *b;
-
-  /* This *very bad* error was found in the source: 
-	if ( (a==NULL) || (b=NULL) )
-		return(FALSE);
-  */
-  if ( (box_a==NULL) || (box_b==NULL) )
-    return(FALSE);
-
-  a = swap_corners(box_a);
-  b = swap_corners(box_b);
-
-  /* swap the box pointers if needed */
-  if ( a->dim < b->dim ) {
-    NDBOX * tmp = b; b = a; a = tmp;
-  }
-
-  /* compare within the dimensions of (b) */
-  for ( i = 0; i < b->dim; i++ ) {
-    if ( a->x[i] > b->x[i + b->dim] )
-      return(FALSE);
-    if ( a->x[i + a->dim] < b->x[i] )
-      return(FALSE);
-  }
-
-  /* compare to zero those dimensions in (a) absent in (b) */
-  for ( i = b->dim; i < a->dim; i++ ) {
-     if ( a->x[i] > 0 )
-      return(FALSE);
-     if ( a->x[i + a->dim] < 0 )
-      return(FALSE);
-  }
-
-  pfree(a);
-  pfree(b);
-
-  return(TRUE);
+	int			i;
+	NDBOX	   *a;
+	NDBOX	   *b;
+
+	/*
+	 * This *very bad* error was found in the source: if ( (a==NULL) ||
+	 * (b=NULL) ) return(FALSE);
+	 */
+	if ((box_a == NULL) || (box_b == NULL))
+		return (FALSE);
+
+	a = swap_corners(box_a);
+	b = swap_corners(box_b);
+
+	/* swap the box pointers if needed */
+	if (a->dim < b->dim)
+	{
+		NDBOX	   *tmp = b;
+
+		b = a;
+		a = tmp;
+	}
+
+	/* compare within the dimensions of (b) */
+	for (i = 0; i < b->dim; i++)
+	{
+		if (a->x[i] > b->x[i + b->dim])
+			return (FALSE);
+		if (a->x[i + a->dim] < b->x[i])
+			return (FALSE);
+	}
+
+	/* compare to zero those dimensions in (a) absent in (b) */
+	for (i = b->dim; i < a->dim; i++)
+	{
+		if (a->x[i] > 0)
+			return (FALSE);
+		if (a->x[i + a->dim] < 0)
+			return (FALSE);
+	}
+
+	pfree(a);
+	pfree(b);
+
+	return (TRUE);
 }
 
 
 /* Distance */
 /* The distance is computed as a per axis sum of the squared distances
-   between 1D projections of the boxes onto Cartesian axes. Assuming zero 
-   distance between overlapping projections, this metric coincides with the 
+   between 1D projections of the boxes onto Cartesian axes. Assuming zero
+   distance between overlapping projections, this metric coincides with the
    "common sense" geometric distance */
-float *cube_distance(NDBOX *a, NDBOX *b)
+float *
+cube_distance(NDBOX * a, NDBOX * b)
 {
-  int i;
-  double d, distance;
-  float *result;
-
-  result = (float *) palloc(sizeof(float));
-  
-  /* swap the box pointers if needed */
-  if ( a->dim < b->dim ) {
-    NDBOX * tmp = b; b = a; a = tmp;
-  }
-
-  distance = 0.0;
-  /* compute within the dimensions of (b) */
-  for ( i = 0; i < b->dim; i++ ) {
-    d = distance_1D(a->x[i], a->x[i + a->dim], b->x[i], b->x[i + b->dim]);
-    distance += d*d;
-  }
-
-  /* compute distance to zero for those dimensions in (a) absent in (b) */
-  for ( i = b->dim; i < a->dim; i++ ) {
-    d = distance_1D(a->x[i], a->x[i + a->dim], 0.0, 0.0);
-    distance += d*d;
-  }
-  
-  *result = (float)sqrt(distance);
-
-  return(result);
+	int			i;
+	double		d,
+				distance;
+	float	   *result;
+
+	result = (float *) palloc(sizeof(float));
+
+	/* swap the box pointers if needed */
+	if (a->dim < b->dim)
+	{
+		NDBOX	   *tmp = b;
+
+		b = a;
+		a = tmp;
+	}
+
+	distance = 0.0;
+	/* compute within the dimensions of (b) */
+	for (i = 0; i < b->dim; i++)
+	{
+		d = distance_1D(a->x[i], a->x[i + a->dim], b->x[i], b->x[i + b->dim]);
+		distance += d * d;
+	}
+
+	/* compute distance to zero for those dimensions in (a) absent in (b) */
+	for (i = b->dim; i < a->dim; i++)
+	{
+		d = distance_1D(a->x[i], a->x[i + a->dim], 0.0, 0.0);
+		distance += d * d;
+	}
+
+	*result = (float) sqrt(distance);
+
+	return (result);
 }
 
-static float distance_1D(float a1, float a2, float b1, float b2)
+static float
+distance_1D(float a1, float a2, float b1, float b2)
 {
-  /* interval (a) is entirely on the left of (b) */
-  if( (a1 <= b1) && (a2 <= b1) && (a1 <= b2) && (a2 <= b2) ) {
-    return ( min( b1, b2 ) - max( a1, a2 ) );
-  }
-
-  /* interval (a) is entirely on the right of (b) */
-  if( (a1 > b1) && (a2 > b1) && (a1 > b2) && (a2 > b2) ) {
-    return ( min( a1, a2 ) - max( b1, b2 ) );
-  }
-  
-  /* the rest are all sorts of intersections */
-  return(0.0);
+	/* interval (a) is entirely on the left of (b) */
+	if ((a1 <= b1) && (a2 <= b1) && (a1 <= b2) && (a2 <= b2))
+		return (min(b1, b2) - max(a1, a2));
+
+	/* interval (a) is entirely on the right of (b) */
+	if ((a1 > b1) && (a2 > b1) && (a1 > b2) && (a2 > b2))
+		return (min(a1, a2) - max(b1, b2));
+
+	/* the rest are all sorts of intersections */
+	return (0.0);
 }
 
 /* normalize the box's co-ordinates by placing min(xLL,xUR) to LL
-   and max(xLL,xUR) to UR 
+   and max(xLL,xUR) to UR
 */
-static NDBOX *swap_corners ( NDBOX *a )
+static NDBOX *
+swap_corners(NDBOX * a)
 {
-  int i, j;
-  NDBOX * result;
-  
-  result = palloc(a->size);
-  result->size = a->size;
-  result->dim = a->dim;
-
-  for ( i = 0, j = a->dim; i < a->dim; i++, j++ ) {
-    result->x[i] = min(a->x[i],a->x[j]);
-    result->x[j] = max(a->x[i],a->x[j]);
-  }
-
-  return(result);
+	int			i,
+				j;
+	NDBOX	   *result;
+
+	result = palloc(a->size);
+	result->size = a->size;
+	result->dim = a->dim;
+
+	for (i = 0, j = a->dim; i < a->dim; i++, j++)
+	{
+		result->x[i] = min(a->x[i], a->x[j]);
+		result->x[j] = max(a->x[i], a->x[j]);
+	}
+
+	return (result);
 }
diff --git a/contrib/cube/cubedata.h b/contrib/cube/cubedata.h
index 18bb648546..359fab2871 100644
--- a/contrib/cube/cubedata.h
+++ b/contrib/cube/cubedata.h
@@ -1,5 +1,6 @@
-typedef struct NDBOX {
-  unsigned int size;			/* required to be a Postgres varlena type */
-  unsigned int dim;
-  float x[1];
-} NDBOX;
+typedef struct NDBOX
+{
+	unsigned int size;			/* required to be a Postgres varlena type */
+	unsigned int dim;
+	float		x[1];
+}			NDBOX;
diff --git a/contrib/earthdistance/earthdistance.c b/contrib/earthdistance/earthdistance.c
index 2383256be9..c1962272f4 100644
--- a/contrib/earthdistance/earthdistance.c
+++ b/contrib/earthdistance/earthdistance.c
@@ -9,7 +9,7 @@
 const int	EARTH_RADIUS = 3958.747716;
 const int	TWO_PI = 2.0 * M_PI;
 
-double *geo_distance(Point *pt1, Point *pt2);
+double	   *geo_distance(Point *pt1, Point *pt2);
 
 
 /******************************************************
diff --git a/contrib/findoidjoins/findoidjoins.c b/contrib/findoidjoins/findoidjoins.c
index 7d76bf719f..8aabe58672 100644
--- a/contrib/findoidjoins/findoidjoins.c
+++ b/contrib/findoidjoins/findoidjoins.c
@@ -20,7 +20,7 @@ main(int argc, char **argv)
 	char		attname[256];
 	char		typname[256];
 	int			count;
-	char	    optstr[256];
+	char		optstr[256];
 
 	if (argc != 2)
 		halt("Usage:  %s database\n", argv[0]);
diff --git a/contrib/fulltextindex/fti.c b/contrib/fulltextindex/fti.c
index 1f9c398fea..a797505e70 100644
--- a/contrib/fulltextindex/fti.c
+++ b/contrib/fulltextindex/fti.c
@@ -62,11 +62,11 @@ select p.* from product p, title_fti f1, title_fti f2 where
    that can build the final query automatigally?
    */
 
-extern Datum	fti(PG_FUNCTION_ARGS);
-static char	   *breakup(char *, char *);
-static bool		is_stopword(char *);
+extern Datum fti(PG_FUNCTION_ARGS);
+static char *breakup(char *, char *);
+static bool is_stopword(char *);
 
-static bool		new_tuple = false;
+static bool new_tuple = false;
 
 
 /* THIS LIST MUST BE IN SORTED ORDER, A BINARY SEARCH IS USED!!!! */
diff --git a/contrib/lo/lo.c b/contrib/lo/lo.c
index 33fa4cf98d..1dcdc35850 100644
--- a/contrib/lo/lo.c
+++ b/contrib/lo/lo.c
@@ -1,7 +1,7 @@
 /*
  *	PostgreSQL type definitions for managed LargeObjects.
  *
- *	$Header: /cvsroot/pgsql/contrib/lo/lo.c,v 1.7 2001/02/10 02:31:25 tgl Exp $
+ *	$Header: /cvsroot/pgsql/contrib/lo/lo.c,v 1.8 2001/03/22 03:59:09 momjian Exp $
  *
  */
 
@@ -36,7 +36,7 @@ Blob	   *lo_in(char *str);	/* Create from String		*/
 char	   *lo_out(Blob * addr);/* Output oid as String		*/
 Oid			lo_oid(Blob * addr);/* Return oid as an oid		*/
 Blob	   *lo(Oid oid);		/* Return Blob based on oid */
-Datum		lo_manage(PG_FUNCTION_ARGS); /* Trigger handler			*/
+Datum		lo_manage(PG_FUNCTION_ARGS);		/* Trigger handler		   */
 
 /*
  * This creates a large object, and sets its OID to the value in the
@@ -69,7 +69,7 @@ lo_in(char *str)
 		 * There is no Oid passed, so create a new one
 		 */
 		oid = DatumGetObjectId(DirectFunctionCall1(lo_creat,
-							   Int32GetDatum(INV_READ | INV_WRITE)));
+								   Int32GetDatum(INV_READ | INV_WRITE)));
 		if (oid == InvalidOid)
 			elog(ERROR, "lo_in: InvalidOid returned from lo_creat");
 	}
diff --git a/contrib/oid2name/oid2name.c b/contrib/oid2name/oid2name.c
index 1eaa73335c..a823c5f50b 100644
--- a/contrib/oid2name/oid2name.c
+++ b/contrib/oid2name/oid2name.c
@@ -1,6 +1,6 @@
-/* 
+/*
   oid2name; a postgresql 7.1 (+?) app to map OIDs on the filesystem
-   to table and database names.  
+   to table and database names.
 
   b. palmer, [email protected] 1-17-2001
 
@@ -13,433 +13,439 @@
 #include "libpq-fe.h"
 
 /* these are the opts structures for command line params */
-struct options {
-  int getdatabase;
-  int gettable;
-  int getoid;
-  
-  int systables;
-
-  int remotehost;
-  int remoteport;
-  int remoteuser;
-  int remotepass;
-
-  int _oid;
-  char _dbname[128];
-  char _tbname[128];
-
-  char _hostname[128];
-  char _port[6];
-  char _username[128];
-  char _password[128];
+struct options
+{
+	int			getdatabase;
+	int			gettable;
+	int			getoid;
+
+	int			systables;
+
+	int			remotehost;
+	int			remoteport;
+	int			remoteuser;
+	int			remotepass;
+
+	int			_oid;
+	char		_dbname[128];
+	char		_tbname[128];
+
+	char		_hostname[128];
+	char		_port[6];
+	char		_username[128];
+	char		_password[128];
 };
 
 /* function prototypes */
-void get_opts(int, char **, struct options *);
-PGconn *sql_conn(char *, struct options *);
-void sql_exec_error (int);
-int sql_exec(PGconn *, char *, int);
-void sql_exec_dumpdb(PGconn *);
-void sql_exec_dumptable(PGconn *, int);
-void sql_exec_searchtable(PGconn *, char *);
-void sql_exec_searchoid(PGconn *, int);
+void		get_opts(int, char **, struct options *);
+PGconn	   *sql_conn(char *, struct options *);
+void		sql_exec_error(int);
+int			sql_exec(PGconn *, char *, int);
+void		sql_exec_dumpdb(PGconn *);
+void		sql_exec_dumptable(PGconn *, int);
+void		sql_exec_searchtable(PGconn *, char *);
+void		sql_exec_searchoid(PGconn *, int);
 
 /* fuction to parse command line options and check for some usage errors. */
-void get_opts(int argc, char **argv, struct options *my_opts)
+void
+get_opts(int argc, char **argv, struct options * my_opts)
 {
-  char c;
+	char		c;
 
-  /* set the defaults */
-  my_opts->getdatabase = 0;
-  my_opts->gettable = 0;
-  my_opts->getoid = 0;
+	/* set the defaults */
+	my_opts->getdatabase = 0;
+	my_opts->gettable = 0;
+	my_opts->getoid = 0;
 
-  my_opts->systables = 0;
+	my_opts->systables = 0;
 
-  my_opts->remotehost = 0;
-  my_opts->remoteport = 0;
-  my_opts->remoteuser = 0;
-  my_opts->remotepass = 0;
+	my_opts->remotehost = 0;
+	my_opts->remoteport = 0;
+	my_opts->remoteuser = 0;
+	my_opts->remotepass = 0;
 
-  /* get opts */
-  while( (c = getopt(argc, argv, "H:p:U:P:d:t:o:xh?")) != EOF)
-    {
-      switch(c)
+	/* get opts */
+	while ((c = getopt(argc, argv, "H:p:U:P:d:t:o:xh?")) != EOF)
 	{
-	  /* specify the database */
-	case 'd':
-	  my_opts->getdatabase = 1;
-	  sscanf(optarg, "%s", my_opts->_dbname);
-	  break;
-
-	  /* specify the table name */
-	case 't':
-	  /* make sure we set the database first */
-	  if(!my_opts->getdatabase)
-	    {
-	      fprintf(stderr, "Sorry,  but you must specify a database to dump from.\n");
-	      exit(1);
-	    }
-	  /* make sure we don't try to do a -o also */
-	  if(my_opts->getoid)
-	    {
-	      fprintf(stderr, "Sorry, you can only specify either oid or table\n");
-	      exit(1);
-	    }
-
-	  my_opts->gettable = 1;
-	  sscanf(optarg, "%s", my_opts->_tbname);
-
-	  break;
-
-	  /* specify the oid int */
-	case 'o':
-	  /* make sure we set the database first */
-	  if(!my_opts->getdatabase)
-	    {
-	      fprintf(stderr, "Sorry,  but you must specify a database to dump from.\n");
-	      exit(1);
-	    }
-	  /* make sure we don't try to do a -t also */
-	  if(my_opts->gettable)
-	    {
-	      fprintf(stderr, "Sorry, you can only specify either oid or table\n");
-	      exit(1);
-	    }
-
-	  my_opts->getoid = 1;
-	  sscanf(optarg, "%i", &my_opts->_oid);
-
-	  break;
-
-	  /* host to connect to */
-	case 'H':
-	  my_opts->remotehost = 1;
-	  sscanf(optarg, "%s", my_opts->_hostname);
-	  break;
-
-	  /* port to connect to on remote host */
-	case 'p':
-	  my_opts->remoteport = 1;
-	  sscanf(optarg, "%s", my_opts->_port);
-	  break;
-
-	  /* username */
-	case 'U':
-	  my_opts->remoteuser = 1;
-	  sscanf(optarg, "%s", my_opts->_username);
-	  break;
-
-	  /* password */
-	case 'P':
-	  my_opts->remotepass = 1;
-	  sscanf(optarg, "%s", my_opts->_password);
-	  break;
-
-	  /* display system tables */
-	case 'x':
-
-	  my_opts->systables = 1;
-	  break;
-
-	  /* help! (ugly in code for easier editing) */
-	case '?':
-	case 'h':
-	  fprintf(stderr, "\n\
+		switch (c)
+		{
+				/* specify the database */
+			case 'd':
+				my_opts->getdatabase = 1;
+				sscanf(optarg, "%s", my_opts->_dbname);
+				break;
+
+				/* specify the table name */
+			case 't':
+				/* make sure we set the database first */
+				if (!my_opts->getdatabase)
+				{
+					fprintf(stderr, "Sorry,  but you must specify a database to dump from.\n");
+					exit(1);
+				}
+				/* make sure we don't try to do a -o also */
+				if (my_opts->getoid)
+				{
+					fprintf(stderr, "Sorry, you can only specify either oid or table\n");
+					exit(1);
+				}
+
+				my_opts->gettable = 1;
+				sscanf(optarg, "%s", my_opts->_tbname);
+
+				break;
+
+				/* specify the oid int */
+			case 'o':
+				/* make sure we set the database first */
+				if (!my_opts->getdatabase)
+				{
+					fprintf(stderr, "Sorry,  but you must specify a database to dump from.\n");
+					exit(1);
+				}
+				/* make sure we don't try to do a -t also */
+				if (my_opts->gettable)
+				{
+					fprintf(stderr, "Sorry, you can only specify either oid or table\n");
+					exit(1);
+				}
+
+				my_opts->getoid = 1;
+				sscanf(optarg, "%i", &my_opts->_oid);
+
+				break;
+
+				/* host to connect to */
+			case 'H':
+				my_opts->remotehost = 1;
+				sscanf(optarg, "%s", my_opts->_hostname);
+				break;
+
+				/* port to connect to on remote host */
+			case 'p':
+				my_opts->remoteport = 1;
+				sscanf(optarg, "%s", my_opts->_port);
+				break;
+
+				/* username */
+			case 'U':
+				my_opts->remoteuser = 1;
+				sscanf(optarg, "%s", my_opts->_username);
+				break;
+
+				/* password */
+			case 'P':
+				my_opts->remotepass = 1;
+				sscanf(optarg, "%s", my_opts->_password);
+				break;
+
+				/* display system tables */
+			case 'x':
+
+				my_opts->systables = 1;
+				break;
+
+				/* help! (ugly in code for easier editing) */
+			case '?':
+			case 'h':
+				fprintf(stderr, "\n\
 Usage: pg_oid2name [-d database [-x] ] [-t table | -o oid] \n\
-        dafault action        display all databases
+        dafault action        display all databases\n\
         -d database           database to oid2name\n\
         -x                    display system tables\n\
         -t table | -o oid     search for table name (-t) or\n\
-                               oid (-o) in -d database
+                               oid (-o) in -d database\n\
         -H host               connect to remote host\n\
         -p port               host port to connect to\n\
         -U username           username to connect with\n\
         -P password           password for username\n\n\
 ");
-	  exit(1);
-	  break;
+				exit(1);
+				break;
+		}
 	}
-    }
 }
 
 /* establish connection with database. */
-PGconn *sql_conn(char *dbName, struct options *my_opts)
+PGconn *
+sql_conn(char *dbName, struct options * my_opts)
 {
-  char *pghost, *pgport;
-  char *pgoptions, *pgtty;
-  char *pguser, *pgpass;
-
-  PGconn *conn;
-
-  pghost = NULL;
-  pgport = NULL;
-  
-  pgoptions = NULL;           /* special options to start up the backend
-                                 * server */
-  pgtty = NULL;               /* debugging tty for the backend server */
-
-  pguser = NULL;
-  pgpass = NULL;
-
-  /* override the NULLs with the user params if passed */
-  if(my_opts->remotehost)
-    {
-      pghost = (char *) malloc (128);
-      sscanf(my_opts->_hostname, "%s", pghost);
-    }
-    
-  if(my_opts->remoteport)
-    {
-      pgport = (char *) malloc (6);
-      sscanf(my_opts->_port, "%s", pgport);
-    }
-
-  if(my_opts->remoteuser)
-    {
-      pguser = (char *) malloc (128);
-      sscanf(my_opts->_username, "%s", pguser);
-    }
-
-  if(my_opts->remotepass)
-    {
-      pgpass = (char *) malloc (128);
-      sscanf(my_opts->_password, "%s", pgpass);
-    }
-
-  /* login */
-  conn = PQsetdbLogin(pghost, pgport, pgoptions, pgtty, dbName, pguser, pgpass);
-
-  /* deal with errors */
-  if (PQstatus(conn) == CONNECTION_BAD)
-    {
-      fprintf(stderr, "Connection to database '%s' failed.\n", dbName);
-      fprintf(stderr, "%s", PQerrorMessage(conn));
-      
-      
-      PQfinish(conn);
-      exit(1);
-
-    }
-
-  /* return the conn if good */
-  return conn;
+	char	   *pghost,
+			   *pgport;
+	char	   *pgoptions,
+			   *pgtty;
+	char	   *pguser,
+			   *pgpass;
+
+	PGconn	   *conn;
+
+	pghost = NULL;
+	pgport = NULL;
+
+	pgoptions = NULL;			/* special options to start up the backend
+								 * server */
+	pgtty = NULL;				/* debugging tty for the backend server */
+
+	pguser = NULL;
+	pgpass = NULL;
+
+	/* override the NULLs with the user params if passed */
+	if (my_opts->remotehost)
+	{
+		pghost = (char *) malloc(128);
+		sscanf(my_opts->_hostname, "%s", pghost);
+	}
+
+	if (my_opts->remoteport)
+	{
+		pgport = (char *) malloc(6);
+		sscanf(my_opts->_port, "%s", pgport);
+	}
+
+	if (my_opts->remoteuser)
+	{
+		pguser = (char *) malloc(128);
+		sscanf(my_opts->_username, "%s", pguser);
+	}
+
+	if (my_opts->remotepass)
+	{
+		pgpass = (char *) malloc(128);
+		sscanf(my_opts->_password, "%s", pgpass);
+	}
+
+	/* login */
+	conn = PQsetdbLogin(pghost, pgport, pgoptions, pgtty, dbName, pguser, pgpass);
+
+	/* deal with errors */
+	if (PQstatus(conn) == CONNECTION_BAD)
+	{
+		fprintf(stderr, "Connection to database '%s' failed.\n", dbName);
+		fprintf(stderr, "%s", PQerrorMessage(conn));
+
+
+		PQfinish(conn);
+		exit(1);
+
+	}
+
+	/* return the conn if good */
+	return conn;
 }
 
 /* If the sql_ command has an error,  this function looks up the error number and prints it out. */
-void sql_exec_error (int error_number)
+void
+sql_exec_error(int error_number)
 {
-  fprintf(stderr, "Error number %i.\n", error_number);
-  switch(error_number)
-    {
-    case 3:
-      fprintf(stderr,  "Error:  PGRES_COPY_OUT\n");
-      break;
-      
-    case 4:
-      fprintf(stderr,  "Error:  PGRES_COPY_IN\n");
-      break;
-      
-    case 5:
-      fprintf(stderr,  "Error:  PGRES_BAD_RESPONCE\n");
-      break;
-      
-    case 6:
-      fprintf(stderr,  "Error:  PGRES_NONFATAL_ERROR\n");
-      break;
-      
-    case 7:
-      fprintf(stderr,  "Error:  PGRES_FATAL_ERROR\n");
-      break;
-    }
+	fprintf(stderr, "Error number %i.\n", error_number);
+	switch (error_number)
+	{
+		case 3:
+			fprintf(stderr, "Error:  PGRES_COPY_OUT\n");
+			break;
+
+		case 4:
+			fprintf(stderr, "Error:  PGRES_COPY_IN\n");
+			break;
+
+		case 5:
+			fprintf(stderr, "Error:  PGRES_BAD_RESPONCE\n");
+			break;
+
+		case 6:
+			fprintf(stderr, "Error:  PGRES_NONFATAL_ERROR\n");
+			break;
+
+		case 7:
+			fprintf(stderr, "Error:  PGRES_FATAL_ERROR\n");
+			break;
+	}
 }
 
 /* actual code to make call to the database and print the output data */
-int sql_exec(PGconn *conn, char *todo, int match)
+int
+sql_exec(PGconn *conn, char *todo, int match)
 {
-  PGresult *res;
-
-  int numbfields;
-  int error_number;
-  int i, len;
-
-  /* make the call */
-  res = PQexec(conn, todo);
-
-  /* check and deal with errors */
-  if (!res || PQresultStatus(res) > 2)
-    {
-      error_number = PQresultStatus(res);
-      fprintf(stderr, "There was an error in the SQL command:\n%s\n", todo);
-      sql_exec_error(error_number);
-      fprintf(stderr,  "PQerrorMessage = %s\n", PQerrorMessage(conn));
-	    
-      PQclear(res);
-      PQfinish(conn);
-      exit(-1);
-    }
-
-  /* get the number of fields */
-  numbfields = PQntuples(res);
-
-  /* if we only expect 1 and there mode than,  return -2 */
-  if(match == 1 && numbfields > 1)
-    return -2;
-
-  /* return -1 if there aren't any returns */
-  if(match == 1 && numbfields < 1)
-    return -1;
-
-  /* for each row,  dump the information */
-  for(i = 0; i < numbfields; i++)
-    {
-      len = strlen(PQgetvalue(res, i, 0));
-
-      fprintf(stdout, "%-6s = %s\n", PQgetvalue(res, i, 0), PQgetvalue(res, i, 1));
-    }
-
-  /* clean the PGconn once done */
-  PQclear(res);
-
-  return 0;
+	PGresult   *res;
+
+	int			numbfields;
+	int			error_number;
+	int			i,
+				len;
+
+	/* make the call */
+	res = PQexec(conn, todo);
+
+	/* check and deal with errors */
+	if (!res || PQresultStatus(res) > 2)
+	{
+		error_number = PQresultStatus(res);
+		fprintf(stderr, "There was an error in the SQL command:\n%s\n", todo);
+		sql_exec_error(error_number);
+		fprintf(stderr, "PQerrorMessage = %s\n", PQerrorMessage(conn));
+
+		PQclear(res);
+		PQfinish(conn);
+		exit(-1);
+	}
+
+	/* get the number of fields */
+	numbfields = PQntuples(res);
+
+	/* if we only expect 1 and there mode than,  return -2 */
+	if (match == 1 && numbfields > 1)
+		return -2;
+
+	/* return -1 if there aren't any returns */
+	if (match == 1 && numbfields < 1)
+		return -1;
+
+	/* for each row,  dump the information */
+	for (i = 0; i < numbfields; i++)
+	{
+		len = strlen(PQgetvalue(res, i, 0));
+
+		fprintf(stdout, "%-6s = %s\n", PQgetvalue(res, i, 0), PQgetvalue(res, i, 1));
+	}
+
+	/* clean the PGconn once done */
+	PQclear(res);
+
+	return 0;
 }
 
 /* dump all databases know by the system table */
-void sql_exec_dumpdb(PGconn *conn)
+void
+sql_exec_dumpdb(PGconn *conn)
 {
-  char *todo;
+	char	   *todo;
 
-  todo = (char *) malloc (1024);
+	todo = (char *) malloc(1024);
 
-  /* get the oid and database name from the system pg_database table */
-  sprintf(todo, "select oid,datname from pg_database");
+	/* get the oid and database name from the system pg_database table */
+	sprintf(todo, "select oid,datname from pg_database");
 
-  sql_exec(conn, todo, 0);
+	sql_exec(conn, todo, 0);
 }
 
 /* display all tables in whatever db we are connected to.  don't display the
    system tables by default */
-void sql_exec_dumptable(PGconn *conn, int systables)
+void
+sql_exec_dumptable(PGconn *conn, int systables)
 {
-  char *todo;
+	char	   *todo;
 
-  todo = (char *) malloc (1024);
+	todo = (char *) malloc(1024);
 
-  /* don't exclude the systables if this is set */
-  if(systables == 1)
-    sprintf(todo, "select relfilenode,relname from pg_class order by relname");
-  else
-    sprintf(todo, "select relfilenode,relname from pg_class where relname not like 'pg_%%' order by relname");
+	/* don't exclude the systables if this is set */
+	if (systables == 1)
+		sprintf(todo, "select relfilenode,relname from pg_class order by relname");
+	else
+		sprintf(todo, "select relfilenode,relname from pg_class where relname not like 'pg_%%' order by relname");
 
-  sql_exec(conn, todo, 0);
+	sql_exec(conn, todo, 0);
 }
 
 /* display the oid for a given tablename for whatever db we are connected
-   to.  do we want to allow %bar% in the search?  Not now. */
-void sql_exec_searchtable(PGconn *conn, char *tablename)
+   to.	do we want to allow %bar% in the search?  Not now. */
+void
+sql_exec_searchtable(PGconn *conn, char *tablename)
 {
-  int returnvalue;
-  char *todo;
-
-  todo = (char *) malloc (1024);
-
-  /* get the oid and tablename where the name matches tablename */
-  sprintf(todo, "select relfilenode,relname from pg_class where relname = '%s'", tablename);
-
-  returnvalue = sql_exec(conn, todo, 1);
-
-  /* deal with the return errors */
-  if(returnvalue == -1)
-    {
-      printf("No tables with that name found\n");
-    }
-  
-  if(returnvalue == -2)
-    {
-      printf("VERY scary:  more than one table with that name found!!\n");
-    }
+	int			returnvalue;
+	char	   *todo;
+
+	todo = (char *) malloc(1024);
+
+	/* get the oid and tablename where the name matches tablename */
+	sprintf(todo, "select relfilenode,relname from pg_class where relname = '%s'", tablename);
+
+	returnvalue = sql_exec(conn, todo, 1);
+
+	/* deal with the return errors */
+	if (returnvalue == -1)
+		printf("No tables with that name found\n");
+
+	if (returnvalue == -2)
+		printf("VERY scary:  more than one table with that name found!!\n");
 }
 
 /* same as above */
-void sql_exec_searchoid(PGconn *conn, int oid)
+void
+sql_exec_searchoid(PGconn *conn, int oid)
 {
-  int returnvalue;
-  char *todo;
+	int			returnvalue;
+	char	   *todo;
+
+	todo = (char *) malloc(1024);
 
-  todo = (char *) malloc (1024);
+	sprintf(todo, "select relfilenode,relname from pg_class where oid = %i", oid);
 
-  sprintf(todo, "select relfilenode,relname from pg_class where oid = %i", oid);
+	returnvalue = sql_exec(conn, todo, 1);
 
-  returnvalue = sql_exec(conn, todo, 1);
+	if (returnvalue == -1)
+		printf("No tables with that oid found\n");
 
-  if(returnvalue == -1)
-    {
-      printf("No tables with that oid found\n");
-    }
-  
-  if(returnvalue == -2)
-    {
-      printf("VERY scary:  more than one table with that oid found!!\n");
-    }
+	if (returnvalue == -2)
+		printf("VERY scary:  more than one table with that oid found!!\n");
 }
 
-int main(int argc, char **argv)
+int
+main(int argc, char **argv)
 {
-  struct options *my_opts;
-  PGconn *pgconn;
-
-  my_opts = (struct options *) malloc (sizeof(struct options));
-
-  /* parse the opts */
-  get_opts(argc, argv, my_opts);
-
-  /* display all the tables in the database */
-  if(my_opts->getdatabase & my_opts->gettable)
-    {
-      printf("Oid of table %s from database \"%s\":\n", my_opts->_tbname, my_opts->_dbname);
-      printf("_______________________________\n");
-
-      pgconn = sql_conn(my_opts->_dbname, my_opts);
-      sql_exec_searchtable(pgconn, my_opts->_tbname);
-      PQfinish(pgconn);
-
-      exit(1);
-    }
-  
-  /* search for the tablename of the given OID */
-  if(my_opts->getdatabase & my_opts->getoid)
-    {
-      printf("Tablename of oid %i from database \"%s\":\n", my_opts->_oid, my_opts->_dbname);
-      printf("---------------------------------\n");
-
-      pgconn = sql_conn(my_opts->_dbname, my_opts);
-      sql_exec_searchoid(pgconn, my_opts->_oid);
-      PQfinish(pgconn);
-
-      exit(1);
-    }
-
-  /* search for the oid for the given tablename */
-  if(my_opts->getdatabase)
-    {
-      printf("All tables from database \"%s\":\n", my_opts->_dbname);
-      printf("---------------------------------\n");
-
-      pgconn = sql_conn(my_opts->_dbname, my_opts);
-      sql_exec_dumptable(pgconn, my_opts->systables);
-      PQfinish(pgconn);
-
-      exit(1);
-    }
-
-  /* display all the databases for the server we are connected to.. */
-  printf("All databases:\n");
-  printf("---------------------------------\n");  
-  
-  pgconn = sql_conn("template1", my_opts);
-  sql_exec_dumpdb(pgconn);
-  PQfinish(pgconn);
-
-  exit(0);
+	struct options *my_opts;
+	PGconn	   *pgconn;
+
+	my_opts = (struct options *) malloc(sizeof(struct options));
+
+	/* parse the opts */
+	get_opts(argc, argv, my_opts);
+
+	/* display all the tables in the database */
+	if (my_opts->getdatabase & my_opts->gettable)
+	{
+		printf("Oid of table %s from database \"%s\":\n", my_opts->_tbname, my_opts->_dbname);
+		printf("_______________________________\n");
+
+		pgconn = sql_conn(my_opts->_dbname, my_opts);
+		sql_exec_searchtable(pgconn, my_opts->_tbname);
+		PQfinish(pgconn);
+
+		exit(1);
+	}
+
+	/* search for the tablename of the given OID */
+	if (my_opts->getdatabase & my_opts->getoid)
+	{
+		printf("Tablename of oid %i from database \"%s\":\n", my_opts->_oid, my_opts->_dbname);
+		printf("---------------------------------\n");
+
+		pgconn = sql_conn(my_opts->_dbname, my_opts);
+		sql_exec_searchoid(pgconn, my_opts->_oid);
+		PQfinish(pgconn);
+
+		exit(1);
+	}
+
+	/* search for the oid for the given tablename */
+	if (my_opts->getdatabase)
+	{
+		printf("All tables from database \"%s\":\n", my_opts->_dbname);
+		printf("---------------------------------\n");
+
+		pgconn = sql_conn(my_opts->_dbname, my_opts);
+		sql_exec_dumptable(pgconn, my_opts->systables);
+		PQfinish(pgconn);
+
+		exit(1);
+	}
+
+	/* display all the databases for the server we are connected to.. */
+	printf("All databases:\n");
+	printf("---------------------------------\n");
+
+	pgconn = sql_conn("template1", my_opts);
+	sql_exec_dumpdb(pgconn);
+	PQfinish(pgconn);
+
+	exit(0);
 }
diff --git a/contrib/pg_controldata/pg_controldata.c b/contrib/pg_controldata/pg_controldata.c
index dc666c1fcf..93fe9a54c9 100644
--- a/contrib/pg_controldata/pg_controldata.c
+++ b/contrib/pg_controldata/pg_controldata.c
@@ -6,7 +6,7 @@
  * copyright (c) Oliver Elphick <[email protected]>, 2001;
  * licence: BSD
  *
- * $Header: /cvsroot/pgsql/contrib/pg_controldata/Attic/pg_controldata.c,v 1.2 2001/03/13 01:17:40 tgl Exp $
+ * $Header: /cvsroot/pgsql/contrib/pg_controldata/Attic/pg_controldata.c,v 1.3 2001/03/22 03:59:09 momjian Exp $
  */
 #include "postgres.h"
 
@@ -24,7 +24,7 @@ dbState(DBState state)
 {
 	switch (state)
 	{
-		case DB_STARTUP:
+			case DB_STARTUP:
 			return "STARTUP";
 		case DB_SHUTDOWNED:
 			return "SHUTDOWNED";
@@ -43,16 +43,17 @@ int
 main()
 {
 	ControlFileData ControlFile;
-	int fd;
-	char ControlFilePath[MAXPGPATH];
-	char *DataDir;
-	crc64 crc;
-	char pgctime_str[32];
-	char ckpttime_str[32];
+	int			fd;
+	char		ControlFilePath[MAXPGPATH];
+	char	   *DataDir;
+	crc64		crc;
+	char		pgctime_str[32];
+	char		ckpttime_str[32];
 
 	DataDir = getenv("PGDATA");
-	if ( DataDir == NULL ) {
-		fprintf(stderr,"PGDATA is not defined\n");
+	if (DataDir == NULL)
+	{
+		fprintf(stderr, "PGDATA is not defined\n");
 		exit(1);
 	}
 
@@ -73,8 +74,8 @@ main()
 
 	/* Check the CRC. */
 	INIT_CRC64(crc);
-	COMP_CRC64(crc, 
-			   (char*) &ControlFile + sizeof(crc64),
+	COMP_CRC64(crc,
+			   (char *) &ControlFile + sizeof(crc64),
 			   sizeof(ControlFileData) - sizeof(crc64));
 	FIN_CRC64(crc);
 
@@ -93,7 +94,7 @@ main()
 		   "Database state:                       %s\n"
 		   "pg_control last modified:             %s\n"
 		   "Current log file id:                  %u\n"
-	       "Next log file segment:                %u\n"
+		   "Next log file segment:                %u\n"
 		   "Latest checkpoint location:           %X/%X\n"
 		   "Prior checkpoint location:            %X/%X\n"
 		   "Latest checkpoint's REDO location:    %X/%X\n"
diff --git a/contrib/pg_dumplo/lo_export.c b/contrib/pg_dumplo/lo_export.c
index 5a2a1614a5..6a62c88bc6 100644
--- a/contrib/pg_dumplo/lo_export.c
+++ b/contrib/pg_dumplo/lo_export.c
@@ -1,20 +1,20 @@
 /* -------------------------------------------------------------------------
  * pg_dumplo
  *
- * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/lo_export.c,v 1.5 2001/01/24 19:42:44 momjian Exp $
+ * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/lo_export.c,v 1.6 2001/03/22 03:59:10 momjian Exp $
  *
  *					Karel Zak 1999-2000
  * -------------------------------------------------------------------------
  */
 
-#include <stdio.h>	
+#include <stdio.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <fcntl.h>
-#include <errno.h>                            
+#include <errno.h>
 #include <time.h>
 
 #include <libpq-fe.h>
@@ -22,17 +22,17 @@
 
 #include "pg_dumplo.h"
 
-extern int 	errno;        
+extern int	errno;
 
 
-void 
-load_lolist( LODumpMaster *pgLO ) 
+void
+load_lolist(LODumpMaster * pgLO)
 {
-	LOlist		*ll;
-	int		i;
-	int		n;
+	LOlist	   *ll;
+	int			i;
+	int			n;
 
- 	/* ----------
+	/* ----------
 	 * Now find any candidate tables who have columns of type oid.
 	 *
 	 * NOTE: System tables including pg_largeobject will be ignored.
@@ -40,8 +40,8 @@ load_lolist( LODumpMaster *pgLO )
 	 *
 	 * NOTE: the system oid column is ignored, as it has attnum < 1.
 	 * This shouldn't matter for correctness, but it saves time.
- 	 * ----------
- 	 */	
+	 * ----------
+	 */
 	pgLO->res = PQexec(pgLO->conn,
 					   "SELECT c.relname, a.attname "
 					   "FROM pg_class c, pg_attribute a, pg_type t "
@@ -52,43 +52,49 @@ load_lolist( LODumpMaster *pgLO )
 					   "    AND c.relkind = 'r' "
 					   "    AND c.relname NOT LIKE 'pg_%'");
 
-	if (PQresultStatus(pgLO->res) != PGRES_TUPLES_OK) {
+	if (PQresultStatus(pgLO->res) != PGRES_TUPLES_OK)
+	{
 		fprintf(stderr, "%s: Failed to get LO OIDs:\n%s", progname,
 				PQerrorMessage(pgLO->conn));
 		exit(RE_ERROR);
 	}
 
-	if ((n = PQntuples(pgLO->res)) == 0) {
+	if ((n = PQntuples(pgLO->res)) == 0)
+	{
 		fprintf(stderr, "%s: No OID columns in the database.\n", progname);
 		exit(RE_ERROR);
- 	}
-	
+	}
+
 	pgLO->lolist = (LOlist *) malloc((n + 1) * sizeof(LOlist));
-	
-	if (!pgLO->lolist) {
+
+	if (!pgLO->lolist)
+	{
 		fprintf(stderr, "%s: can't allocate memory\n", progname);
 		exit(RE_ERROR);
-  	}
-  	
-	for (i = 0, ll = pgLO->lolist; i < n; i++, ll++) {
+	}
+
+	for (i = 0, ll = pgLO->lolist; i < n; i++, ll++)
+	{
 		ll->lo_table = strdup(PQgetvalue(pgLO->res, i, 0));
-		ll->lo_attr  = strdup(PQgetvalue(pgLO->res, i, 1));
+		ll->lo_attr = strdup(PQgetvalue(pgLO->res, i, 1));
 	}
- 	ll->lo_table = ll->lo_attr = (char *) NULL;
-	
+	ll->lo_table = ll->lo_attr = (char *) NULL;
+
 	PQclear(pgLO->res);
 }
 
-void 
-pglo_export(LODumpMaster *pgLO)
+void
+pglo_export(LODumpMaster * pgLO)
 {
-	LOlist		*ll;
-	int		tuples;
+	LOlist	   *ll;
+	int			tuples;
 	char		path[BUFSIZ],
-			Qbuff[QUERY_BUFSIZ];
-	
-	if (pgLO->action != ACTION_SHOW) {
-		time_t	t;
+				Qbuff[QUERY_BUFSIZ];
+
+	if (pgLO->action != ACTION_SHOW)
+	{
+		time_t		t;
+
 		time(&t);
 		fprintf(pgLO->index, "#\n# This is the PostgreSQL large object dump index\n#\n");
 		fprintf(pgLO->index, "#\tDate:     %s", ctime(&t));
@@ -97,90 +103,102 @@ pglo_export(LODumpMaster *pgLO)
 		fprintf(pgLO->index, "#\tUser:     %s\n", pgLO->user);
 		fprintf(pgLO->index, "#\n# oid\ttable\tattribut\tinfile\n#\n");
 	}
-	
+
 	pgLO->counter = 0;
 
-	for(ll=pgLO->lolist; ll->lo_table != NULL; ll++) {
-		
+	for (ll = pgLO->lolist; ll->lo_table != NULL; ll++)
+	{
+
 		/* ----------
 		 * Query: find the LOs referenced by this column
 		 * ----------
 		 */
 		sprintf(Qbuff, "SELECT DISTINCT l.loid FROM \"%s\" x, pg_largeobject l WHERE x.\"%s\" = l.loid",
 				ll->lo_table, ll->lo_attr);
-		
+
 		/* puts(Qbuff); */
-			
+
 		pgLO->res = PQexec(pgLO->conn, Qbuff);
 
-        if (PQresultStatus(pgLO->res) != PGRES_TUPLES_OK) {
+		if (PQresultStatus(pgLO->res) != PGRES_TUPLES_OK)
+		{
 			fprintf(stderr, "%s: Failed to get LO OIDs:\n%s", progname,
 					PQerrorMessage(pgLO->conn));
-        }
-		else if ((tuples = PQntuples(pgLO->res)) == 0) {
+		}
+		else if ((tuples = PQntuples(pgLO->res)) == 0)
+		{
 			if (!pgLO->quiet && pgLO->action == ACTION_EXPORT_ATTR)
 				printf("%s: no large objects in \"%s\".\"%s\"\n",
-					   progname, ll->lo_table, ll->lo_attr);	
-		} else {
-		
-			int	t;
-			char	*val;
-	
+					   progname, ll->lo_table, ll->lo_attr);
+		}
+		else
+		{
+
+			int			t;
+			char	   *val;
+
 			/* ----------
 			 * Create DIR/FILE
 			 * ----------
 			 */
-			if (pgLO->action != ACTION_SHOW) {
-			
+			if (pgLO->action != ACTION_SHOW)
+			{
+
 				sprintf(path, "%s/%s/%s", pgLO->space, pgLO->db,
 						ll->lo_table);
 
-				if (mkdir(path, DIR_UMASK) == -1) {
-					if (errno != EEXIST) {
+				if (mkdir(path, DIR_UMASK) == -1)
+				{
+					if (errno != EEXIST)
+					{
 						perror(path);
-						exit(RE_ERROR);					
-					}	
+						exit(RE_ERROR);
+					}
 				}
 
 				sprintf(path, "%s/%s/%s/%s", pgLO->space, pgLO->db,
-						ll->lo_table, ll->lo_attr);          
-				
-				if (mkdir(path, DIR_UMASK) == -1) {
-					if (errno != EEXIST) {
+						ll->lo_table, ll->lo_attr);
+
+				if (mkdir(path, DIR_UMASK) == -1)
+				{
+					if (errno != EEXIST)
+					{
 						perror(path);
-						exit(RE_ERROR);					
-					}	
+						exit(RE_ERROR);
+					}
 				}
-				
+
 				if (!pgLO->quiet)
-					printf("dump %s.%s (%d large obj)\n", 
-						ll->lo_table, ll->lo_attr, tuples);
+					printf("dump %s.%s (%d large obj)\n",
+						   ll->lo_table, ll->lo_attr, tuples);
 			}
 
 			pgLO->counter += tuples;
-			
-			for(t=0; t<tuples; t++) {
-				Oid lo;
-				
+
+			for (t = 0; t < tuples; t++)
+			{
+				Oid			lo;
+
 				val = PQgetvalue(pgLO->res, t, 0);
-				
+
 				lo = atooid(val);
-				
-				if (pgLO->action == ACTION_SHOW) {
+
+				if (pgLO->action == ACTION_SHOW)
+				{
 					printf("%s.%s: %u\n", ll->lo_table, ll->lo_attr, lo);
 					continue;
 				}
-				
-				sprintf(path, "%s/%s/%s/%s/%s", pgLO->space, 
-					pgLO->db, ll->lo_table, ll->lo_attr, val);
-				
-				if (lo_export(pgLO->conn, lo, path) < 0) 
+
+				sprintf(path, "%s/%s/%s/%s/%s", pgLO->space,
+						pgLO->db, ll->lo_table, ll->lo_attr, val);
+
+				if (lo_export(pgLO->conn, lo, path) < 0)
 					fprintf(stderr, "%s: lo_export failed:\n%s", progname,
 							PQerrorMessage(pgLO->conn));
-					
-				else 
-					fprintf(pgLO->index, "%s\t%s\t%s\t%s/%s/%s/%s\n", val, 
-						ll->lo_table, ll->lo_attr, pgLO->db, ll->lo_table, ll->lo_attr, val);
+
+				else
+					fprintf(pgLO->index, "%s\t%s\t%s\t%s/%s/%s/%s\n", val,
+							ll->lo_table, ll->lo_attr, pgLO->db, ll->lo_table, ll->lo_attr, val);
 			}
 		}
 
diff --git a/contrib/pg_dumplo/lo_import.c b/contrib/pg_dumplo/lo_import.c
index 996bdf9e27..ff8929d6d6 100644
--- a/contrib/pg_dumplo/lo_import.c
+++ b/contrib/pg_dumplo/lo_import.c
@@ -1,20 +1,20 @@
 /* -------------------------------------------------------------------------
  * pg_dumplo
  *
- * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/lo_import.c,v 1.3 2001/01/24 19:42:45 momjian Exp $
+ * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/lo_import.c,v 1.4 2001/03/22 03:59:10 momjian Exp $
  *
  *					Karel Zak 1999-2000
  * -------------------------------------------------------------------------
  */
 
-#include <stdio.h>	
+#include <stdio.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <fcntl.h>
-#include <errno.h>                            
+#include <errno.h>
 #include <time.h>
 
 #include <libpq-fe.h>
@@ -22,76 +22,82 @@
 
 #include "pg_dumplo.h"
 
-extern int 	errno;        
+extern int	errno;
 
-void 
-pglo_import(LODumpMaster *pgLO)
+void
+pglo_import(LODumpMaster * pgLO)
 {
 	LOlist		loa;
-	Oid 		new_oid;
-	char		tab[MAX_TABLE_NAME], attr[MAX_ATTR_NAME],
-			path[BUFSIZ], lo_path[BUFSIZ],
-			Qbuff[QUERY_BUFSIZ];
-	
-	while(fgets(Qbuff, QUERY_BUFSIZ, pgLO->index)) {
-		
+	Oid			new_oid;
+	char		tab[MAX_TABLE_NAME],
+				attr[MAX_ATTR_NAME],
+				path[BUFSIZ],
+				lo_path[BUFSIZ],
+				Qbuff[QUERY_BUFSIZ];
+
+	while (fgets(Qbuff, QUERY_BUFSIZ, pgLO->index))
+	{
+
 		if (*Qbuff == '#')
 			continue;
 
-		if (! pgLO->remove && ! pgLO->quiet)
+		if (!pgLO->remove && !pgLO->quiet)
 			printf(Qbuff);
-		
-		sscanf(Qbuff, "%u\t%s\t%s\t%s\n", &loa.lo_oid, tab, attr, path); 
+
+		sscanf(Qbuff, "%u\t%s\t%s\t%s\n", &loa.lo_oid, tab, attr, path);
 		loa.lo_table = tab;
-		loa.lo_attr  = attr;
+		loa.lo_attr = attr;
 
-		sprintf(lo_path, "%s/%s", pgLO->space, path); 
+		sprintf(lo_path, "%s/%s", pgLO->space, path);
 
 		/* ----------
 		 * Import LO
 		 * ----------
 		 */
-		if ((new_oid = lo_import(pgLO->conn, lo_path)) == 0) {
-		
+		if ((new_oid = lo_import(pgLO->conn, lo_path)) == 0)
+		{
+
 			fprintf(stderr, "%s: %s\n", progname, PQerrorMessage(pgLO->conn));
-			
+
 			PQexec(pgLO->conn, "ROLLBACK");
 			fprintf(stderr, "\n%s: ROLLBACK\n", progname);
 			exit(RE_ERROR);
 		}
 
-		if (pgLO->remove) {
+		if (pgLO->remove)
+		{
 			notice(pgLO, FALSE);
-			if (lo_unlink(pgLO->conn, loa.lo_oid) < 0) 
-				fprintf(stderr, "%s: can't remove LO %u:\n%s", 
-					progname, loa.lo_oid, PQerrorMessage(pgLO->conn));
-					
+			if (lo_unlink(pgLO->conn, loa.lo_oid) < 0)
+				fprintf(stderr, "%s: can't remove LO %u:\n%s",
+						progname, loa.lo_oid, PQerrorMessage(pgLO->conn));
+
 			else if (!pgLO->quiet)
-				printf("remove old %u and create new %u\n", 
-					loa.lo_oid, new_oid);	
-			notice(pgLO, TRUE);	
+				printf("remove old %u and create new %u\n",
+					   loa.lo_oid, new_oid);
+			notice(pgLO, TRUE);
 		}
-		
+
 		pgLO->counter++;
-	
+
 		/* ----------
 		 * UPDATE oid in tab
 		 * ----------
 		 */
-		sprintf(Qbuff, "UPDATE \"%s\" SET \"%s\"=%u WHERE \"%s\"=%u", 
+		sprintf(Qbuff, "UPDATE \"%s\" SET \"%s\"=%u WHERE \"%s\"=%u",
 			loa.lo_table, loa.lo_attr, new_oid, loa.lo_attr, loa.lo_oid);
 
-		/*fprintf(stderr, Qbuff);*/
-			
+		/* fprintf(stderr, Qbuff); */
+
 		pgLO->res = PQexec(pgLO->conn, Qbuff);
-	
-		if (PQresultStatus(pgLO->res) != PGRES_COMMAND_OK) {
-			fprintf(stderr, "%s: %s\n",progname, PQerrorMessage(pgLO->conn));
+
+		if (PQresultStatus(pgLO->res) != PGRES_COMMAND_OK)
+		{
+			fprintf(stderr, "%s: %s\n", progname, PQerrorMessage(pgLO->conn));
 			PQclear(pgLO->res);
 			PQexec(pgLO->conn, "ROLLBACK");
 			fprintf(stderr, "\n%s: ROLLBACK\n", progname);
 			exit(RE_ERROR);
-		}	
+		}
 		PQclear(pgLO->res);
-	}	
- }
+	}
+}
diff --git a/contrib/pg_dumplo/main.c b/contrib/pg_dumplo/main.c
index e8ff2f72e0..3878aeca02 100644
--- a/contrib/pg_dumplo/main.c
+++ b/contrib/pg_dumplo/main.c
@@ -1,7 +1,7 @@
 /* -------------------------------------------------------------------------
  * pg_dumplo
  *
- * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/main.c,v 1.6 2001/02/10 02:31:25 tgl Exp $
+ * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/main.c,v 1.7 2001/03/22 03:59:10 momjian Exp $
  *
  *					Karel Zak 1999-2000
  * -------------------------------------------------------------------------
@@ -12,238 +12,254 @@
 #include "postgres_fe.h"
 #endif
 
-#include <stdio.h>	
+#include <stdio.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <string.h>
-#include <errno.h>                            
+#include <errno.h>
 
 #include <libpq-fe.h>
 #include <libpq/libpq-fs.h>
 
-#include "pg_dumplo.h" 
+#include "pg_dumplo.h"
 
 #ifdef HAVE_GETOPT_LONG
-	#include <getopt.h>
-	#define no_argument 0
-	#define required_argument 1
+#include <getopt.h>
+#define no_argument 0
+#define required_argument 1
 #endif
-        
-extern int 	errno;        
 
-char	*progname = NULL;
+extern int	errno;
 
-int main(int argc, char **argv);
+char	   *progname = NULL;
+
+int			main(int argc, char **argv);
 static void usage(void);
-static void parse_lolist (LODumpMaster *pgLO);
-        
+static void parse_lolist(LODumpMaster * pgLO);
+
 
 /*-----
  *	The mother of all C functions
  *-----
  */
-int 
+int
 main(int argc, char **argv)
-{	
-	LODumpMaster	_pgLO, *pgLO = &_pgLO;
-	char		*pwd = NULL;
-
-	pgLO->argv 	= argv;
-	pgLO->argc 	= argc;
-	pgLO->action 	= 0;
-	pgLO->lolist 	= NULL;
-	pgLO->user 	= NULL;
-	pgLO->db	= NULL;
-	pgLO->host	= NULL;
-	pgLO->space	= NULL;
-	pgLO->index	= NULL;
-	pgLO->remove	= FALSE;
-	pgLO->quiet	= FALSE; 
-	pgLO->counter	= 0;
+{
+	LODumpMaster _pgLO,
+			   *pgLO = &_pgLO;
+	char	   *pwd = NULL;
+
+	pgLO->argv = argv;
+	pgLO->argc = argc;
+	pgLO->action = 0;
+	pgLO->lolist = NULL;
+	pgLO->user = NULL;
+	pgLO->db = NULL;
+	pgLO->host = NULL;
+	pgLO->space = NULL;
+	pgLO->index = NULL;
+	pgLO->remove = FALSE;
+	pgLO->quiet = FALSE;
+	pgLO->counter = 0;
 	pgLO->lolist_start = 0;
-	
+
 	progname = argv[0];
 
 	/* ----------
 	 * Parse ARGV
 	 * ----------
 	 */
-	if (argc > 1) {
-      		int	arg;
-      		extern int optind;
-
-#ifdef HAVE_GETOPT_LONG      	
-		int	l_index=0;	
-      		static struct option l_opt[] = {
-      			{ "help",	no_argument, 0, 'h' },		
-			{ "user",	required_argument, 0, 'u' },
-			{ "pwd",	required_argument, 0, 'p' },
-			{ "db",		required_argument, 0, 'd' },
-			{ "host",	required_argument, 0, 'h' },
-			{ "space",	required_argument, 0, 's' },
-			{ "import",	no_argument, 0, 'i' },
-			{ "export",	no_argument, 0, 'e' },
-			{ "remove",	no_argument, 0, 'r' },
-			{ "quiet",	no_argument, 0, 'q' },
-			{ "all",	no_argument, 0, 'a' },
-			{ "show",	no_argument, 0, 'w' },
-			{ NULL, 0, 0, 0 }
-      		};     	
-
-		while((arg = getopt_long(argc, argv, "?aehu:p:qd:l:t:irs:w", l_opt, &l_index)) != -1) {
+	if (argc > 1)
+	{
+		int			arg;
+		extern int	optind;
+
+#ifdef HAVE_GETOPT_LONG
+		int			l_index = 0;
+		static struct option l_opt[] = {
+			{"help", no_argument, 0, 'h'},
+			{"user", required_argument, 0, 'u'},
+			{"pwd", required_argument, 0, 'p'},
+			{"db", required_argument, 0, 'd'},
+			{"host", required_argument, 0, 'h'},
+			{"space", required_argument, 0, 's'},
+			{"import", no_argument, 0, 'i'},
+			{"export", no_argument, 0, 'e'},
+			{"remove", no_argument, 0, 'r'},
+			{"quiet", no_argument, 0, 'q'},
+			{"all", no_argument, 0, 'a'},
+			{"show", no_argument, 0, 'w'},
+			{NULL, 0, 0, 0}
+		};
+
+		while ((arg = getopt_long(argc, argv, "?aehu:p:qd:l:t:irs:w", l_opt, &l_index)) != -1)
+		{
 #else
-		while((arg = getopt(argc, argv, "?aehu:p:qd:l:t:irs:w")) != -1) {                
+		while ((arg = getopt(argc, argv, "?aehu:p:qd:l:t:irs:w")) != -1)
+		{
 #endif
-			switch(arg) {
-      			case '?':
-      			case 'h':
-      				usage();
+			switch (arg)
+			{
+				case '?':
+				case 'h':
+					usage();
 					exit(RE_OK);
-        		case 'u':    	
-        			pgLO->user = strdup(optarg);
-        			break;	 
-        		case 't':    	
-        			pgLO->host = strdup(optarg);
-        			break;	 	
-        		case 'p':    	
-        			pwd = strdup(optarg);
-        			break;	          		
-        		case 'd':    	
-        			pgLO->db = strdup(optarg);
-        			break;
-        		case 's':    	
-        			pgLO->space = strdup(optarg);
-        			break;	
-        		case 'i':    	
-        			pgLO->action = ACTION_IMPORT;
-        			break;	
-        		case 'l':
-        			pgLO->action = ACTION_EXPORT_ATTR;
-        			pgLO->lolist_start = optind-1;
-        			parse_lolist (pgLO);
-        			break;
-        		case 'e':	
-        		case 'a':
+				case 'u':
+					pgLO->user = strdup(optarg);
+					break;
+				case 't':
+					pgLO->host = strdup(optarg);
+					break;
+				case 'p':
+					pwd = strdup(optarg);
+					break;
+				case 'd':
+					pgLO->db = strdup(optarg);
+					break;
+				case 's':
+					pgLO->space = strdup(optarg);
+					break;
+				case 'i':
+					pgLO->action = ACTION_IMPORT;
+					break;
+				case 'l':
+					pgLO->action = ACTION_EXPORT_ATTR;
+					pgLO->lolist_start = optind - 1;
+					parse_lolist(pgLO);
+					break;
+				case 'e':
+				case 'a':
 					pgLO->action = ACTION_EXPORT_ALL;
 					break;
 				case 'w':
 					pgLO->action = ACTION_SHOW;
-					break;	
-        		case 'r':
-        			pgLO->remove = TRUE;
-        			break;
-        		case 'q':
-        			pgLO->quiet = TRUE;	
-        			break;
-        		default:
-        			fprintf(stderr, "%s: bad arg -%c\n", progname, arg);
-        			usage();
-        			exit(RE_ERROR);
+					break;
+				case 'r':
+					pgLO->remove = TRUE;
+					break;
+				case 'q':
+					pgLO->quiet = TRUE;
+					break;
+				default:
+					fprintf(stderr, "%s: bad arg -%c\n", progname, arg);
+					usage();
+					exit(RE_ERROR);
 			}
-		}	
-	} else {
+		}
+	}
+	else
+	{
 		usage();
-        	exit(RE_ERROR);
-	}	
+		exit(RE_ERROR);
+	}
 
 	/* ----------
 	 * Check space
 	 * ----------
 	 */
-	if (! pgLO->space && ! pgLO->action == ACTION_SHOW) {
-		if (!(pgLO->space = getenv("PWD"))) {
+	if (!pgLO->space && !pgLO->action == ACTION_SHOW)
+	{
+		if (!(pgLO->space = getenv("PWD")))
+		{
 			fprintf(stderr, "%s: not set space for dump-tree (option '-s' or $PWD).\n", progname);
 			exit(RE_ERROR);
-		}	
+		}
 	}
-	
-	if (!pgLO->action) {
+
+	if (!pgLO->action)
+	{
 		fprintf(stderr, "%s: What do you want - export or import?\n", progname);
 		exit(RE_ERROR);
 	}
-	
+
 	/* ----------
 	 * Make connection
 	 * ----------
 	 */
-	pgLO->conn = PQsetdbLogin(pgLO->host, NULL, NULL, NULL, pgLO->db, 
-			pgLO->user, pwd);
-        
-	if (PQstatus(pgLO->conn) == CONNECTION_BAD) {
+	pgLO->conn = PQsetdbLogin(pgLO->host, NULL, NULL, NULL, pgLO->db,
+							  pgLO->user, pwd);
+
+	if (PQstatus(pgLO->conn) == CONNECTION_BAD)
+	{
 		fprintf(stderr, "%s (connection): %s\n", progname, PQerrorMessage(pgLO->conn));
 		exit(RE_ERROR);
-	}  
+	}
 	pgLO->host = PQhost(pgLO->conn) ? PQhost(pgLO->conn) : "localhost";
-	pgLO->db   = PQdb(pgLO->conn); 
-	pgLO->user = PQuser(pgLO->conn);	
-	
-	
+	pgLO->db = PQdb(pgLO->conn);
+	pgLO->user = PQuser(pgLO->conn);
+
+
 	/* ----------
 	 * Init index file
 	 * ----------
 	 */
-	if (pgLO->action != ACTION_SHOW) 
+	if (pgLO->action != ACTION_SHOW)
 		index_file(pgLO);
-	
+
 	PQexec(pgLO->conn, "BEGIN");
 
-	switch(pgLO->action) {
-	
+	switch (pgLO->action)
+	{
+
 		case ACTION_SHOW:
 		case ACTION_EXPORT_ALL:
 			load_lolist(pgLO);
 			/* FALL THROUGH */
-				
+
 		case ACTION_EXPORT_ATTR:
 			pglo_export(pgLO);
-			if (!pgLO->quiet) {
+			if (!pgLO->quiet)
+			{
 				if (pgLO->action == ACTION_SHOW)
 					printf("\nDatabase '%s' contains %d large objects.\n\n", pgLO->db, pgLO->counter);
-				else	
+				else
 					printf("\nExported %d large objects.\n\n", pgLO->counter);
 			}
 			break;
-		
+
 		case ACTION_IMPORT:
 			pglo_import(pgLO);
 			if (!pgLO->quiet)
 				printf("\nImported %d large objects.\n\n", pgLO->counter);
-			break;			
-	}	
+			break;
+	}
 
 	PQexec(pgLO->conn, "COMMIT");
-	PQfinish(pgLO->conn);	
-	
+	PQfinish(pgLO->conn);
+
 	if (pgLO->action != ACTION_SHOW)
 		fclose(pgLO->index);
-	
+
 	exit(RE_OK);
 }
 
 static void
-parse_lolist (LODumpMaster *pgLO)
+parse_lolist(LODumpMaster * pgLO)
 {
-	LOlist		*ll;
-	char		**d, 
-			*loc,
-			buff[MAX_TABLE_NAME + MAX_ATTR_NAME +1];
+	LOlist	   *ll;
+	char	  **d,
+			   *loc,
+				buff[MAX_TABLE_NAME + MAX_ATTR_NAME + 1];
 
 	pgLO->lolist = (LOlist *) malloc(pgLO->argc * sizeof(LOlist));
-	
-	if (! pgLO->lolist) {
+
+	if (!pgLO->lolist)
+	{
 		fprintf(stderr, "%s: can't allocate memory\n", progname);
 		exit(RE_ERROR);
 	}
-	
-	for(	d=pgLO->argv + pgLO->lolist_start, ll=pgLO->lolist; 
-		*d != NULL; 
-		d++, ll++) {
-		
+
+	for (d = pgLO->argv + pgLO->lolist_start, ll = pgLO->lolist;
+		 *d != NULL;
+		 d++, ll++)
+	{
+
 		strncpy(buff, *d, MAX_TABLE_NAME + MAX_ATTR_NAME);
-		
-		if ((loc = strchr(buff, '.')) == NULL) {
+
+		if ((loc = strchr(buff, '.')) == NULL)
+		{
 			fprintf(stderr, "%s: '%s' is bad 'table.attr'\n", progname, buff);
-			exit(RE_ERROR);	
+			exit(RE_ERROR);
 		}
 		*loc = '\0';
 		ll->lo_table = strdup(buff);
@@ -254,55 +270,55 @@ parse_lolist (LODumpMaster *pgLO)
 }
 
 
-static void 
+static void
 usage()
 {
 	printf("\npg_dumplo %s - PostgreSQL large objects dump\n", VERSION);
-        puts("pg_dumplo [option]\n\n"
+	puts("pg_dumplo [option]\n\n"
 
 #ifdef HAVE_GETOPT_LONG
-	
-	"-h --help                    this help\n"	
-	"-u --user=<username>         username for connection to server\n"
-	"-p --password=<password>     password for connection to server\n"	
-	"-d --db=<database>           database name\n"	
-	"-t --host=<hostname>         server hostname\n"		
-	"-s --space=<dir>             directory with dump tree (for export/import)\n"
-	"-i --import                  import large obj dump tree to DB\n"
-        "-e --export                  export (dump) large obj to dump tree\n"
-	"-l <table.attr ...>          dump attribute (columns) with LO to dump tree\n"
-	"-a --all                     dump all LO in DB (default)\n"
-	"-r --remove                  if is set '-i' try remove old LO\n"
-        "-q --quiet                   run quietly\n"
-	"-w --show                    not dump, but show all LO in DB\n" 
-	); /* puts() */ 
+
+		 "-h --help                    this help\n"
+	   "-u --user=<username>         username for connection to server\n"
+	   "-p --password=<password>     password for connection to server\n"
+		 "-d --db=<database>           database name\n"
+		 "-t --host=<hostname>         server hostname\n"
+		 "-s --space=<dir>             directory with dump tree (for export/import)\n"
+		 "-i --import                  import large obj dump tree to DB\n"
+	"-e --export                  export (dump) large obj to dump tree\n"
+		 "-l <table.attr ...>          dump attribute (columns) with LO to dump tree\n"
+		 "-a --all                     dump all LO in DB (default)\n"
+		 "-r --remove                  if is set '-i' try remove old LO\n"
+		 "-q --quiet                   run quietly\n"
+		 "-w --show                    not dump, but show all LO in DB\n"
+		);						/* puts() */
 
 #else
-	"-h                           this help\n"	
-	"-u <username>                username for connection to server\n"
-	"-p <password>                password for connection to server\n"	
-	"-d <database>                database name\n"	
-	"-t <hostname>                server hostname\n"		
-	"-s <dir>                     directory with dump tree (for export/import)\n"
-	"-i                           import large obj dump tree to DB\n"
-        "-e                           export (dump) large obj to dump tree\n"
-	"-l <table.attr ...>          dump attribute (columns) with LO to dump tree\n"
-	"-a                           dump all LO in DB (default)\n"
-	"-r                           if is set '-i' try remove old LO\n"
-	"-q                           run quietly\n" 
-        "-w                           not dump, but show all LO in DB\n"
-	); /* puts() */ 
+		 "-h                           this help\n"
+	   "-u <username>                username for connection to server\n"
+	   "-p <password>                password for connection to server\n"
+		 "-d <database>                database name\n"
+		 "-t <hostname>                server hostname\n"
+		 "-s <dir>                     directory with dump tree (for export/import)\n"
+		 "-i                           import large obj dump tree to DB\n"
+	"-e                           export (dump) large obj to dump tree\n"
+		 "-l <table.attr ...>          dump attribute (columns) with LO to dump tree\n"
+		 "-a                           dump all LO in DB (default)\n"
+		 "-r                           if is set '-i' try remove old LO\n"
+		 "-q                           run quietly\n"
+		 "-w                           not dump, but show all LO in DB\n"
+		);						/* puts() */
 
 #endif
 
 	puts(
-	"Example (dump):   pg_dumplo -d my_db -s /my_dump/dir -l t1.a t1.b t2.a\n"
-	"                  pg_dumplo -a -d my_db -s /my_dump/dir\n"
-	"Example (import): pg_dumplo -i -d my_db -s /my_dump/dir\n"	
-	"Example (show):   pg_dumplo -w -d my_db\n\n"	
-	"Note:  * option '-l' must be last option!\n"	
-	"       * option '-i' without option '-r' make new large obj in DB\n" 
-	"         not rewrite old, the '-i' UPDATE oid numbers in table.attr only!\n"
-	"       * if is not set option -s, the pg_dumplo use $PWD\n" 
-	); /* puts()*/	
+		 "Example (dump):   pg_dumplo -d my_db -s /my_dump/dir -l t1.a t1.b t2.a\n"
+		 "                  pg_dumplo -a -d my_db -s /my_dump/dir\n"
+		 "Example (import): pg_dumplo -i -d my_db -s /my_dump/dir\n"
+		 "Example (show):   pg_dumplo -w -d my_db\n\n"
+		 "Note:  * option '-l' must be last option!\n"
+	"       * option '-i' without option '-r' make new large obj in DB\n"
+		 "         not rewrite old, the '-i' UPDATE oid numbers in table.attr only!\n"
+		 "       * if is not set option -s, the pg_dumplo use $PWD\n"
+		);						/* puts() */
 }
diff --git a/contrib/pg_dumplo/pg_dumplo.h b/contrib/pg_dumplo/pg_dumplo.h
index 7513c71b9b..3ab25495cb 100644
--- a/contrib/pg_dumplo/pg_dumplo.h
+++ b/contrib/pg_dumplo/pg_dumplo.h
@@ -1,7 +1,7 @@
 /* -------------------------------------------------------------------------
  * pg_dumplo
  *
- * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/pg_dumplo.h,v 1.3 2001/01/24 19:42:45 momjian Exp $
+ * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/pg_dumplo.h,v 1.4 2001/03/22 03:59:10 momjian Exp $
  *
  *					Karel Zak 1999-2000
  * -------------------------------------------------------------------------
@@ -17,12 +17,12 @@
 /* ----------
  * Define
  * ----------
- */        
+ */
 #define QUERY_BUFSIZ	(8*1024)
 #define DIR_UMASK	0755
 #define FILE_UMASK	0644
 
-#define	TRUE		1
+#define TRUE		1
 #define FALSE		0
 #define RE_OK		0
 #define RE_ERROR	1
@@ -36,44 +36,47 @@
  * LO struct
  * ----------
  */
-typedef struct { 
-	char	*lo_table,
-			*lo_attr;
-	Oid		lo_oid;
-} LOlist;
+typedef struct
+{
+	char	   *lo_table,
+			   *lo_attr;
+	Oid			lo_oid;
+}			LOlist;
 
-typedef struct {
-	int		action;
-	LOlist		*lolist;
-	char		**argv,
-			*user,
-			*db,
-			*host,
-			*space;
-	FILE		*index;
-	int		counter,
-			argc,
-			lolist_start,
-			remove,
-			quiet;
-	PGresult	*res;
-	PGconn		*conn;
-} LODumpMaster;
+typedef struct
+{
+	int			action;
+	LOlist	   *lolist;
+	char	  **argv,
+			   *user,
+			   *db,
+			   *host,
+			   *space;
+	FILE	   *index;
+	int			counter,
+				argc,
+				lolist_start,
+				remove,
+				quiet;
+	PGresult   *res;
+	PGconn	   *conn;
+}			LODumpMaster;
 
-typedef enum {	
+typedef enum
+{
 	ACTION_NONE,
 	ACTION_SHOW,
-	ACTION_EXPORT_ATTR,	
-	ACTION_EXPORT_ALL,	
+	ACTION_EXPORT_ATTR,
+	ACTION_EXPORT_ALL,
 	ACTION_IMPORT
-} PGLODUMP_ACTIONS;
+}			PGLODUMP_ACTIONS;
 
 extern char *progname;
 
-extern void	notice		(LODumpMaster *pgLO, int set);
-extern void	index_file	(LODumpMaster *pgLO);
-extern void	load_lolist	(LODumpMaster *pgLO);
-extern void	pglo_export	(LODumpMaster *pgLO);
-extern void	pglo_import	(LODumpMaster *pgLO);
+extern void notice(LODumpMaster * pgLO, int set);
+extern void index_file(LODumpMaster * pgLO);
+extern void load_lolist(LODumpMaster * pgLO);
+extern void pglo_export(LODumpMaster * pgLO);
+extern void pglo_import(LODumpMaster * pgLO);
 
-#endif /* PG_DUMPLO_H */
+#endif	 /* PG_DUMPLO_H */
diff --git a/contrib/pg_dumplo/utils.c b/contrib/pg_dumplo/utils.c
index dc3f5bbf9a..d36ee4be08 100644
--- a/contrib/pg_dumplo/utils.c
+++ b/contrib/pg_dumplo/utils.c
@@ -1,20 +1,20 @@
 /* -------------------------------------------------------------------------
  * pg_dumplo
  *
- * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/utils.c,v 1.3 2001/01/24 19:42:45 momjian Exp $
+ * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/utils.c,v 1.4 2001/03/22 03:59:10 momjian Exp $
  *
  *					Karel Zak 1999-2000
  * -------------------------------------------------------------------------
  */
 
-#include <stdio.h>	
+#include <stdio.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <fcntl.h>
-#include <errno.h>                            
+#include <errno.h>
 #include <time.h>
 
 #include <libpq-fe.h>
@@ -22,65 +22,76 @@
 
 #include "pg_dumplo.h"
 
-extern int 	errno;        
+extern int	errno;
+
+static void Dummy_NoticeProcessor(void *arg, const char *message);
+static void Default_NoticeProcessor(void *arg, const char *message);
 
-static void Dummy_NoticeProcessor(void * arg, const char * message);
-static void Default_NoticeProcessor(void * arg, const char * message);
-    
 
 void
-index_file(LODumpMaster *pgLO)
+index_file(LODumpMaster * pgLO)
 {
-	char	path[BUFSIZ];
+	char		path[BUFSIZ];
 
 	if (pgLO->action == ACTION_SHOW)
 		return;
-	
-	sprintf(path, "%s/%s", pgLO->space, pgLO->db); 
-	
+
+	sprintf(path, "%s/%s", pgLO->space, pgLO->db);
+
 	if (pgLO->action == ACTION_EXPORT_ATTR ||
-	    pgLO->action == ACTION_EXPORT_ALL) {
-	    
-		if (mkdir(path, DIR_UMASK) == -1) {
-			if (errno != EEXIST) {
+		pgLO->action == ACTION_EXPORT_ALL)
+	{
+
+		if (mkdir(path, DIR_UMASK) == -1)
+		{
+			if (errno != EEXIST)
+			{
 				perror(path);
-				exit(RE_ERROR);	
-			}	
+				exit(RE_ERROR);
+			}
 		}
-		
-		sprintf(path, "%s/lo_dump.index", path);          
 
-		if ((pgLO->index = fopen(path, "w")) == NULL) {
+		sprintf(path, "%s/lo_dump.index", path);
+
+		if ((pgLO->index = fopen(path, "w")) == NULL)
+		{
 			perror(path);
 			exit(RE_ERROR);
 		}
-		
-	} else if (pgLO->action != ACTION_NONE ) {
-	
-		sprintf(path, "%s/lo_dump.index", path);          
 
-		if ((pgLO->index = fopen(path, "r")) == NULL) {
+	}
+	else if (pgLO->action != ACTION_NONE)
+	{
+
+		sprintf(path, "%s/lo_dump.index", path);
+
+		if ((pgLO->index = fopen(path, "r")) == NULL)
+		{
 			perror(path);
 			exit(RE_ERROR);
 		}
 	}
 }
 
-static 
-void Dummy_NoticeProcessor(void * arg, const char * message)
+static
+void
+Dummy_NoticeProcessor(void *arg, const char *message)
 {
-    ;
+	;
 }
 
-static 
-void Default_NoticeProcessor(void * arg, const char * message)
+static
+void
+Default_NoticeProcessor(void *arg, const char *message)
 {
-     fprintf(stderr, "%s", message);
+	fprintf(stderr, "%s", message);
 }
 
-void 
-notice(LODumpMaster *pgLO, int set)
-{         
-	if (set)PQsetNoticeProcessor(pgLO->conn, Default_NoticeProcessor, NULL);
-	else	PQsetNoticeProcessor(pgLO->conn, Dummy_NoticeProcessor, NULL);	
+void
+notice(LODumpMaster * pgLO, int set)
+{
+	if (set)
+		PQsetNoticeProcessor(pgLO->conn, Default_NoticeProcessor, NULL);
+	else
+		PQsetNoticeProcessor(pgLO->conn, Dummy_NoticeProcessor, NULL);
 }
diff --git a/contrib/pg_logger/pg_logger.c b/contrib/pg_logger/pg_logger.c
index af56a249c6..cc2fdbed30 100644
--- a/contrib/pg_logger/pg_logger.c
+++ b/contrib/pg_logger/pg_logger.c
@@ -2,10 +2,10 @@
  *
  * Copyright 2001 by Nathan Myers <[email protected]>
  * This software is distributed free of charge with no warranty of any kind.
- * You have permission to make copies for any purpose, provided that (1) 
- * this copyright notice is retained unchanged, and (2) you agree to 
- * absolve the author of all responsibility for all consequences arising 
- * from any use.  
+ * You have permission to make copies for any purpose, provided that (1)
+ * this copyright notice is retained unchanged, and (2) you agree to
+ * absolve the author of all responsibility for all consequences arising
+ * from any use.
  */
 
 #include <stdio.h>
@@ -13,73 +13,94 @@
 #include <syslog.h>
 #include <string.h>
 
-struct {
-    const char *tag;
-    int size;
-    int priority;
-} tags[] = {
-    { "",         0,                 LOG_NOTICE },
-    { "emerg:",   sizeof("emerg"),   LOG_EMERG },
-    { "alert:",   sizeof("alert"),   LOG_ALERT },
-    { "crit:",    sizeof("crit"),    LOG_CRIT },
-    { "err:",     sizeof("err"),     LOG_ERR },
-    { "error:",   sizeof("error"),   LOG_ERR },
-    { "warning:", sizeof("warning"), LOG_WARNING },
-    { "notice:",  sizeof("notice"),  LOG_NOTICE },
-    { "info:",    sizeof("info"),    LOG_INFO },
-    { "debug:",   sizeof("debug"),   LOG_DEBUG }
+struct
+{
+	const char *tag;
+	int			size;
+	int			priority;
+}			tags[] =
+
+{
+	{
+		"", 0, LOG_NOTICE
+	},
+	{
+		"emerg:", sizeof("emerg"), LOG_EMERG
+	},
+	{
+		"alert:", sizeof("alert"), LOG_ALERT
+	},
+	{
+		"crit:", sizeof("crit"), LOG_CRIT
+	},
+	{
+		"err:", sizeof("err"), LOG_ERR
+	},
+	{
+		"error:", sizeof("error"), LOG_ERR
+	},
+	{
+		"warning:", sizeof("warning"), LOG_WARNING
+	},
+	{
+		"notice:", sizeof("notice"), LOG_NOTICE
+	},
+	{
+		"info:", sizeof("info"), LOG_INFO
+	},
+	{
+		"debug:", sizeof("debug"), LOG_DEBUG
+	}
 };
 
-int main()
+int
+main()
 {
-    char buf[301];
-    int c;
-    char *pos = buf;
-    const char *colon = 0;
+	char		buf[301];
+	int			c;
+	char	   *pos = buf;
+	const char *colon = 0;
 
 #ifndef DEBUG
-    openlog("postgresql", LOG_CONS, LOG_LOCAL1);
+	openlog("postgresql", LOG_CONS, LOG_LOCAL1);
 #endif
-    while ( (c = getchar()) != EOF) {
-        if (c == '\r') {
-          continue;
-        }
-        if (c == '\n') {
-            int level = sizeof(tags)/sizeof(*tags);
-            char *bol;
+	while ((c = getchar()) != EOF)
+	{
+		if (c == '\r')
+			continue;
+		if (c == '\n')
+		{
+			int			level = sizeof(tags) / sizeof(*tags);
+			char	   *bol;
 
-            if (colon == 0 || (size_t)(colon - buf) > sizeof("warning")) {
-                level = 1;
-            }
-            *pos = 0;
-            while (--level) {
-                if (pos - buf >= tags[level].size
-                    && strncmp(buf, tags[level].tag, tags[level].size) == 0) {
-                    break; 
-                }
-            }
-            bol = buf + tags[level].size;
-            if (bol > buf && *bol == ' ') {
-                ++bol;
-            }
-            if (pos - bol > 0) {
+			if (colon == 0 || (size_t) (colon - buf) > sizeof("warning"))
+				level = 1;
+			*pos = 0;
+			while (--level)
+			{
+				if (pos - buf >= tags[level].size
+				 && strncmp(buf, tags[level].tag, tags[level].size) == 0)
+					break;
+			}
+			bol = buf + tags[level].size;
+			if (bol > buf && *bol == ' ')
+				++bol;
+			if (pos - bol > 0)
+			{
 #ifndef DEBUG
-                syslog(tags[level].priority, "%s", bol);
+				syslog(tags[level].priority, "%s", bol);
 #else
-                printf("%d/%s\n", tags[level].priority, bol);
+				printf("%d/%s\n", tags[level].priority, bol);
 #endif
-            }
-            pos = buf;
-            colon = (char const *)0;
-            continue;
-        }
-        if (c == ':' && !colon) {
-            colon = pos;
-        }
-        if ((size_t)(pos - buf) < sizeof(buf)-1) {
-            *pos++ = c;
-        }
-    }
-    return 0;
+			}
+			pos = buf;
+			colon = (char const *) 0;
+			continue;
+		}
+		if (c == ':' && !colon)
+			colon = pos;
+		if ((size_t) (pos - buf) < sizeof(buf) - 1)
+			*pos++ = c;
+	}
+	return 0;
 }
-
diff --git a/contrib/pg_resetxlog/pg_resetxlog.c b/contrib/pg_resetxlog/pg_resetxlog.c
index 5137cddd91..848bbb9267 100644
--- a/contrib/pg_resetxlog/pg_resetxlog.c
+++ b/contrib/pg_resetxlog/pg_resetxlog.c
@@ -5,15 +5,15 @@
  *	  Can also rebuild pg_control if needed.
  *
  * The theory of operation is fairly simple:
- *    1. Read the existing pg_control (which will include the last
+ *	  1. Read the existing pg_control (which will include the last
  *		 checkpoint record).  If it is an old format then update to
  *		 current format.
  *	  2. If pg_control is corrupt, attempt to intuit reasonable values,
  *		 by scanning the old xlog if necessary.
  *	  3. Modify pg_control to reflect a "shutdown" state with a checkpoint
- *	     record at the start of xlog.
+ *		 record at the start of xlog.
  *	  4. Flush the existing xlog files and write a new segment with
- *	     just a checkpoint record in it.  The new segment is positioned
+ *		 just a checkpoint record in it.  The new segment is positioned
  *		 just past the end of the old xlog, so that existing LSNs in
  *		 data pages will appear to be "in the past".
  * This is all pretty straightforward except for the intuition part of
@@ -23,7 +23,7 @@
  * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Header: /cvsroot/pgsql/contrib/pg_resetxlog/Attic/pg_resetxlog.c,v 1.2 2001/03/16 05:08:39 tgl Exp $
+ * $Header: /cvsroot/pgsql/contrib/pg_resetxlog/Attic/pg_resetxlog.c,v 1.3 2001/03/22 03:59:10 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -63,7 +63,7 @@
  * Compute ID and segment from an XLogRecPtr.
  *
  * For XLByteToSeg, do the computation at face value.  For XLByteToPrevSeg,
- * a boundary byte is taken to be in the previous segment.  This is suitable
+ * a boundary byte is taken to be in the previous segment.	This is suitable
  * for deciding which segment to write given a pointer to a record end,
  * for example.
  */
@@ -109,8 +109,9 @@ static char *DataDir;			/* locations of important stuff */
 static char XLogDir[MAXPGPATH];
 static char ControlFilePath[MAXPGPATH];
 
-static ControlFileData ControlFile;	/* pg_control values */
-static uint32 newXlogId, newXlogSeg; /* ID/Segment of new XLOG segment */
+static ControlFileData ControlFile;		/* pg_control values */
+static uint32 newXlogId,
+			newXlogSeg;			/* ID/Segment of new XLOG segment */
 static bool guessed = false;	/* T if we had to guess at any values */
 
 
@@ -139,17 +140,18 @@ XLogFileOpen(uint32 log, uint32 seg)
 static bool
 ReadControlFile(void)
 {
-	int		fd;
-	int		len;
-	char   *buffer;
-	crc64	crc;
+	int			fd;
+	int			len;
+	char	   *buffer;
+	crc64		crc;
 
 	if ((fd = open(ControlFilePath, O_RDONLY)) < 0)
 	{
+
 		/*
-		 * If pg_control is not there at all, or we can't read it,
-		 * the odds are we've been handed a bad DataDir path, so give up.
-		 * User can do "touch pg_control" to force us to proceed.
+		 * If pg_control is not there at all, or we can't read it, the
+		 * odds are we've been handed a bad DataDir path, so give up. User
+		 * can do "touch pg_control" to force us to proceed.
 		 */
 		perror("Failed to open $PGDATA/global/pg_control for reading");
 		if (errno == ENOENT)
@@ -175,7 +177,7 @@ ReadControlFile(void)
 	{
 		/* Seems to be current version --- check the CRC. */
 		INIT_CRC64(crc);
-		COMP_CRC64(crc, 
+		COMP_CRC64(crc,
 				   buffer + sizeof(crc64),
 				   sizeof(ControlFileData) - sizeof(crc64));
 		FIN_CRC64(crc);
@@ -193,6 +195,7 @@ ReadControlFile(void)
 		guessed = true;
 		return true;
 	}
+
 	/*
 	 * Maybe it's a 7.1beta pg_control.
 	 */
@@ -217,75 +220,75 @@ ReadControlFile(void)
 
 typedef struct crc64V0
 {
-	uint32			crc1;
-	uint32			crc2;
-} crc64V0;
+	uint32		crc1;
+	uint32		crc2;
+}			crc64V0;
 
 static uint32 crc_tableV0[] = {
-0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
-0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
-0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
-0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
-0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
-0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
-0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
-0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
-0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
-0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
-0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
-0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
-0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
-0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
-0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
-0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
-0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
-0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
-0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
-0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
-0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
-0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
-0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
-0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
-0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
-0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
-0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
-0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
-0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
-0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
-0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
-0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
-0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
-0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
-0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
-0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
-0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
-0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
-0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
-0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
-0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
-0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
-0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
+	0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
+	0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
+	0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
+	0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
+	0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
+	0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
+	0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
+	0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
+	0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
+	0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
+	0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
+	0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
+	0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
+	0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
+	0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
+	0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
+	0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
+	0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
+	0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
+	0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
+	0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
+	0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
+	0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
+	0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
+	0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
+	0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
+	0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
+	0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
+	0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
+	0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
+	0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
+	0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
+	0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
+	0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
+	0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
+	0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
+	0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
+	0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
+	0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
+	0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
+	0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
+	0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
+	0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
 };
 
 #define INIT_CRC64V0(crc)	((crc).crc1 = 0xffffffff, (crc).crc2 = 0xffffffff)
 #define FIN_CRC64V0(crc)	((crc).crc1 ^= 0xffffffff, (crc).crc2 ^= 0xffffffff)
 #define COMP_CRC64V0(crc, data, len)	\
 {\
-        uint32       __c1 = (crc).crc1;\
-        uint32       __c2 = (crc).crc2;\
-        char        *__data = (char *) (data);\
-        uint32       __len = (len);\
+		uint32		 __c1 = (crc).crc1;\
+		uint32		 __c2 = (crc).crc2;\
+		char		*__data = (char *) (data);\
+		uint32		 __len = (len);\
 \
-        while (__len >= 2)\
-        {\
-                __c1 = crc_tableV0[(__c1 ^ *__data++) & 0xff] ^ (__c1 >> 8);\
-                __c2 = crc_tableV0[(__c2 ^ *__data++) & 0xff] ^ (__c2 >> 8);\
-                __len -= 2;\
-        }\
-        if (__len > 0)\
-                __c1 = crc_tableV0[(__c1 ^ *__data++) & 0xff] ^ (__c1 >> 8);\
-        (crc).crc1 = __c1;\
-        (crc).crc2 = __c2;\
+		while (__len >= 2)\
+		{\
+				__c1 = crc_tableV0[(__c1 ^ *__data++) & 0xff] ^ (__c1 >> 8);\
+				__c2 = crc_tableV0[(__c2 ^ *__data++) & 0xff] ^ (__c2 >> 8);\
+				__len -= 2;\
+		}\
+		if (__len > 0)\
+				__c1 = crc_tableV0[(__c1 ^ *__data++) & 0xff] ^ (__c1 >> 8);\
+		(crc).crc1 = __c1;\
+		(crc).crc2 = __c2;\
 }
 
 #define EQ_CRC64V0(c1,c2)  ((c1).crc1 == (c2).crc1 && (c1).crc2 == (c2).crc2)
@@ -295,51 +298,51 @@ static uint32 crc_tableV0[] = {
 
 typedef struct ControlFileDataV0
 {
-	crc64V0			crc;
-	uint32			logId;		/* current log file id */
-	uint32			logSeg;		/* current log file segment (1-based) */
-	XLogRecPtr		checkPoint;	/* last check point record ptr */
-	time_t			time;		/* time stamp of last modification */
-	DBState			state;		/* see enum above */
-	uint32			blcksz;		/* block size for this DB */
-	uint32			relseg_size; /* blocks per segment of large relation */
-	uint32			catalog_version_no;	/* internal version number */
-	char			lc_collate[LOCALE_NAME_BUFLEN_V0];
-	char			lc_ctype[LOCALE_NAME_BUFLEN_V0];
-	char			archdir[MAXPGPATH];	/* where to move offline log files */
-} ControlFileDataV0;
+	crc64V0		crc;
+	uint32		logId;			/* current log file id */
+	uint32		logSeg;			/* current log file segment (1-based) */
+	XLogRecPtr	checkPoint;		/* last check point record ptr */
+	time_t		time;			/* time stamp of last modification */
+	DBState		state;			/* see enum above */
+	uint32		blcksz;			/* block size for this DB */
+	uint32		relseg_size;	/* blocks per segment of large relation */
+	uint32		catalog_version_no;		/* internal version number */
+	char		lc_collate[LOCALE_NAME_BUFLEN_V0];
+	char		lc_ctype[LOCALE_NAME_BUFLEN_V0];
+	char		archdir[MAXPGPATH];		/* where to move offline log files */
+}			ControlFileDataV0;
 
 typedef struct CheckPointV0
 {
-	XLogRecPtr		redo;		/* next RecPtr available when we */
-								/* began to create CheckPoint */
-								/* (i.e. REDO start point) */
-	XLogRecPtr		undo;		/* first record of oldest in-progress */
-								/* transaction when we started */
-								/* (i.e. UNDO end point) */
-	StartUpID		ThisStartUpID;
-	TransactionId	nextXid;
-	Oid				nextOid;
-	bool			Shutdown;
-} CheckPointV0;
+	XLogRecPtr	redo;			/* next RecPtr available when we */
+	/* began to create CheckPoint */
+	/* (i.e. REDO start point) */
+	XLogRecPtr	undo;			/* first record of oldest in-progress */
+	/* transaction when we started */
+	/* (i.e. UNDO end point) */
+	StartUpID	ThisStartUpID;
+	TransactionId nextXid;
+	Oid			nextOid;
+	bool		Shutdown;
+}			CheckPointV0;
 
 typedef struct XLogRecordV0
 {
-	crc64V0			xl_crc;
-	XLogRecPtr		xl_prev;	/* ptr to previous record in log */
-	XLogRecPtr		xl_xact_prev; /* ptr to previous record of this xact */
-	TransactionId	xl_xid;		/* xact id */
-	uint16			xl_len;		/* total len of record *data* */
-	uint8			xl_info;
-	RmgrId			xl_rmid;	/* resource manager inserted this record */
-} XLogRecordV0;
+	crc64V0		xl_crc;
+	XLogRecPtr	xl_prev;		/* ptr to previous record in log */
+	XLogRecPtr	xl_xact_prev;	/* ptr to previous record of this xact */
+	TransactionId xl_xid;		/* xact id */
+	uint16		xl_len;			/* total len of record *data* */
+	uint8		xl_info;
+	RmgrId		xl_rmid;		/* resource manager inserted this record */
+}			XLogRecordV0;
 
 #define SizeOfXLogRecordV0	DOUBLEALIGN(sizeof(XLogRecordV0))
 
 typedef struct XLogContRecordV0
 {
-	uint16			xl_len;		/* len of data left */
-} XLogContRecordV0;
+	uint16		xl_len;			/* len of data left */
+}			XLogContRecordV0;
 
 #define SizeOfXLogContRecordV0	DOUBLEALIGN(sizeof(XLogContRecordV0))
 
@@ -347,16 +350,16 @@ typedef struct XLogContRecordV0
 
 typedef struct XLogPageHeaderDataV0
 {
-	uint32                xlp_magic;
-	uint16                xlp_info;
-} XLogPageHeaderDataV0;
+	uint32		xlp_magic;
+	uint16		xlp_info;
+}			XLogPageHeaderDataV0;
 
 #define SizeOfXLogPHDV0   DOUBLEALIGN(sizeof(XLogPageHeaderDataV0))
 
 typedef XLogPageHeaderDataV0 *XLogPageHeaderV0;
 
 
-static bool RecordIsValidV0(XLogRecordV0 *record);
+static bool RecordIsValidV0(XLogRecordV0 * record);
 static XLogRecordV0 *ReadRecordV0(XLogRecPtr *RecPtr, char *buffer);
 static bool ValidXLOGHeaderV0(XLogPageHeaderV0 hdr);
 
@@ -376,7 +379,7 @@ CheckControlVersion0(char *buffer, int len)
 		return false;
 	/* Check CRC the version-0 way. */
 	INIT_CRC64V0(crc);
-	COMP_CRC64V0(crc, 
+	COMP_CRC64V0(crc,
 				 buffer + sizeof(crc64V0),
 				 sizeof(ControlFileDataV0) - sizeof(crc64V0));
 	FIN_CRC64V0(crc);
@@ -409,12 +412,13 @@ CheckControlVersion0(char *buffer, int len)
 						  (char *) malloc(_INTL_MAXLOGRECSZ));
 	if (record == NULL)
 	{
+
 		/*
 		 * We have to guess at the checkpoint contents.
 		 */
 		guessed = true;
 		ControlFile.checkPointCopy.ThisStartUpID = 0;
-		ControlFile.checkPointCopy.nextXid = (TransactionId) 514; /* XXX */
+		ControlFile.checkPointCopy.nextXid = (TransactionId) 514;		/* XXX */
 		ControlFile.checkPointCopy.nextOid = BootstrapObjectIdData;
 		return true;
 	}
@@ -435,26 +439,26 @@ CheckControlVersion0(char *buffer, int len)
  * We assume all of the record has been read into memory at *record.
  */
 static bool
-RecordIsValidV0(XLogRecordV0 *record)
+RecordIsValidV0(XLogRecordV0 * record)
 {
 	crc64V0		crc;
 	uint32		len = record->xl_len;
 
 	/*
 	 * NB: this code is not right for V0 records containing backup blocks,
-	 * but for now it's only going to be applied to checkpoint records,
-	 * so I'm not going to worry about it...
+	 * but for now it's only going to be applied to checkpoint records, so
+	 * I'm not going to worry about it...
 	 */
 	INIT_CRC64V0(crc);
 	COMP_CRC64V0(crc, XLogRecGetData(record), len);
-	COMP_CRC64V0(crc, (char*) record + sizeof(crc64V0),
+	COMP_CRC64V0(crc, (char *) record + sizeof(crc64V0),
 				 SizeOfXLogRecordV0 - sizeof(crc64V0));
 	FIN_CRC64V0(crc);
 
 	if (!EQ_CRC64V0(record->xl_crc, crc))
 		return false;
 
-	return(true);
+	return (true);
 }
 
 /*
@@ -489,7 +493,7 @@ ReadRecordV0(XLogRecPtr *RecPtr, char *buffer)
 		readFile = XLogFileOpen(readId, readSeg);
 		if (readFile < 0)
 			goto next_record_is_invalid;
-		readOff = (uint32) (-1); /* force read to occur below */
+		readOff = (uint32) (-1);/* force read to occur below */
 	}
 
 	targetPageOff = ((RecPtr->xrecoff % XLogSegSize) / BLCKSZ) * BLCKSZ;
@@ -510,10 +514,13 @@ ReadRecordV0(XLogRecPtr *RecPtr, char *buffer)
 
 	if (record->xl_len == 0)
 		goto next_record_is_invalid;
+
 	/*
-	 * Compute total length of record including any appended backup blocks.
+	 * Compute total length of record including any appended backup
+	 * blocks.
 	 */
 	total_len = SizeOfXLogRecordV0 + record->xl_len;
+
 	/*
 	 * Make sure it will fit in buffer (currently, it is mechanically
 	 * impossible for this test to fail, but it seems like a good idea
@@ -526,7 +533,7 @@ ReadRecordV0(XLogRecPtr *RecPtr, char *buffer)
 	{
 		/* Need to reassemble record */
 		XLogContRecordV0 *contrecord;
-		uint32			gotlen = len;
+		uint32		gotlen = len;
 
 		memcpy(buffer, record, len);
 		record = (XLogRecordV0 *) buffer;
@@ -551,13 +558,13 @@ ReadRecordV0(XLogRecPtr *RecPtr, char *buffer)
 			if (!(((XLogPageHeaderV0) readBuf)->xlp_info & XLP_FIRST_IS_CONTRECORD))
 				goto next_record_is_invalid;
 			contrecord = (XLogContRecordV0 *) ((char *) readBuf + SizeOfXLogPHDV0);
-			if (contrecord->xl_len == 0 || 
+			if (contrecord->xl_len == 0 ||
 				total_len != (contrecord->xl_len + gotlen))
 				goto next_record_is_invalid;
 			len = BLCKSZ - SizeOfXLogPHDV0 - SizeOfXLogContRecordV0;
 			if (contrecord->xl_len > len)
 			{
-				memcpy(buffer, (char *)contrecord + SizeOfXLogContRecordV0, len);
+				memcpy(buffer, (char *) contrecord + SizeOfXLogContRecordV0, len);
 				gotlen += len;
 				buffer += len;
 				continue;
@@ -587,7 +594,7 @@ next_record_is_invalid:;
  * Check whether the xlog header of a page just read in looks valid.
  *
  * This is just a convenience subroutine to avoid duplicated code in
- * ReadRecord.  It's not intended for use from anywhere else.
+ * ReadRecord.	It's not intended for use from anywhere else.
  */
 static bool
 ValidXLOGHeaderV0(XLogPageHeaderV0 hdr)
@@ -610,6 +617,7 @@ GuessControlValues(void)
 {
 #ifdef USE_LOCALE
 	char	   *localeptr;
+
 #endif
 
 	/*
@@ -625,7 +633,7 @@ GuessControlValues(void)
 	ControlFile.checkPointCopy.redo.xrecoff = SizeOfXLogPHD;
 	ControlFile.checkPointCopy.undo = ControlFile.checkPointCopy.redo;
 	ControlFile.checkPointCopy.ThisStartUpID = 0;
-	ControlFile.checkPointCopy.nextXid = (TransactionId) 514; /* XXX */
+	ControlFile.checkPointCopy.nextXid = (TransactionId) 514;	/* XXX */
 	ControlFile.checkPointCopy.nextOid = BootstrapObjectIdData;
 	ControlFile.checkPointCopy.time = time(NULL);
 
@@ -677,7 +685,7 @@ PrintControlValues(void)
 		   "pg_control version number:            %u\n"
 		   "Catalog version number:               %u\n"
 		   "Current log file id:                  %u\n"
-	       "Next log file segment:                %u\n"
+		   "Next log file segment:                %u\n"
 		   "Latest checkpoint's StartUpID:        %u\n"
 		   "Latest checkpoint's NextXID:          %u\n"
 		   "Latest checkpoint's NextOID:          %u\n"
@@ -707,11 +715,11 @@ static void
 RewriteControlFile(void)
 {
 	int			fd;
-	char		buffer[BLCKSZ];	/* need not be aligned */
+	char		buffer[BLCKSZ]; /* need not be aligned */
 
 	/*
-	 * Adjust fields as needed to force an empty XLOG starting at the
-	 * next available segment.
+	 * Adjust fields as needed to force an empty XLOG starting at the next
+	 * available segment.
 	 */
 	newXlogId = ControlFile.logId;
 	newXlogSeg = ControlFile.logSeg;
@@ -734,17 +742,17 @@ RewriteControlFile(void)
 
 	/* Contents are protected with a CRC */
 	INIT_CRC64(ControlFile.crc);
-	COMP_CRC64(ControlFile.crc, 
-			   (char*) &ControlFile + sizeof(crc64),
+	COMP_CRC64(ControlFile.crc,
+			   (char *) &ControlFile + sizeof(crc64),
 			   sizeof(ControlFileData) - sizeof(crc64));
 	FIN_CRC64(ControlFile.crc);
 
 	/*
-	 * We write out BLCKSZ bytes into pg_control, zero-padding the
-	 * excess over sizeof(ControlFileData).  This reduces the odds
-	 * of premature-EOF errors when reading pg_control.  We'll still
-	 * fail when we check the contents of the file, but hopefully with
-	 * a more specific error than "couldn't read pg_control".
+	 * We write out BLCKSZ bytes into pg_control, zero-padding the excess
+	 * over sizeof(ControlFileData).  This reduces the odds of
+	 * premature-EOF errors when reading pg_control.  We'll still fail
+	 * when we check the contents of the file, but hopefully with a more
+	 * specific error than "couldn't read pg_control".
 	 */
 	if (sizeof(ControlFileData) > BLCKSZ)
 	{
@@ -786,9 +794,9 @@ RewriteControlFile(void)
 static void
 KillExistingXLOG(void)
 {
-	DIR			   *xldir;
-	struct dirent  *xlde;
-	char			path[MAXPGPATH];
+	DIR		   *xldir;
+	struct dirent *xlde;
+	char		path[MAXPGPATH];
 
 	xldir = opendir(XLogDir);
 	if (xldir == NULL)
@@ -803,7 +811,7 @@ KillExistingXLOG(void)
 		if (strlen(xlde->d_name) == 16 &&
 			strspn(xlde->d_name, "0123456789ABCDEF") == 16)
 		{
-			sprintf(path, "%s%c%s",	XLogDir, SEP_CHAR, xlde->d_name);
+			sprintf(path, "%s%c%s", XLogDir, SEP_CHAR, xlde->d_name);
 			if (unlink(path) < 0)
 			{
 				perror(path);
@@ -858,7 +866,7 @@ WriteEmptyXLOG(void)
 
 	INIT_CRC64(crc);
 	COMP_CRC64(crc, &ControlFile.checkPointCopy, sizeof(CheckPoint));
-	COMP_CRC64(crc, (char*) record + sizeof(crc64),
+	COMP_CRC64(crc, (char *) record + sizeof(crc64),
 			   SizeOfXLogRecord - sizeof(crc64));
 	FIN_CRC64(crc);
 	record->xl_crc = crc;
@@ -914,13 +922,13 @@ usage(void)
 
 
 int
-main(int argc, char ** argv)
+main(int argc, char **argv)
 {
-	int		argn;
-	bool	force = false;
-	bool	noupdate = false;
-	int		fd;
-	char	path[MAXPGPATH];
+	int			argn;
+	bool		force = false;
+	bool		noupdate = false;
+	int			fd;
+	char		path[MAXPGPATH];
 
 	for (argn = 1; argn < argc; argn++)
 	{
@@ -934,7 +942,7 @@ main(int argc, char ** argv)
 			usage();
 	}
 
-	if (argn != argc-1)			/* one required non-switch argument */
+	if (argn != argc - 1)		/* one required non-switch argument */
 		usage();
 
 	DataDir = argv[argn++];
@@ -946,7 +954,8 @@ main(int argc, char ** argv)
 
 	/*
 	 * Check for a postmaster lock file --- if there is one, refuse to
-	 * proceed, on grounds we might be interfering with a live installation.
+	 * proceed, on grounds we might be interfering with a live
+	 * installation.
 	 */
 	snprintf(path, MAXPGPATH, "%s%cpostmaster.pid", DataDir, SEP_CHAR);
 
@@ -973,8 +982,8 @@ main(int argc, char ** argv)
 		GuessControlValues();
 
 	/*
-	 * If we had to guess anything, and -f was not given, just print
-	 * the guessed values and exit.  Also print if -n is given.
+	 * If we had to guess anything, and -f was not given, just print the
+	 * guessed values and exit.  Also print if -n is given.
 	 */
 	if ((guessed && !force) || noupdate)
 	{
diff --git a/contrib/pgcrypto/encode.c b/contrib/pgcrypto/encode.c
index 0ad0a8f56c..b6db217c83 100644
--- a/contrib/pgcrypto/encode.c
+++ b/contrib/pgcrypto/encode.c
@@ -1,7 +1,7 @@
 /*
  * encode.c
  *		Various data encoding/decoding things.
- * 
+ *
  * Copyright (c) 2001 Marko Kreen
  * All rights reserved.
  *
@@ -9,15 +9,15 @@
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
+ *	  notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
+ *	  notice, this list of conditions and the following disclaimer in the
+ *	  documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * ARE DISCLAIMED.	IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
@@ -26,7 +26,7 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- * $Id: encode.c,v 1.3 2001/02/10 02:31:25 tgl Exp $
+ * $Id: encode.c,v 1.4 2001/03/22 03:59:10 momjian Exp $
  */
 
 #include "postgres.h"
@@ -43,9 +43,9 @@
 #endif
 
 static pg_coding *
-find_coding(pg_coding *hbuf, text *name, int silent);
+			find_coding(pg_coding * hbuf, text *name, int silent);
 static pg_coding *
-pg_find_coding(pg_coding *res, char *name);
+			pg_find_coding(pg_coding * res, char *name);
 
 
 /* SQL function: encode(bytea, text) returns text */
@@ -54,34 +54,37 @@ PG_FUNCTION_INFO_V1(encode);
 Datum
 encode(PG_FUNCTION_ARGS)
 {
-	text *arg;
-	text *name;
-	uint len, rlen, rlen0;
-	pg_coding *c, cbuf;
-	text *res;
-	
+	text	   *arg;
+	text	   *name;
+	uint		len,
+				rlen,
+				rlen0;
+	pg_coding  *c,
+				cbuf;
+	text	   *res;
+
 	if (PG_ARGISNULL(0) || PG_ARGISNULL(1))
 		PG_RETURN_NULL();
-	
-	name = PG_GETARG_TEXT_P(1);	
-	c = find_coding(&cbuf, name, 0); /* will give error if fails */
+
+	name = PG_GETARG_TEXT_P(1);
+	c = find_coding(&cbuf, name, 0);	/* will give error if fails */
 
 	arg = PG_GETARG_TEXT_P(0);
 	len = VARSIZE(arg) - VARHDRSZ;
-	
+
 	rlen0 = c->encode_len(len);
-	
-	res = (text *)palloc(rlen0 + VARHDRSZ);
-	
+
+	res = (text *) palloc(rlen0 + VARHDRSZ);
+
 	rlen = c->encode(VARDATA(arg), len, VARDATA(res));
 	VARATT_SIZEP(res) = rlen + VARHDRSZ;
 
 	if (rlen > rlen0)
 		elog(FATAL, "pg_encode: overflow, encode estimate too small");
-	
+
 	PG_FREE_IF_COPY(arg, 0);
 	PG_FREE_IF_COPY(name, 1);
-	
+
 	PG_RETURN_TEXT_P(res);
 }
 
@@ -91,54 +94,58 @@ PG_FUNCTION_INFO_V1(decode);
 Datum
 decode(PG_FUNCTION_ARGS)
 {
-	text *arg;
-	text *name;
-	uint len, rlen, rlen0;
-	pg_coding *c, cbuf;
-	text *res;
-	
+	text	   *arg;
+	text	   *name;
+	uint		len,
+				rlen,
+				rlen0;
+	pg_coding  *c,
+				cbuf;
+	text	   *res;
+
 	if (PG_ARGISNULL(0) || PG_ARGISNULL(1))
 		PG_RETURN_NULL();
-	
-	name = PG_GETARG_TEXT_P(1);	
-	c = find_coding(&cbuf, name, 0); /* will give error if fails */
+
+	name = PG_GETARG_TEXT_P(1);
+	c = find_coding(&cbuf, name, 0);	/* will give error if fails */
 
 	arg = PG_GETARG_TEXT_P(0);
 	len = VARSIZE(arg) - VARHDRSZ;
-	
+
 	rlen0 = c->decode_len(len);
-	
-	res = (text *)palloc(rlen0 + VARHDRSZ);
-	
+
+	res = (text *) palloc(rlen0 + VARHDRSZ);
+
 	rlen = c->decode(VARDATA(arg), len, VARDATA(res));
 	VARATT_SIZEP(res) = rlen + VARHDRSZ;
 
 	if (rlen > rlen0)
 		elog(FATAL, "pg_decode: overflow, decode estimate too small");
-	
+
 	PG_FREE_IF_COPY(arg, 0);
 	PG_FREE_IF_COPY(name, 1);
-	
+
 	PG_RETURN_TEXT_P(res);
 }
 
 static pg_coding *
-find_coding(pg_coding *dst, text *name, int silent)
+find_coding(pg_coding * dst, text *name, int silent)
 {
-	pg_coding *p;
-	char buf[NAMEDATALEN];
-	uint len;
-	
+	pg_coding  *p;
+	char		buf[NAMEDATALEN];
+	uint		len;
+
 	len = VARSIZE(name) - VARHDRSZ;
-	if (len >= NAMEDATALEN) {
+	if (len >= NAMEDATALEN)
+	{
 		if (silent)
 			return NULL;
 		elog(ERROR, "Encoding type does not exist (name too long)");
 	}
-		
+
 	memcpy(buf, VARDATA(name), len);
 	buf[len] = 0;
-	
+
 	p = pg_find_coding(dst, buf);
 
 	if (p == NULL && !silent)
@@ -151,21 +158,23 @@ static char *hextbl = "0123456789abcdef";
 uint
 hex_encode(uint8 *src, uint len, uint8 *dst)
 {
-	uint8 *end = src + len;
-	while (src < end) {
+	uint8	   *end = src + len;
+
+	while (src < end)
+	{
 		*dst++ = hextbl[(*src >> 4) & 0xF];
 		*dst++ = hextbl[*src & 0xF];
 		src++;
 	}
-	return len*2;
+	return len * 2;
 }
 
 /* probably should use lookup table */
 static uint8
 get_hex(char c)
 {
-	uint8 res = 0;
-	
+	uint8		res = 0;
+
 	if (c >= '0' && c <= '9')
 		res = c - '0';
 	else if (c >= 'a' && c <= 'f')
@@ -174,19 +183,26 @@ get_hex(char c)
 		res = c - 'A' + 10;
 	else
 		elog(ERROR, "Bad hex code: '%c'", c);
-	
+
 	return res;
 }
 
 uint
 hex_decode(uint8 *src, uint len, uint8 *dst)
 {
-	uint8 *s, *srcend, v1, v2, *p = dst;
-	
+	uint8	   *s,
+			   *srcend,
+				v1,
+				v2,
+			   *p = dst;
+
 	srcend = src + len;
-	s = src; p = dst;
-	while (s < srcend) {
-		if (*s == ' ' || *s == '\n' || *s == '\t' || *s == '\r') {
+	s = src;
+	p = dst;
+	while (s < srcend)
+	{
+		if (*s == ' ' || *s == '\n' || *s == '\t' || *s == '\r')
+		{
 			s++;
 			continue;
 		}
@@ -196,30 +212,36 @@ hex_decode(uint8 *src, uint len, uint8 *dst)
 		v2 = get_hex(*s++);
 		*p++ = v1 | v2;
 	}
-	
+
 	return p - dst;
 }
 
 
 static unsigned char _base64[] =
-	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
 uint
 b64_encode(uint8 *src, uint len, uint8 *dst)
 {
-	uint8 *s, *p, *end = src + len, *lend = dst + 76;
-	int pos = 2;
+	uint8	   *s,
+			   *p,
+			   *end = src + len,
+			   *lend = dst + 76;
+	int			pos = 2;
 	unsigned long buf = 0;
 
-	s = src; p = dst;
-	
-	while (s < end) {
+	s = src;
+	p = dst;
+
+	while (s < end)
+	{
 		buf |= *s << (pos << 3);
 		pos--;
 		s++;
-		
+
 		/* write it out */
-		if (pos < 0) {
+		if (pos < 0)
+		{
 			*p++ = _base64[(buf >> 18) & 0x3f];
 			*p++ = _base64[(buf >> 12) & 0x3f];
 			*p++ = _base64[(buf >> 6) & 0x3f];
@@ -228,12 +250,14 @@ b64_encode(uint8 *src, uint len, uint8 *dst)
 			pos = 2;
 			buf = 0;
 		}
-		if (p >= lend) {
+		if (p >= lend)
+		{
 			*p++ = '\n';
 			lend = p + 76;
 		}
 	}
-	if (pos != 2) {
+	if (pos != 2)
+	{
 		*p++ = _base64[(buf >> 18) & 0x3f];
 		*p++ = _base64[(buf >> 12) & 0x3f];
 		*p++ = (pos == 0) ? _base64[(buf >> 6) & 0x3f] : '=';
@@ -247,14 +271,17 @@ b64_encode(uint8 *src, uint len, uint8 *dst)
 uint
 b64_decode(uint8 *src, uint len, uint8 *dst)
 {
-	char *srcend = src + len, *s = src;
-	uint8 *p = dst;
-	char c;
-	uint b = 0;
+	char	   *srcend = src + len,
+			   *s = src;
+	uint8	   *p = dst;
+	char		c;
+	uint		b = 0;
 	unsigned long buf = 0;
-	int pos = 0, end = 0;
-	
-	while (s < srcend) {
+	int			pos = 0,
+				end = 0;
+
+	while (s < srcend)
+	{
 		c = *s++;
 		if (c >= 'A' && c <= 'Z')
 			b = c - 'A';
@@ -266,16 +293,21 @@ b64_decode(uint8 *src, uint len, uint8 *dst)
 			b = 62;
 		else if (c == '/')
 			b = 63;
-		else if (c == '=') {
+		else if (c == '=')
+		{
 			/* end sequence */
-			if (!end) {
-				if (pos == 2) end = 1;
-				else if (pos == 3) end = 2;
+			if (!end)
+			{
+				if (pos == 2)
+					end = 1;
+				else if (pos == 3)
+					end = 2;
 				else
 					elog(ERROR, "base64: unexpected '='");
 			}
 			b = 0;
-		} else if (c == ' ' || c == '\t' || c == '\n' || c == '\r')
+		}
+		else if (c == ' ' || c == '\t' || c == '\n' || c == '\r')
 			continue;
 		else
 			elog(ERROR, "base64: Invalid symbol");
@@ -283,7 +315,8 @@ b64_decode(uint8 *src, uint len, uint8 *dst)
 		/* add it to buffer */
 		buf = (buf << 6) + b;
 		pos++;
-		if (pos == 4) {
+		if (pos == 4)
+		{
 			*p++ = (buf >> 16) & 255;
 			if (end == 0 || end > 1)
 				*p++ = (buf >> 8) & 255;
@@ -326,21 +359,22 @@ b64_dec_len(uint srclen)
 }
 
 static pg_coding
-encoding_list [] = {
-	{ "hex", hex_enc_len, hex_dec_len, hex_encode, hex_decode},
-	{ "base64", b64_enc_len, b64_dec_len, b64_encode, b64_decode},
-	{ NULL, NULL, NULL, NULL, NULL}
+			encoding_list[] = {
+	{"hex", hex_enc_len, hex_dec_len, hex_encode, hex_decode},
+	{"base64", b64_enc_len, b64_dec_len, b64_encode, b64_decode},
+	{NULL, NULL, NULL, NULL, NULL}
 };
 
 
 static pg_coding *
-pg_find_coding(pg_coding *res, char *name)
+pg_find_coding(pg_coding * res, char *name)
 {
-	pg_coding *p;
-	for (p = encoding_list; p->name; p++) {
+	pg_coding  *p;
+
+	for (p = encoding_list; p->name; p++)
+	{
 		if (!strcasecmp(p->name, name))
 			return p;
 	}
 	return NULL;
 }
-
diff --git a/contrib/pgcrypto/encode.h b/contrib/pgcrypto/encode.h
index 33e6508cb1..451e06d75b 100644
--- a/contrib/pgcrypto/encode.h
+++ b/contrib/pgcrypto/encode.h
@@ -1,7 +1,7 @@
 /*
  * pg_encode.h
  *		encode.c
- * 
+ *
  * Copyright (c) 2001 Marko Kreen
  * All rights reserved.
  *
@@ -9,15 +9,15 @@
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
+ *	  notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
+ *	  notice, this list of conditions and the following disclaimer in the
+ *	  documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * ARE DISCLAIMED.	IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
@@ -26,35 +26,35 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- * $Id: encode.h,v 1.1 2001/01/24 03:46:16 momjian Exp $
+ * $Id: encode.h,v 1.2 2001/03/22 03:59:10 momjian Exp $
  */
 
 #ifndef __PG_ENCODE_H
 #define __PG_ENCODE_H
 
 /* exported functions */
-Datum encode(PG_FUNCTION_ARGS);
-Datum decode(PG_FUNCTION_ARGS);
+Datum		encode(PG_FUNCTION_ARGS);
+Datum		decode(PG_FUNCTION_ARGS);
 
 typedef struct _pg_coding pg_coding;
-struct _pg_coding {
-	char *name;
-	uint (*encode_len)(uint dlen);
-	uint (*decode_len)(uint dlen);
-	uint (*encode)(uint8 *data, uint dlen, uint8 *res);
-	uint (*decode)(uint8 *data, uint dlen, uint8 *res);
+struct _pg_coding
+{
+	char	   *name;
+	uint		(*encode_len) (uint dlen);
+	uint		(*decode_len) (uint dlen);
+	uint		(*encode) (uint8 *data, uint dlen, uint8 *res);
+	uint		(*decode) (uint8 *data, uint dlen, uint8 *res);
 };
 
 /* They are for outside usage in C code, if needed */
-uint hex_encode(uint8 *src, uint len, uint8 *dst);
-uint hex_decode(uint8 *src, uint len, uint8 *dst);
-uint b64_encode(uint8 *src, uint len, uint8 *dst);
-uint b64_decode(uint8 *src, uint len, uint8 *dst);
-
-uint hex_enc_len(uint srclen);
-uint hex_dec_len(uint srclen);
-uint b64_enc_len(uint srclen);
-uint b64_dec_len(uint srclen);
+uint		hex_encode(uint8 *src, uint len, uint8 *dst);
+uint		hex_decode(uint8 *src, uint len, uint8 *dst);
+uint		b64_encode(uint8 *src, uint len, uint8 *dst);
+uint		b64_decode(uint8 *src, uint len, uint8 *dst);
 
-#endif /* __PG_ENCODE_H */
+uint		hex_enc_len(uint srclen);
+uint		hex_dec_len(uint srclen);
+uint		b64_enc_len(uint srclen);
+uint		b64_dec_len(uint srclen);
 
+#endif	 /* __PG_ENCODE_H */
diff --git a/contrib/pgcrypto/internal.c b/contrib/pgcrypto/internal.c
index 3c6e6fc80b..2d4a52717e 100644
--- a/contrib/pgcrypto/internal.c
+++ b/contrib/pgcrypto/internal.c
@@ -1,7 +1,7 @@
 /*
  * internal.c
  *		Wrapper for builtin functions
- * 
+ *
  * Copyright (c) 2000 Marko Kreen
  * All rights reserved.
  *
@@ -9,15 +9,15 @@
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
+ *	  notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
+ *	  notice, this list of conditions and the following disclaimer in the
+ *	  documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * ARE DISCLAIMED.	IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
@@ -26,7 +26,7 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- * $Id: internal.c,v 1.2 2001/02/10 02:31:25 tgl Exp $
+ * $Id: internal.c,v 1.3 2001/03/22 03:59:10 momjian Exp $
  */
 
 #include "postgres.h"
@@ -49,31 +49,32 @@
 #endif
 
 static uint
-pg_md5_len(pg_digest *h);
+			pg_md5_len(pg_digest * h);
 static uint8 *
-pg_md5_digest(pg_digest *h, uint8 *src, uint len, uint8 *buf);
+			pg_md5_digest(pg_digest * h, uint8 *src, uint len, uint8 *buf);
 
 static uint
-pg_sha1_len(pg_digest *h);
+			pg_sha1_len(pg_digest * h);
 static uint8 *
-pg_sha1_digest(pg_digest *h, uint8 *src, uint len, uint8 *buf);
+			pg_sha1_digest(pg_digest * h, uint8 *src, uint len, uint8 *buf);
 
 static pg_digest
-int_digest_list [] = {
-	{ "md5", pg_md5_len, pg_md5_digest, {0}},
-	{ "sha1", pg_sha1_len, pg_sha1_digest, {0}},
-	{ NULL, NULL, NULL, {0}}
+			int_digest_list[] = {
+	{"md5", pg_md5_len, pg_md5_digest, {0}},
+	{"sha1", pg_sha1_len, pg_sha1_digest, {0}},
+	{NULL, NULL, NULL, {0}}
 };
 
 static uint
-pg_md5_len(pg_digest *h) {
+pg_md5_len(pg_digest * h)
+{
 	return MD5_DIGEST_LENGTH;
 }
 
 static uint8 *
-pg_md5_digest(pg_digest *h, uint8 *src, uint len, uint8 *buf)
+pg_md5_digest(pg_digest * h, uint8 *src, uint len, uint8 *buf)
 {
-	MD5_CTX ctx;
+	MD5_CTX		ctx;
 
 	MD5Init(&ctx);
 	MD5Update(&ctx, src, len);
@@ -83,32 +84,31 @@ pg_md5_digest(pg_digest *h, uint8 *src, uint len, uint8 *buf)
 }
 
 static uint
-pg_sha1_len(pg_digest *h) {
+pg_sha1_len(pg_digest * h)
+{
 	return SHA1_DIGEST_LENGTH;
 }
 
 static uint8 *
-pg_sha1_digest(pg_digest *h, uint8 *src, uint len, uint8 *buf)
+pg_sha1_digest(pg_digest * h, uint8 *src, uint len, uint8 *buf)
 {
-	SHA1_CTX ctx;
+	SHA1_CTX	ctx;
 
 	SHA1Init(&ctx);
 	SHA1Update(&ctx, src, len);
 	SHA1Final(buf, &ctx);
-	
+
 	return buf;
 }
 
 
-pg_digest *
-pg_find_digest(pg_digest *h, char *name)
+pg_digest  *
+pg_find_digest(pg_digest * h, char *name)
 {
-	pg_digest *p;
+	pg_digest  *p;
 
 	for (p = int_digest_list; p->name; p++)
 		if (!strcasecmp(p->name, name))
 			return p;
 	return NULL;
 }
-
-
diff --git a/contrib/pgcrypto/krb.c b/contrib/pgcrypto/krb.c
index 14ac44b29d..95df07ca27 100644
--- a/contrib/pgcrypto/krb.c
+++ b/contrib/pgcrypto/krb.c
@@ -1,7 +1,7 @@
 /*
  * krb.c
  *		Wrapper for Kerberos5 libdes SHA1/MD5.
- * 
+ *
  * Copyright (c) 2000 Marko Kreen
  * All rights reserved.
  *
@@ -9,15 +9,15 @@
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
+ *	  notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
+ *	  notice, this list of conditions and the following disclaimer in the
+ *	  documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * ARE DISCLAIMED.	IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
@@ -26,12 +26,12 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- * 
+ *
  * NOTES
  *	It is possible that this works with other SHA1/MD5
  *	implementations too.
  *
- * $Id: krb.c,v 1.3 2001/02/20 15:34:14 momjian Exp $
+ * $Id: krb.c,v 1.4 2001/03/22 03:59:10 momjian Exp $
  */
 
 #include "postgres.h"
@@ -54,31 +54,32 @@
 #endif
 
 static uint
-pg_md5_len(pg_digest *h);
+			pg_md5_len(pg_digest * h);
 static uint8 *
-pg_md5_digest(pg_digest *h, uint8 *src, uint len, uint8 *buf);
+			pg_md5_digest(pg_digest * h, uint8 *src, uint len, uint8 *buf);
 
 static uint
-pg_sha1_len(pg_digest *h);
+			pg_sha1_len(pg_digest * h);
 static uint8 *
-pg_sha1_digest(pg_digest *h, uint8 *src, uint len, uint8 *buf);
+			pg_sha1_digest(pg_digest * h, uint8 *src, uint len, uint8 *buf);
 
 static pg_digest
-int_digest_list [] = {
-	{ "md5", pg_md5_len, pg_md5_digest, {0}},
-	{ "sha1", pg_sha1_len, pg_sha1_digest, {0}},
-	{ NULL, NULL, NULL, {0}}
+			int_digest_list[] = {
+	{"md5", pg_md5_len, pg_md5_digest, {0}},
+	{"sha1", pg_sha1_len, pg_sha1_digest, {0}},
+	{NULL, NULL, NULL, {0}}
 };
 
 static uint
-pg_md5_len(pg_digest *h) {
+pg_md5_len(pg_digest * h)
+{
 	return MD5_DIGEST_LENGTH;
 }
 
 static uint8 *
-pg_md5_digest(pg_digest *h, uint8 *src, uint len, uint8 *buf)
+pg_md5_digest(pg_digest * h, uint8 *src, uint len, uint8 *buf)
 {
-	MD5_CTX ctx;
+	MD5_CTX		ctx;
 
 	MD5Init(&ctx);
 	MD5Update(&ctx, src, len);
@@ -88,32 +89,31 @@ pg_md5_digest(pg_digest *h, uint8 *src, uint len, uint8 *buf)
 }
 
 static uint
-pg_sha1_len(pg_digest *h) {
+pg_sha1_len(pg_digest * h)
+{
 	return SHA1_DIGEST_LENGTH;
 }
 
 static uint8 *
-pg_sha1_digest(pg_digest *h, uint8 *src, uint len, uint8 *buf)
+pg_sha1_digest(pg_digest * h, uint8 *src, uint len, uint8 *buf)
 {
-	SHA1_CTX ctx;
+	SHA1_CTX	ctx;
 
 	SHA1Init(&ctx);
 	SHA1Update(&ctx, src, len);
 	SHA1Final(buf, &ctx);
-	
+
 	return buf;
 }
 
 
-pg_digest *
-pg_find_digest(pg_digest *h, char *name)
+pg_digest  *
+pg_find_digest(pg_digest * h, char *name)
 {
-	pg_digest *p;
+	pg_digest  *p;
 
 	for (p = int_digest_list; p->name; p++)
 		if (!strcasecmp(p->name, name))
 			return p;
 	return NULL;
 }
-
-
diff --git a/contrib/pgcrypto/md5.c b/contrib/pgcrypto/md5.c
index d538720231..a5cfae3497 100644
--- a/contrib/pgcrypto/md5.c
+++ b/contrib/pgcrypto/md5.c
@@ -1,5 +1,5 @@
-/*	$Id: md5.c,v 1.4 2001/02/10 02:31:25 tgl Exp $	*/
-/*     $KAME: md5.c,v 1.3 2000/02/22 14:01:17 itojun Exp $     */
+/*	$Id: md5.c,v 1.5 2001/03/22 03:59:10 momjian Exp $	*/
+/*	   $KAME: md5.c,v 1.3 2000/02/22 14:01:17 itojun Exp $	   */
 
 /*
  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
@@ -9,18 +9,18 @@
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
+ *	  notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
+ *	  notice, this list of conditions and the following disclaimer in the
+ *	  documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the project nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
+ *	  may be used to endorse or promote products derived from this software
+ *	  without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
+ * ARE DISCLAIMED.	IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
@@ -93,42 +93,43 @@
 /* Integer part of 4294967296 times abs(sin(i)), where i is in radians. */
 static const uint32 T[65] = {
 	0,
-	0xd76aa478, 	0xe8c7b756,	0x242070db,	0xc1bdceee,
-	0xf57c0faf,	0x4787c62a, 	0xa8304613,	0xfd469501,
-	0x698098d8,	0x8b44f7af,	0xffff5bb1,	0x895cd7be,
-	0x6b901122, 	0xfd987193, 	0xa679438e,	0x49b40821,
-
-	0xf61e2562,	0xc040b340, 	0x265e5a51, 	0xe9b6c7aa,
-	0xd62f105d,	0x2441453,	0xd8a1e681,	0xe7d3fbc8,
-	0x21e1cde6,	0xc33707d6, 	0xf4d50d87, 	0x455a14ed,
-	0xa9e3e905,	0xfcefa3f8, 	0x676f02d9, 	0x8d2a4c8a,
-
-	0xfffa3942,	0x8771f681, 	0x6d9d6122, 	0xfde5380c,
-	0xa4beea44, 	0x4bdecfa9, 	0xf6bb4b60, 	0xbebfbc70,
-	0x289b7ec6, 	0xeaa127fa, 	0xd4ef3085,	0x4881d05,
-	0xd9d4d039, 	0xe6db99e5, 	0x1fa27cf8, 	0xc4ac5665,
-
-	0xf4292244, 	0x432aff97, 	0xab9423a7, 	0xfc93a039,
-	0x655b59c3, 	0x8f0ccc92, 	0xffeff47d, 	0x85845dd1,
-	0x6fa87e4f, 	0xfe2ce6e0, 	0xa3014314, 	0x4e0811a1,
-	0xf7537e82, 	0xbd3af235, 	0x2ad7d2bb, 	0xeb86d391,
+	0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,
+	0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
+	0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
+	0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
+
+	0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,
+	0xd62f105d, 0x2441453, 0xd8a1e681, 0xe7d3fbc8,
+	0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
+	0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
+
+	0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
+	0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
+	0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x4881d05,
+	0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
+
+	0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,
+	0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
+	0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
+	0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391,
 };
 
 static const uint8 md5_paddat[MD5_BUFLEN] = {
-	0x80,	0,	0,	0,	0,	0,	0,	0,
-	0,	0,	0,	0,	0,	0,	0,	0,
-	0,	0,	0,	0,	0,	0,	0,	0,
-	0,	0,	0,	0,	0,	0,	0,	0,
-	0,	0,	0,	0,	0,	0,	0,	0,
-	0,	0,	0,	0,	0,	0,	0,	0,
-	0,	0,	0,	0,	0,	0,	0,	0,
-	0,	0,	0,	0,	0,	0,	0,	0,	
+	0x80, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
 };
 
-static void md5_calc (uint8 *, md5_ctxt *);
+static void md5_calc(uint8 *, md5_ctxt *);
 
-void md5_init(ctxt)
-	md5_ctxt *ctxt;
+void
+md5_init(ctxt)
+md5_ctxt   *ctxt;
 {
 	ctxt->md5_n = 0;
 	ctxt->md5_i = 0;
@@ -139,56 +140,64 @@ void md5_init(ctxt)
 	bzero(ctxt->md5_buf, sizeof(ctxt->md5_buf));
 }
 
-void md5_loop(ctxt, input, len)
-	md5_ctxt *ctxt;
-	uint8 *input;
-	unsigned int len; /* number of bytes */
+void
+md5_loop(ctxt, input, len)
+md5_ctxt   *ctxt;
+uint8	   *input;
+unsigned int len;				/* number of bytes */
 {
-	unsigned int gap, i;
+	unsigned int gap,
+				i;
 
-	ctxt->md5_n += len * 8; /* byte to bit */
+	ctxt->md5_n += len * 8;		/* byte to bit */
 	gap = MD5_BUFLEN - ctxt->md5_i;
 
-	if (len >= gap) {
-		bcopy((void *)input, (void *)(ctxt->md5_buf + ctxt->md5_i),
-			gap);
+	if (len >= gap)
+	{
+		bcopy((void *) input, (void *) (ctxt->md5_buf + ctxt->md5_i),
+			  gap);
 		md5_calc(ctxt->md5_buf, ctxt);
 
-		for (i = gap; i + MD5_BUFLEN <= len; i += MD5_BUFLEN) {
-			md5_calc((uint8 *)(input + i), ctxt);
-		}
-		
+		for (i = gap; i + MD5_BUFLEN <= len; i += MD5_BUFLEN)
+			md5_calc((uint8 *) (input + i), ctxt);
+
 		ctxt->md5_i = len - i;
-		bcopy((void *)(input + i), (void *)ctxt->md5_buf, ctxt->md5_i);
-	} else {
-		bcopy((void *)input, (void *)(ctxt->md5_buf + ctxt->md5_i),
-			len);
+		bcopy((void *) (input + i), (void *) ctxt->md5_buf, ctxt->md5_i);
+	}
+	else
+	{
+		bcopy((void *) input, (void *) (ctxt->md5_buf + ctxt->md5_i),
+			  len);
 		ctxt->md5_i += len;
 	}
 }
 
-void md5_pad(ctxt)
-	md5_ctxt *ctxt;
+void
+md5_pad(ctxt)
+md5_ctxt   *ctxt;
 {
 	unsigned int gap;
 
-	/* Don't count up padding. Keep md5_n. */	
+	/* Don't count up padding. Keep md5_n. */
 	gap = MD5_BUFLEN - ctxt->md5_i;
-	if (gap > 8) {
-		bcopy((void *)md5_paddat,
-		      (void *)(ctxt->md5_buf + ctxt->md5_i),
-		      gap - sizeof(ctxt->md5_n));
-	} else {
+	if (gap > 8)
+	{
+		bcopy((void *) md5_paddat,
+			  (void *) (ctxt->md5_buf + ctxt->md5_i),
+			  gap - sizeof(ctxt->md5_n));
+	}
+	else
+	{
 		/* including gap == 8 */
-		bcopy((void *)md5_paddat, (void *)(ctxt->md5_buf + ctxt->md5_i),
-			gap);
+		bcopy((void *) md5_paddat, (void *) (ctxt->md5_buf + ctxt->md5_i),
+			  gap);
 		md5_calc(ctxt->md5_buf, ctxt);
-		bcopy((void *)(md5_paddat + gap),
-		      (void *)ctxt->md5_buf,
-		      MD5_BUFLEN - sizeof(ctxt->md5_n));
+		bcopy((void *) (md5_paddat + gap),
+			  (void *) ctxt->md5_buf,
+			  MD5_BUFLEN - sizeof(ctxt->md5_n));
 	}
 
-	/* 8 byte word */	
+	/* 8 byte word */
 #if BYTE_ORDER == LITTLE_ENDIAN
 	bcopy(&ctxt->md5_n8[0], &ctxt->md5_buf[56], 8);
 #endif
@@ -206,98 +215,192 @@ void md5_pad(ctxt)
 	md5_calc(ctxt->md5_buf, ctxt);
 }
 
-void md5_result(digest, ctxt)
-	uint8 *digest;
-	md5_ctxt *ctxt;
+void
+md5_result(digest, ctxt)
+uint8	   *digest;
+md5_ctxt   *ctxt;
 {
 	/* 4 byte words */
 #if BYTE_ORDER == LITTLE_ENDIAN
 	bcopy(&ctxt->md5_st8[0], digest, 16);
 #endif
 #if BYTE_ORDER == BIG_ENDIAN
-	digest[ 0] = ctxt->md5_st8[ 3]; digest[ 1] = ctxt->md5_st8[ 2];
-	digest[ 2] = ctxt->md5_st8[ 1]; digest[ 3] = ctxt->md5_st8[ 0];
-	digest[ 4] = ctxt->md5_st8[ 7]; digest[ 5] = ctxt->md5_st8[ 6];
-	digest[ 6] = ctxt->md5_st8[ 5]; digest[ 7] = ctxt->md5_st8[ 4];
-	digest[ 8] = ctxt->md5_st8[11]; digest[ 9] = ctxt->md5_st8[10];
-	digest[10] = ctxt->md5_st8[ 9]; digest[11] = ctxt->md5_st8[ 8];
-	digest[12] = ctxt->md5_st8[15]; digest[13] = ctxt->md5_st8[14];
-	digest[14] = ctxt->md5_st8[13]; digest[15] = ctxt->md5_st8[12];
+	digest[0] = ctxt->md5_st8[3];
+	digest[1] = ctxt->md5_st8[2];
+	digest[2] = ctxt->md5_st8[1];
+	digest[3] = ctxt->md5_st8[0];
+	digest[4] = ctxt->md5_st8[7];
+	digest[5] = ctxt->md5_st8[6];
+	digest[6] = ctxt->md5_st8[5];
+	digest[7] = ctxt->md5_st8[4];
+	digest[8] = ctxt->md5_st8[11];
+	digest[9] = ctxt->md5_st8[10];
+	digest[10] = ctxt->md5_st8[9];
+	digest[11] = ctxt->md5_st8[8];
+	digest[12] = ctxt->md5_st8[15];
+	digest[13] = ctxt->md5_st8[14];
+	digest[14] = ctxt->md5_st8[13];
+	digest[15] = ctxt->md5_st8[12];
 #endif
 }
 
 #if BYTE_ORDER == BIG_ENDIAN
-uint32 X[16];
+uint32		X[16];
+
 #endif
 
-static void md5_calc(b64, ctxt)
-	uint8 *b64;
-	md5_ctxt *ctxt;
+static void
+md5_calc(b64, ctxt)
+uint8	   *b64;
+md5_ctxt   *ctxt;
 {
-	uint32 A = ctxt->md5_sta;
-	uint32 B = ctxt->md5_stb;
-	uint32 C = ctxt->md5_stc;
-	uint32 D = ctxt->md5_std;
+	uint32		A = ctxt->md5_sta;
+	uint32		B = ctxt->md5_stb;
+	uint32		C = ctxt->md5_stc;
+	uint32		D = ctxt->md5_std;
+
 #if BYTE_ORDER == LITTLE_ENDIAN
-	uint32 *X = (uint32 *)b64;
-#endif	
+	uint32	   *X = (uint32 *) b64;
+
+#endif
 #if BYTE_ORDER == BIG_ENDIAN
 	/* 4 byte words */
 	/* what a brute force but fast! */
-	uint8 *y = (uint8 *)X;
-	y[ 0] = b64[ 3]; y[ 1] = b64[ 2]; y[ 2] = b64[ 1]; y[ 3] = b64[ 0];
-	y[ 4] = b64[ 7]; y[ 5] = b64[ 6]; y[ 6] = b64[ 5]; y[ 7] = b64[ 4];
-	y[ 8] = b64[11]; y[ 9] = b64[10]; y[10] = b64[ 9]; y[11] = b64[ 8];
-	y[12] = b64[15]; y[13] = b64[14]; y[14] = b64[13]; y[15] = b64[12];
-	y[16] = b64[19]; y[17] = b64[18]; y[18] = b64[17]; y[19] = b64[16];
-	y[20] = b64[23]; y[21] = b64[22]; y[22] = b64[21]; y[23] = b64[20];
-	y[24] = b64[27]; y[25] = b64[26]; y[26] = b64[25]; y[27] = b64[24];
-	y[28] = b64[31]; y[29] = b64[30]; y[30] = b64[29]; y[31] = b64[28];
-	y[32] = b64[35]; y[33] = b64[34]; y[34] = b64[33]; y[35] = b64[32];
-	y[36] = b64[39]; y[37] = b64[38]; y[38] = b64[37]; y[39] = b64[36];
-	y[40] = b64[43]; y[41] = b64[42]; y[42] = b64[41]; y[43] = b64[40];
-	y[44] = b64[47]; y[45] = b64[46]; y[46] = b64[45]; y[47] = b64[44];
-	y[48] = b64[51]; y[49] = b64[50]; y[50] = b64[49]; y[51] = b64[48];
-	y[52] = b64[55]; y[53] = b64[54]; y[54] = b64[53]; y[55] = b64[52];
-	y[56] = b64[59]; y[57] = b64[58]; y[58] = b64[57]; y[59] = b64[56];
-	y[60] = b64[63]; y[61] = b64[62]; y[62] = b64[61]; y[63] = b64[60];
+	uint8	   *y = (uint8 *) X;
+
+	y[0] = b64[3];
+	y[1] = b64[2];
+	y[2] = b64[1];
+	y[3] = b64[0];
+	y[4] = b64[7];
+	y[5] = b64[6];
+	y[6] = b64[5];
+	y[7] = b64[4];
+	y[8] = b64[11];
+	y[9] = b64[10];
+	y[10] = b64[9];
+	y[11] = b64[8];
+	y[12] = b64[15];
+	y[13] = b64[14];
+	y[14] = b64[13];
+	y[15] = b64[12];
+	y[16] = b64[19];
+	y[17] = b64[18];
+	y[18] = b64[17];
+	y[19] = b64[16];
+	y[20] = b64[23];
+	y[21] = b64[22];
+	y[22] = b64[21];
+	y[23] = b64[20];
+	y[24] = b64[27];
+	y[25] = b64[26];
+	y[26] = b64[25];
+	y[27] = b64[24];
+	y[28] = b64[31];
+	y[29] = b64[30];
+	y[30] = b64[29];
+	y[31] = b64[28];
+	y[32] = b64[35];
+	y[33] = b64[34];
+	y[34] = b64[33];
+	y[35] = b64[32];
+	y[36] = b64[39];
+	y[37] = b64[38];
+	y[38] = b64[37];
+	y[39] = b64[36];
+	y[40] = b64[43];
+	y[41] = b64[42];
+	y[42] = b64[41];
+	y[43] = b64[40];
+	y[44] = b64[47];
+	y[45] = b64[46];
+	y[46] = b64[45];
+	y[47] = b64[44];
+	y[48] = b64[51];
+	y[49] = b64[50];
+	y[50] = b64[49];
+	y[51] = b64[48];
+	y[52] = b64[55];
+	y[53] = b64[54];
+	y[54] = b64[53];
+	y[55] = b64[52];
+	y[56] = b64[59];
+	y[57] = b64[58];
+	y[58] = b64[57];
+	y[59] = b64[56];
+	y[60] = b64[63];
+	y[61] = b64[62];
+	y[62] = b64[61];
+	y[63] = b64[60];
 #endif
 
-	ROUND1(A, B, C, D,  0, Sa,  1); ROUND1(D, A, B, C,  1, Sb,  2);
-	ROUND1(C, D, A, B,  2, Sc,  3); ROUND1(B, C, D, A,  3, Sd,  4);
-	ROUND1(A, B, C, D,  4, Sa,  5); ROUND1(D, A, B, C,  5, Sb,  6);
-	ROUND1(C, D, A, B,  6, Sc,  7); ROUND1(B, C, D, A,  7, Sd,  8);
-	ROUND1(A, B, C, D,  8, Sa,  9); ROUND1(D, A, B, C,  9, Sb, 10);
-	ROUND1(C, D, A, B, 10, Sc, 11); ROUND1(B, C, D, A, 11, Sd, 12);
-	ROUND1(A, B, C, D, 12, Sa, 13); ROUND1(D, A, B, C, 13, Sb, 14);
-	ROUND1(C, D, A, B, 14, Sc, 15); ROUND1(B, C, D, A, 15, Sd, 16);
-	
-	ROUND2(A, B, C, D,  1, Se, 17); ROUND2(D, A, B, C,  6, Sf, 18);
-	ROUND2(C, D, A, B, 11, Sg, 19); ROUND2(B, C, D, A,  0, Sh, 20);
-	ROUND2(A, B, C, D,  5, Se, 21); ROUND2(D, A, B, C, 10, Sf, 22);
-	ROUND2(C, D, A, B, 15, Sg, 23); ROUND2(B, C, D, A,  4, Sh, 24);
-	ROUND2(A, B, C, D,  9, Se, 25); ROUND2(D, A, B, C, 14, Sf, 26);
-	ROUND2(C, D, A, B,  3, Sg, 27); ROUND2(B, C, D, A,  8, Sh, 28);
-	ROUND2(A, B, C, D, 13, Se, 29); ROUND2(D, A, B, C,  2, Sf, 30);
-	ROUND2(C, D, A, B,  7, Sg, 31); ROUND2(B, C, D, A, 12, Sh, 32);
-
-	ROUND3(A, B, C, D,  5, Si, 33); ROUND3(D, A, B, C,  8, Sj, 34);
-	ROUND3(C, D, A, B, 11, Sk, 35); ROUND3(B, C, D, A, 14, Sl, 36);
-	ROUND3(A, B, C, D,  1, Si, 37); ROUND3(D, A, B, C,  4, Sj, 38);
-	ROUND3(C, D, A, B,  7, Sk, 39); ROUND3(B, C, D, A, 10, Sl, 40);
-	ROUND3(A, B, C, D, 13, Si, 41); ROUND3(D, A, B, C,  0, Sj, 42);
-	ROUND3(C, D, A, B,  3, Sk, 43); ROUND3(B, C, D, A,  6, Sl, 44);
-	ROUND3(A, B, C, D,  9, Si, 45); ROUND3(D, A, B, C, 12, Sj, 46);
-	ROUND3(C, D, A, B, 15, Sk, 47); ROUND3(B, C, D, A,  2, Sl, 48);
-	
-	ROUND4(A, B, C, D,  0, Sm, 49); ROUND4(D, A, B, C,  7, Sn, 50);	
-	ROUND4(C, D, A, B, 14, So, 51); ROUND4(B, C, D, A,  5, Sp, 52);	
-	ROUND4(A, B, C, D, 12, Sm, 53); ROUND4(D, A, B, C,  3, Sn, 54);	
-	ROUND4(C, D, A, B, 10, So, 55); ROUND4(B, C, D, A,  1, Sp, 56);	
-	ROUND4(A, B, C, D,  8, Sm, 57); ROUND4(D, A, B, C, 15, Sn, 58);	
-	ROUND4(C, D, A, B,  6, So, 59); ROUND4(B, C, D, A, 13, Sp, 60);	
-	ROUND4(A, B, C, D,  4, Sm, 61); ROUND4(D, A, B, C, 11, Sn, 62);	
-	ROUND4(C, D, A, B,  2, So, 63); ROUND4(B, C, D, A,  9, Sp, 64);
+	ROUND1(A, B, C, D, 0, Sa, 1);
+	ROUND1(D, A, B, C, 1, Sb, 2);
+	ROUND1(C, D, A, B, 2, Sc, 3);
+	ROUND1(B, C, D, A, 3, Sd, 4);
+	ROUND1(A, B, C, D, 4, Sa, 5);
+	ROUND1(D, A, B, C, 5, Sb, 6);
+	ROUND1(C, D, A, B, 6, Sc, 7);
+	ROUND1(B, C, D, A, 7, Sd, 8);
+	ROUND1(A, B, C, D, 8, Sa, 9);
+	ROUND1(D, A, B, C, 9, Sb, 10);
+	ROUND1(C, D, A, B, 10, Sc, 11);
+	ROUND1(B, C, D, A, 11, Sd, 12);
+	ROUND1(A, B, C, D, 12, Sa, 13);
+	ROUND1(D, A, B, C, 13, Sb, 14);
+	ROUND1(C, D, A, B, 14, Sc, 15);
+	ROUND1(B, C, D, A, 15, Sd, 16);
+
+	ROUND2(A, B, C, D, 1, Se, 17);
+	ROUND2(D, A, B, C, 6, Sf, 18);
+	ROUND2(C, D, A, B, 11, Sg, 19);
+	ROUND2(B, C, D, A, 0, Sh, 20);
+	ROUND2(A, B, C, D, 5, Se, 21);
+	ROUND2(D, A, B, C, 10, Sf, 22);
+	ROUND2(C, D, A, B, 15, Sg, 23);
+	ROUND2(B, C, D, A, 4, Sh, 24);
+	ROUND2(A, B, C, D, 9, Se, 25);
+	ROUND2(D, A, B, C, 14, Sf, 26);
+	ROUND2(C, D, A, B, 3, Sg, 27);
+	ROUND2(B, C, D, A, 8, Sh, 28);
+	ROUND2(A, B, C, D, 13, Se, 29);
+	ROUND2(D, A, B, C, 2, Sf, 30);
+	ROUND2(C, D, A, B, 7, Sg, 31);
+	ROUND2(B, C, D, A, 12, Sh, 32);
+
+	ROUND3(A, B, C, D, 5, Si, 33);
+	ROUND3(D, A, B, C, 8, Sj, 34);
+	ROUND3(C, D, A, B, 11, Sk, 35);
+	ROUND3(B, C, D, A, 14, Sl, 36);
+	ROUND3(A, B, C, D, 1, Si, 37);
+	ROUND3(D, A, B, C, 4, Sj, 38);
+	ROUND3(C, D, A, B, 7, Sk, 39);
+	ROUND3(B, C, D, A, 10, Sl, 40);
+	ROUND3(A, B, C, D, 13, Si, 41);
+	ROUND3(D, A, B, C, 0, Sj, 42);
+	ROUND3(C, D, A, B, 3, Sk, 43);
+	ROUND3(B, C, D, A, 6, Sl, 44);
+	ROUND3(A, B, C, D, 9, Si, 45);
+	ROUND3(D, A, B, C, 12, Sj, 46);
+	ROUND3(C, D, A, B, 15, Sk, 47);
+	ROUND3(B, C, D, A, 2, Sl, 48);
+
+	ROUND4(A, B, C, D, 0, Sm, 49);
+	ROUND4(D, A, B, C, 7, Sn, 50);
+	ROUND4(C, D, A, B, 14, So, 51);
+	ROUND4(B, C, D, A, 5, Sp, 52);
+	ROUND4(A, B, C, D, 12, Sm, 53);
+	ROUND4(D, A, B, C, 3, Sn, 54);
+	ROUND4(C, D, A, B, 10, So, 55);
+	ROUND4(B, C, D, A, 1, Sp, 56);
+	ROUND4(A, B, C, D, 8, Sm, 57);
+	ROUND4(D, A, B, C, 15, Sn, 58);
+	ROUND4(C, D, A, B, 6, So, 59);
+	ROUND4(B, C, D, A, 13, Sp, 60);
+	ROUND4(A, B, C, D, 4, Sm, 61);
+	ROUND4(D, A, B, C, 11, Sn, 62);
+	ROUND4(C, D, A, B, 2, So, 63);
+	ROUND4(B, C, D, A, 9, Sp, 64);
 
 	ctxt->md5_sta += A;
 	ctxt->md5_stb += B;
diff --git a/contrib/pgcrypto/md5.h b/contrib/pgcrypto/md5.h
index b724c34ba0..54ca2558df 100644
--- a/contrib/pgcrypto/md5.h
+++ b/contrib/pgcrypto/md5.h
@@ -1,5 +1,5 @@
-/*	$Id: md5.h,v 1.3 2001/01/09 16:07:13 momjian Exp $	*/
-/*     $KAME: md5.h,v 1.3 2000/02/22 14:01:18 itojun Exp $     */
+/*	$Id: md5.h,v 1.4 2001/03/22 03:59:10 momjian Exp $	*/
+/*	   $KAME: md5.h,v 1.3 2000/02/22 14:01:18 itojun Exp $	   */
 
 /*
  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
@@ -9,18 +9,18 @@
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
+ *	  notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
+ *	  notice, this list of conditions and the following disclaimer in the
+ *	  documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the project nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
+ *	  may be used to endorse or promote products derived from this software
+ *	  without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
+ * ARE DISCLAIMED.	IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
@@ -35,11 +35,13 @@
 
 #define MD5_BUFLEN	64
 
-typedef struct {
-	union {
+typedef struct
+{
+	union
+	{
 		uint32		md5_state32[4];
 		uint8		md5_state8[16];
-	} md5_st;
+	}			md5_st;
 
 #define md5_sta		md5_st.md5_state32[0]
 #define md5_stb		md5_st.md5_state32[1]
@@ -47,21 +49,22 @@ typedef struct {
 #define md5_std		md5_st.md5_state32[3]
 #define md5_st8		md5_st.md5_state8
 
-	union {
+	union
+	{
 		uint64		md5_count64;
 		uint8		md5_count8[8];
-	} md5_count;
+	}			md5_count;
 #define md5_n	md5_count.md5_count64
 #define md5_n8	md5_count.md5_count8
 
-	unsigned int	md5_i;
-	uint8			md5_buf[MD5_BUFLEN];
-} md5_ctxt;
+	unsigned int md5_i;
+	uint8		md5_buf[MD5_BUFLEN];
+}			md5_ctxt;
 
-extern void md5_init (md5_ctxt *);
-extern void md5_loop (md5_ctxt *, uint8 *, unsigned int);
-extern void md5_pad (md5_ctxt *);
-extern void md5_result (uint8 *, md5_ctxt *);
+extern void md5_init(md5_ctxt *);
+extern void md5_loop(md5_ctxt *, uint8 *, unsigned int);
+extern void md5_pad(md5_ctxt *);
+extern void md5_result(uint8 *, md5_ctxt *);
 
 /* compatibility */
 #define MD5_CTX		md5_ctxt
@@ -73,4 +76,4 @@ do {				\
 	md5_result((x), (y));	\
 } while (0)
 
-#endif /* ! _NETINET6_MD5_H_*/
+#endif	 /* ! _NETINET6_MD5_H_ */
diff --git a/contrib/pgcrypto/mhash.c b/contrib/pgcrypto/mhash.c
index 34ac7e9c7a..d6ada96d14 100644
--- a/contrib/pgcrypto/mhash.c
+++ b/contrib/pgcrypto/mhash.c
@@ -1,7 +1,7 @@
 /*
  * mhash.c
  *		Wrapper for mhash library.
- * 
+ *
  * Copyright (c) 2000 Marko Kreen
  * All rights reserved.
  *
@@ -9,15 +9,15 @@
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
+ *	  notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
+ *	  notice, this list of conditions and the following disclaimer in the
+ *	  documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * ARE DISCLAIMED.	IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
@@ -26,7 +26,7 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- * $Id: mhash.c,v 1.2 2001/02/10 02:31:26 tgl Exp $
+ * $Id: mhash.c,v 1.3 2001/03/22 03:59:10 momjian Exp $
  */
 
 #include "postgres.h"
@@ -36,45 +36,50 @@
 #include <mhash.h>
 
 static uint
-pg_mhash_len(pg_digest *hash);
-static uint8 *
-pg_mhash_digest(pg_digest *hash, uint8 *src,
-		uint len, uint8 *buf);
+			pg_mhash_len(pg_digest * hash);
+static uint8 *pg_mhash_digest(pg_digest * hash, uint8 *src,
+				uint len, uint8 *buf);
 
 static uint
-pg_mhash_len(pg_digest *h) {
+pg_mhash_len(pg_digest * h)
+{
 	return mhash_get_block_size(h->misc.code);
 }
 
 static uint8 *
-pg_mhash_digest(pg_digest *h, uint8 *src, uint len, uint8 *dst)
+pg_mhash_digest(pg_digest * h, uint8 *src, uint len, uint8 *dst)
 {
-	uint8 *res;
-	
-	MHASH mh = mhash_init(h->misc.code);
+	uint8	   *res;
+
+	MHASH		mh = mhash_init(h->misc.code);
+
 	mhash(mh, src, len);
 	res = mhash_end(mh);
-	
+
 	memcpy(dst, res, mhash_get_block_size(h->misc.code));
 	mhash_free(res);
-	
+
 	return dst;
 }
 
-pg_digest *
-pg_find_digest(pg_digest *h, char *name)
+pg_digest  *
+pg_find_digest(pg_digest * h, char *name)
 {
-	size_t hnum, i, b;
-	char *mname;
-	
+	size_t		hnum,
+				i,
+				b;
+	char	   *mname;
+
 	hnum = mhash_count();
-	for (i = 0; i <= hnum; i++) {
+	for (i = 0; i <= hnum; i++)
+	{
 		mname = mhash_get_hash_name(i);
 		if (mname == NULL)
 			continue;
 		b = strcasecmp(name, mname);
 		free(mname);
-		if (!b) {
+		if (!b)
+		{
 			h->name = mhash_get_hash_name(i);
 			h->length = pg_mhash_len;
 			h->digest = pg_mhash_digest;
@@ -84,4 +89,3 @@ pg_find_digest(pg_digest *h, char *name)
 	}
 	return NULL;
 }
-
diff --git a/contrib/pgcrypto/openssl.c b/contrib/pgcrypto/openssl.c
index 18fb075488..866d26f0ff 100644
--- a/contrib/pgcrypto/openssl.c
+++ b/contrib/pgcrypto/openssl.c
@@ -1,7 +1,7 @@
 /*
  * openssl.c
  *		Wrapper for OpenSSL library.
- * 
+ *
  * Copyright (c) 2000 Marko Kreen
  * All rights reserved.
  *
@@ -9,15 +9,15 @@
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
+ *	  notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
+ *	  notice, this list of conditions and the following disclaimer in the
+ *	  documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * ARE DISCLAIMED.	IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
@@ -26,7 +26,7 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- * $Id: openssl.c,v 1.2 2001/02/10 02:31:26 tgl Exp $
+ * $Id: openssl.c,v 1.3 2001/03/22 03:59:10 momjian Exp $
  */
 
 #include "postgres.h"
@@ -36,50 +36,50 @@
 #include <evp.h>
 
 static uint
-pg_ossl_len(pg_digest *h);
+			pg_ossl_len(pg_digest * h);
 static uint8 *
-pg_ossl_digest(pg_digest *h, uint8 *src, uint len, uint8 *buf);
+			pg_ossl_digest(pg_digest * h, uint8 *src, uint len, uint8 *buf);
 
 static uint
-pg_ossl_len(pg_digest *h) {
-	return EVP_MD_size((EVP_MD*)h->misc.ptr);
+pg_ossl_len(pg_digest * h)
+{
+	return EVP_MD_size((EVP_MD *) h->misc.ptr);
 }
 
 static uint8 *
-pg_ossl_digest(pg_digest *h, uint8 *src, uint len, uint8 *buf)
+pg_ossl_digest(pg_digest * h, uint8 *src, uint len, uint8 *buf)
 {
-	EVP_MD *md = (EVP_MD*)h->misc.ptr;
-	EVP_MD_CTX ctx;
+	EVP_MD	   *md = (EVP_MD *) h->misc.ptr;
+	EVP_MD_CTX	ctx;
 
 	EVP_DigestInit(&ctx, md);
 	EVP_DigestUpdate(&ctx, src, len);
 	EVP_DigestFinal(&ctx, buf, NULL);
-	
+
 	return buf;
 }
 
-static int pg_openssl_initialized = 0;
+static int	pg_openssl_initialized = 0;
 
-pg_digest *
-pg_find_digest(pg_digest *h, char *name)
+pg_digest  *
+pg_find_digest(pg_digest * h, char *name)
 {
 	const EVP_MD *md;
 
-	if (!pg_openssl_initialized) {
+	if (!pg_openssl_initialized)
+	{
 		OpenSSL_add_all_digests();
 		pg_openssl_initialized = 1;
 	}
-	
+
 	md = EVP_get_digestbyname(name);
 	if (md == NULL)
 		return NULL;
-	
+
 	h->name = name;
 	h->length = pg_ossl_len;
 	h->digest = pg_ossl_digest;
-	h->misc.ptr = (void*)md;
-	
+	h->misc.ptr = (void *) md;
+
 	return h;
 }
-
-
diff --git a/contrib/pgcrypto/pgcrypto.c b/contrib/pgcrypto/pgcrypto.c
index 1feb3e4806..31e5a845bd 100644
--- a/contrib/pgcrypto/pgcrypto.c
+++ b/contrib/pgcrypto/pgcrypto.c
@@ -1,7 +1,7 @@
 /*
  * pgcrypto.c
  *		Cryptographic digests for PostgreSQL.
- * 
+ *
  * Copyright (c) 2000 Marko Kreen
  * All rights reserved.
  *
@@ -9,15 +9,15 @@
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
+ *	  notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
+ *	  notice, this list of conditions and the following disclaimer in the
+ *	  documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * ARE DISCLAIMED.	IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
@@ -26,7 +26,7 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- * $Id: pgcrypto.c,v 1.6 2001/02/10 02:31:26 tgl Exp $
+ * $Id: pgcrypto.c,v 1.7 2001/03/22 03:59:10 momjian Exp $
  */
 
 #include "postgres.h"
@@ -44,12 +44,12 @@
 
 
 /* exported functions */
-Datum digest(PG_FUNCTION_ARGS);
-Datum digest_exists(PG_FUNCTION_ARGS);
+Datum		digest(PG_FUNCTION_ARGS);
+Datum		digest_exists(PG_FUNCTION_ARGS);
 
 /* private stuff */
 static pg_digest *
-find_digest(pg_digest *hbuf, text *name, int silent);
+			find_digest(pg_digest * hbuf, text *name, int silent);
 
 
 /* SQL function: hash(text, text) returns text */
@@ -58,31 +58,33 @@ PG_FUNCTION_INFO_V1(digest);
 Datum
 digest(PG_FUNCTION_ARGS)
 {
-	text *arg;
-	text *name;
-	uint len, hlen;
-	pg_digest *h, _hbuf;
-	text *res;
-	
+	text	   *arg;
+	text	   *name;
+	uint		len,
+				hlen;
+	pg_digest  *h,
+				_hbuf;
+	text	   *res;
+
 	if (PG_ARGISNULL(0) || PG_ARGISNULL(1))
 		PG_RETURN_NULL();
-	
-	name = PG_GETARG_TEXT_P(1);	
-	h = find_digest(&_hbuf, name, 0); /* will give error if fails */
+
+	name = PG_GETARG_TEXT_P(1);
+	h = find_digest(&_hbuf, name, 0);	/* will give error if fails */
 
 	hlen = h->length(h);
-	
-	res = (text *)palloc(hlen + VARHDRSZ);
+
+	res = (text *) palloc(hlen + VARHDRSZ);
 	VARATT_SIZEP(res) = hlen + VARHDRSZ;
-	
+
 	arg = PG_GETARG_TEXT_P(0);
 	len = VARSIZE(arg) - VARHDRSZ;
-	
+
 	h->digest(h, VARDATA(arg), len, VARDATA(res));
-	
+
 	PG_FREE_IF_COPY(arg, 0);
 	PG_FREE_IF_COPY(name, 1);
-	
+
 	PG_RETURN_TEXT_P(res);
 }
 
@@ -92,16 +94,17 @@ PG_FUNCTION_INFO_V1(digest_exists);
 Datum
 digest_exists(PG_FUNCTION_ARGS)
 {
-	text *name;
-	pg_digest _hbuf, *res;
+	text	   *name;
+	pg_digest	_hbuf,
+			   *res;
 
 	if (PG_ARGISNULL(0))
 		PG_RETURN_NULL();
-	
+
 	name = PG_GETARG_TEXT_P(0);
-	
+
 	res = find_digest(&_hbuf, name, 1);
-	
+
 	PG_FREE_IF_COPY(name, 0);
 
 	if (res != NULL)
@@ -110,26 +113,26 @@ digest_exists(PG_FUNCTION_ARGS)
 }
 
 static pg_digest *
-find_digest(pg_digest *hbuf, text *name, int silent)
+find_digest(pg_digest * hbuf, text *name, int silent)
 {
-	pg_digest *p;
-	char buf[NAMEDATALEN];
-	uint len;
-	
+	pg_digest  *p;
+	char		buf[NAMEDATALEN];
+	uint		len;
+
 	len = VARSIZE(name) - VARHDRSZ;
-	if (len >= NAMEDATALEN) {
+	if (len >= NAMEDATALEN)
+	{
 		if (silent)
 			return NULL;
 		elog(ERROR, "Hash type does not exist (name too long)");
 	}
-		
+
 	memcpy(buf, VARDATA(name), len);
 	buf[len] = 0;
-	
+
 	p = pg_find_digest(hbuf, buf);
 
 	if (p == NULL && !silent)
 		elog(ERROR, "Hash type does not exist: '%s'", buf);
 	return p;
 }
-
diff --git a/contrib/pgcrypto/pgcrypto.h b/contrib/pgcrypto/pgcrypto.h
index 039d6cef79..1700b89b15 100644
--- a/contrib/pgcrypto/pgcrypto.h
+++ b/contrib/pgcrypto/pgcrypto.h
@@ -1,7 +1,7 @@
 /*
  * pgcrypto.h
  *		Header file for pgcrypto.
- * 
+ *
  * Copyright (c) 2000 Marko Kreen
  * All rights reserved.
  *
@@ -9,15 +9,15 @@
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
+ *	  notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
+ *	  notice, this list of conditions and the following disclaimer in the
+ *	  documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * ARE DISCLAIMED.	IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
@@ -26,25 +26,27 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- * $Id: pgcrypto.h,v 1.2 2001/01/09 16:07:13 momjian Exp $
+ * $Id: pgcrypto.h,v 1.3 2001/03/22 03:59:10 momjian Exp $
  */
 
 #ifndef _PG_CRYPTO_H
 #define _PG_CRYPTO_H
 
 typedef struct _pg_digest pg_digest;
-struct _pg_digest {
-	char *name;
-	uint (*length)(pg_digest *h);
-	uint8 *(*digest)(pg_digest *h, uint8 *data,
-			uint dlen, uint8 *buf);
+struct _pg_digest
+{
+	char	   *name;
+	uint		(*length) (pg_digest * h);
+	uint8	   *(*digest) (pg_digest * h, uint8 *data,
+									   uint dlen, uint8 *buf);
 	/* private */
-	union {
-		uint code;
+	union
+	{
+		uint		code;
 		const void *ptr;
-	} misc;
+	}			misc;
 };
 
-extern pg_digest *pg_find_digest(pg_digest *hbuf, char *name);
+extern pg_digest *pg_find_digest(pg_digest * hbuf, char *name);
 
 #endif
diff --git a/contrib/pgcrypto/sha1.c b/contrib/pgcrypto/sha1.c
index 63c28dc7e9..db9f1a17c6 100644
--- a/contrib/pgcrypto/sha1.c
+++ b/contrib/pgcrypto/sha1.c
@@ -1,5 +1,5 @@
-/*	$Id: sha1.c,v 1.4 2001/02/10 02:31:26 tgl Exp $	*/
-/*     $KAME: sha1.c,v 1.3 2000/02/22 14:01:18 itojun Exp $    */
+/*	$Id: sha1.c,v 1.5 2001/03/22 03:59:10 momjian Exp $ */
+/*	   $KAME: sha1.c,v 1.3 2000/02/22 14:01:18 itojun Exp $    */
 
 /*
  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
@@ -9,18 +9,18 @@
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
+ *	  notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
+ *	  notice, this list of conditions and the following disclaimer in the
+ *	  documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the project nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
+ *	  may be used to endorse or promote products derived from this software
+ *	  without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
+ * ARE DISCLAIMED.	IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
@@ -41,120 +41,182 @@
 
 /* sanity check */
 #if BYTE_ORDER != BIG_ENDIAN
-# if BYTE_ORDER != LITTLE_ENDIAN
-#  define unsupported 1
-# endif
+#if BYTE_ORDER != LITTLE_ENDIAN
+#define unsupported 1
+#endif
 #endif
 
 #ifndef unsupported
 
 /* constant table */
-static uint32 _K[] = { 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6 };
-#define	K(t)	_K[(t) / 20]
+static uint32 _K[] = {0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6};
+
+#define K(t)	_K[(t) / 20]
 
-#define	F0(b, c, d)	(((b) & (c)) | ((~(b)) & (d)))
-#define	F1(b, c, d)	(((b) ^ (c)) ^ (d))
-#define	F2(b, c, d)	(((b) & (c)) | ((b) & (d)) | ((c) & (d)))
-#define	F3(b, c, d)	(((b) ^ (c)) ^ (d))
+#define F0(b, c, d) (((b) & (c)) | ((~(b)) & (d)))
+#define F1(b, c, d) (((b) ^ (c)) ^ (d))
+#define F2(b, c, d) (((b) & (c)) | ((b) & (d)) | ((c) & (d)))
+#define F3(b, c, d) (((b) ^ (c)) ^ (d))
 
-#define	S(n, x)		(((x) << (n)) | ((x) >> (32 - n)))
+#define S(n, x)		(((x) << (n)) | ((x) >> (32 - n)))
 
-#define	H(n)	(ctxt->h.b32[(n)])
-#define	COUNT	(ctxt->count)
-#define	BCOUNT	(ctxt->c.b64[0] / 8)
-#define	W(n)	(ctxt->m.b32[(n)])
+#define H(n)	(ctxt->h.b32[(n)])
+#define COUNT	(ctxt->count)
+#define BCOUNT	(ctxt->c.b64[0] / 8)
+#define W(n)	(ctxt->m.b32[(n)])
 
-#define	PUTBYTE(x)	{ \
+#define PUTBYTE(x)	{ \
 	ctxt->m.b8[(COUNT % 64)] = (x);		\
 	COUNT++;				\
 	COUNT %= 64;				\
 	ctxt->c.b64[0] += 8;			\
 	if (COUNT % 64 == 0)			\
 		sha1_step(ctxt);		\
-     }
+	 }
 
-#define	PUTPAD(x)	{ \
+#define PUTPAD(x)	{ \
 	ctxt->m.b8[(COUNT % 64)] = (x);		\
 	COUNT++;				\
 	COUNT %= 64;				\
 	if (COUNT % 64 == 0)			\
 		sha1_step(ctxt);		\
-     }
+	 }
 
-static void sha1_step (struct sha1_ctxt *);
+static void sha1_step(struct sha1_ctxt *);
 
 static void
 sha1_step(ctxt)
-	struct sha1_ctxt *ctxt;
+struct sha1_ctxt *ctxt;
 {
-	uint32	a, b, c, d, e;
-	size_t t, s;
-	uint32	tmp;
+	uint32		a,
+				b,
+				c,
+				d,
+				e;
+	size_t		t,
+				s;
+	uint32		tmp;
 
 #if BYTE_ORDER == LITTLE_ENDIAN
 	struct sha1_ctxt tctxt;
+
 	bcopy(&ctxt->m.b8[0], &tctxt.m.b8[0], 64);
-	ctxt->m.b8[0] = tctxt.m.b8[3]; ctxt->m.b8[1] = tctxt.m.b8[2];
-	ctxt->m.b8[2] = tctxt.m.b8[1]; ctxt->m.b8[3] = tctxt.m.b8[0];
-	ctxt->m.b8[4] = tctxt.m.b8[7]; ctxt->m.b8[5] = tctxt.m.b8[6];
-	ctxt->m.b8[6] = tctxt.m.b8[5]; ctxt->m.b8[7] = tctxt.m.b8[4];
-	ctxt->m.b8[8] = tctxt.m.b8[11]; ctxt->m.b8[9] = tctxt.m.b8[10];
-	ctxt->m.b8[10] = tctxt.m.b8[9]; ctxt->m.b8[11] = tctxt.m.b8[8];
-	ctxt->m.b8[12] = tctxt.m.b8[15]; ctxt->m.b8[13] = tctxt.m.b8[14];
-	ctxt->m.b8[14] = tctxt.m.b8[13]; ctxt->m.b8[15] = tctxt.m.b8[12];
-	ctxt->m.b8[16] = tctxt.m.b8[19]; ctxt->m.b8[17] = tctxt.m.b8[18];
-	ctxt->m.b8[18] = tctxt.m.b8[17]; ctxt->m.b8[19] = tctxt.m.b8[16];
-	ctxt->m.b8[20] = tctxt.m.b8[23]; ctxt->m.b8[21] = tctxt.m.b8[22];
-	ctxt->m.b8[22] = tctxt.m.b8[21]; ctxt->m.b8[23] = tctxt.m.b8[20];
-	ctxt->m.b8[24] = tctxt.m.b8[27]; ctxt->m.b8[25] = tctxt.m.b8[26];
-	ctxt->m.b8[26] = tctxt.m.b8[25]; ctxt->m.b8[27] = tctxt.m.b8[24];
-	ctxt->m.b8[28] = tctxt.m.b8[31]; ctxt->m.b8[29] = tctxt.m.b8[30];
-	ctxt->m.b8[30] = tctxt.m.b8[29]; ctxt->m.b8[31] = tctxt.m.b8[28];
-	ctxt->m.b8[32] = tctxt.m.b8[35]; ctxt->m.b8[33] = tctxt.m.b8[34];
-	ctxt->m.b8[34] = tctxt.m.b8[33]; ctxt->m.b8[35] = tctxt.m.b8[32];
-	ctxt->m.b8[36] = tctxt.m.b8[39]; ctxt->m.b8[37] = tctxt.m.b8[38];
-	ctxt->m.b8[38] = tctxt.m.b8[37]; ctxt->m.b8[39] = tctxt.m.b8[36];
-	ctxt->m.b8[40] = tctxt.m.b8[43]; ctxt->m.b8[41] = tctxt.m.b8[42];
-	ctxt->m.b8[42] = tctxt.m.b8[41]; ctxt->m.b8[43] = tctxt.m.b8[40];
-	ctxt->m.b8[44] = tctxt.m.b8[47]; ctxt->m.b8[45] = tctxt.m.b8[46];
-	ctxt->m.b8[46] = tctxt.m.b8[45]; ctxt->m.b8[47] = tctxt.m.b8[44];
-	ctxt->m.b8[48] = tctxt.m.b8[51]; ctxt->m.b8[49] = tctxt.m.b8[50];
-	ctxt->m.b8[50] = tctxt.m.b8[49]; ctxt->m.b8[51] = tctxt.m.b8[48];
-	ctxt->m.b8[52] = tctxt.m.b8[55]; ctxt->m.b8[53] = tctxt.m.b8[54];
-	ctxt->m.b8[54] = tctxt.m.b8[53]; ctxt->m.b8[55] = tctxt.m.b8[52];
-	ctxt->m.b8[56] = tctxt.m.b8[59]; ctxt->m.b8[57] = tctxt.m.b8[58];
-	ctxt->m.b8[58] = tctxt.m.b8[57]; ctxt->m.b8[59] = tctxt.m.b8[56];
-	ctxt->m.b8[60] = tctxt.m.b8[63]; ctxt->m.b8[61] = tctxt.m.b8[62];
-	ctxt->m.b8[62] = tctxt.m.b8[61]; ctxt->m.b8[63] = tctxt.m.b8[60];
+	ctxt->m.b8[0] = tctxt.m.b8[3];
+	ctxt->m.b8[1] = tctxt.m.b8[2];
+	ctxt->m.b8[2] = tctxt.m.b8[1];
+	ctxt->m.b8[3] = tctxt.m.b8[0];
+	ctxt->m.b8[4] = tctxt.m.b8[7];
+	ctxt->m.b8[5] = tctxt.m.b8[6];
+	ctxt->m.b8[6] = tctxt.m.b8[5];
+	ctxt->m.b8[7] = tctxt.m.b8[4];
+	ctxt->m.b8[8] = tctxt.m.b8[11];
+	ctxt->m.b8[9] = tctxt.m.b8[10];
+	ctxt->m.b8[10] = tctxt.m.b8[9];
+	ctxt->m.b8[11] = tctxt.m.b8[8];
+	ctxt->m.b8[12] = tctxt.m.b8[15];
+	ctxt->m.b8[13] = tctxt.m.b8[14];
+	ctxt->m.b8[14] = tctxt.m.b8[13];
+	ctxt->m.b8[15] = tctxt.m.b8[12];
+	ctxt->m.b8[16] = tctxt.m.b8[19];
+	ctxt->m.b8[17] = tctxt.m.b8[18];
+	ctxt->m.b8[18] = tctxt.m.b8[17];
+	ctxt->m.b8[19] = tctxt.m.b8[16];
+	ctxt->m.b8[20] = tctxt.m.b8[23];
+	ctxt->m.b8[21] = tctxt.m.b8[22];
+	ctxt->m.b8[22] = tctxt.m.b8[21];
+	ctxt->m.b8[23] = tctxt.m.b8[20];
+	ctxt->m.b8[24] = tctxt.m.b8[27];
+	ctxt->m.b8[25] = tctxt.m.b8[26];
+	ctxt->m.b8[26] = tctxt.m.b8[25];
+	ctxt->m.b8[27] = tctxt.m.b8[24];
+	ctxt->m.b8[28] = tctxt.m.b8[31];
+	ctxt->m.b8[29] = tctxt.m.b8[30];
+	ctxt->m.b8[30] = tctxt.m.b8[29];
+	ctxt->m.b8[31] = tctxt.m.b8[28];
+	ctxt->m.b8[32] = tctxt.m.b8[35];
+	ctxt->m.b8[33] = tctxt.m.b8[34];
+	ctxt->m.b8[34] = tctxt.m.b8[33];
+	ctxt->m.b8[35] = tctxt.m.b8[32];
+	ctxt->m.b8[36] = tctxt.m.b8[39];
+	ctxt->m.b8[37] = tctxt.m.b8[38];
+	ctxt->m.b8[38] = tctxt.m.b8[37];
+	ctxt->m.b8[39] = tctxt.m.b8[36];
+	ctxt->m.b8[40] = tctxt.m.b8[43];
+	ctxt->m.b8[41] = tctxt.m.b8[42];
+	ctxt->m.b8[42] = tctxt.m.b8[41];
+	ctxt->m.b8[43] = tctxt.m.b8[40];
+	ctxt->m.b8[44] = tctxt.m.b8[47];
+	ctxt->m.b8[45] = tctxt.m.b8[46];
+	ctxt->m.b8[46] = tctxt.m.b8[45];
+	ctxt->m.b8[47] = tctxt.m.b8[44];
+	ctxt->m.b8[48] = tctxt.m.b8[51];
+	ctxt->m.b8[49] = tctxt.m.b8[50];
+	ctxt->m.b8[50] = tctxt.m.b8[49];
+	ctxt->m.b8[51] = tctxt.m.b8[48];
+	ctxt->m.b8[52] = tctxt.m.b8[55];
+	ctxt->m.b8[53] = tctxt.m.b8[54];
+	ctxt->m.b8[54] = tctxt.m.b8[53];
+	ctxt->m.b8[55] = tctxt.m.b8[52];
+	ctxt->m.b8[56] = tctxt.m.b8[59];
+	ctxt->m.b8[57] = tctxt.m.b8[58];
+	ctxt->m.b8[58] = tctxt.m.b8[57];
+	ctxt->m.b8[59] = tctxt.m.b8[56];
+	ctxt->m.b8[60] = tctxt.m.b8[63];
+	ctxt->m.b8[61] = tctxt.m.b8[62];
+	ctxt->m.b8[62] = tctxt.m.b8[61];
+	ctxt->m.b8[63] = tctxt.m.b8[60];
 #endif
 
-	a = H(0); b = H(1); c = H(2); d = H(3); e = H(4);
+	a = H(0);
+	b = H(1);
+	c = H(2);
+	d = H(3);
+	e = H(4);
 
-	for (t = 0; t < 20; t++) {
+	for (t = 0; t < 20; t++)
+	{
 		s = t & 0x0f;
-		if (t >= 16) {
-			W(s) = S(1, W((s+13) & 0x0f) ^ W((s+8) & 0x0f) ^ W((s+2) & 0x0f) ^ W(s));
-		}
+		if (t >= 16)
+			W(s) = S(1, W((s + 13) & 0x0f) ^ W((s + 8) & 0x0f) ^ W((s + 2) & 0x0f) ^ W(s));
 		tmp = S(5, a) + F0(b, c, d) + e + W(s) + K(t);
-		e = d; d = c; c = S(30, b); b = a; a = tmp;
+		e = d;
+		d = c;
+		c = S(30, b);
+		b = a;
+		a = tmp;
 	}
-	for (t = 20; t < 40; t++) {
+	for (t = 20; t < 40; t++)
+	{
 		s = t & 0x0f;
-		W(s) = S(1, W((s+13) & 0x0f) ^ W((s+8) & 0x0f) ^ W((s+2) & 0x0f) ^ W(s));
+		W(s) = S(1, W((s + 13) & 0x0f) ^ W((s + 8) & 0x0f) ^ W((s + 2) & 0x0f) ^ W(s));
 		tmp = S(5, a) + F1(b, c, d) + e + W(s) + K(t);
-		e = d; d = c; c = S(30, b); b = a; a = tmp;
+		e = d;
+		d = c;
+		c = S(30, b);
+		b = a;
+		a = tmp;
 	}
-	for (t = 40; t < 60; t++) {
+	for (t = 40; t < 60; t++)
+	{
 		s = t & 0x0f;
-		W(s) = S(1, W((s+13) & 0x0f) ^ W((s+8) & 0x0f) ^ W((s+2) & 0x0f) ^ W(s));
+		W(s) = S(1, W((s + 13) & 0x0f) ^ W((s + 8) & 0x0f) ^ W((s + 2) & 0x0f) ^ W(s));
 		tmp = S(5, a) + F2(b, c, d) + e + W(s) + K(t);
-		e = d; d = c; c = S(30, b); b = a; a = tmp;
+		e = d;
+		d = c;
+		c = S(30, b);
+		b = a;
+		a = tmp;
 	}
-	for (t = 60; t < 80; t++) {
+	for (t = 60; t < 80; t++)
+	{
 		s = t & 0x0f;
-		W(s) = S(1, W((s+13) & 0x0f) ^ W((s+8) & 0x0f) ^ W((s+2) & 0x0f) ^ W(s));
+		W(s) = S(1, W((s + 13) & 0x0f) ^ W((s + 8) & 0x0f) ^ W((s + 2) & 0x0f) ^ W(s));
 		tmp = S(5, a) + F3(b, c, d) + e + W(s) + K(t);
-		e = d; d = c; c = S(30, b); b = a; a = tmp;
+		e = d;
+		d = c;
+		c = S(30, b);
+		b = a;
+		a = tmp;
 	}
 
 	H(0) = H(0) + a;
@@ -170,7 +232,7 @@ sha1_step(ctxt)
 
 void
 sha1_init(ctxt)
-	struct sha1_ctxt *ctxt;
+struct sha1_ctxt *ctxt;
 {
 	bzero(ctxt, sizeof(struct sha1_ctxt));
 	H(0) = 0x67452301;
@@ -182,55 +244,65 @@ sha1_init(ctxt)
 
 void
 sha1_pad(ctxt)
-	struct sha1_ctxt *ctxt;
+struct sha1_ctxt *ctxt;
 {
-	size_t padlen;		/*pad length in bytes*/
-	size_t padstart;
+	size_t		padlen;			/* pad length in bytes */
+	size_t		padstart;
 
 	PUTPAD(0x80);
 
 	padstart = COUNT % 64;
 	padlen = 64 - padstart;
-	if (padlen < 8) {
+	if (padlen < 8)
+	{
 		bzero(&ctxt->m.b8[padstart], padlen);
 		COUNT += padlen;
 		COUNT %= 64;
 		sha1_step(ctxt);
 		padstart = COUNT % 64;	/* should be 0 */
-		padlen = 64 - padstart;	/* should be 64 */
+		padlen = 64 - padstart; /* should be 64 */
 	}
 	bzero(&ctxt->m.b8[padstart], padlen - 8);
 	COUNT += (padlen - 8);
 	COUNT %= 64;
 #if BYTE_ORDER == BIG_ENDIAN
-	PUTPAD(ctxt->c.b8[0]); PUTPAD(ctxt->c.b8[1]);
-	PUTPAD(ctxt->c.b8[2]); PUTPAD(ctxt->c.b8[3]);
-	PUTPAD(ctxt->c.b8[4]); PUTPAD(ctxt->c.b8[5]);
-	PUTPAD(ctxt->c.b8[6]); PUTPAD(ctxt->c.b8[7]);
+	PUTPAD(ctxt->c.b8[0]);
+	PUTPAD(ctxt->c.b8[1]);
+	PUTPAD(ctxt->c.b8[2]);
+	PUTPAD(ctxt->c.b8[3]);
+	PUTPAD(ctxt->c.b8[4]);
+	PUTPAD(ctxt->c.b8[5]);
+	PUTPAD(ctxt->c.b8[6]);
+	PUTPAD(ctxt->c.b8[7]);
 #else
-	PUTPAD(ctxt->c.b8[7]); PUTPAD(ctxt->c.b8[6]);
-	PUTPAD(ctxt->c.b8[5]); PUTPAD(ctxt->c.b8[4]);
-	PUTPAD(ctxt->c.b8[3]); PUTPAD(ctxt->c.b8[2]);
-	PUTPAD(ctxt->c.b8[1]); PUTPAD(ctxt->c.b8[0]);
+	PUTPAD(ctxt->c.b8[7]);
+	PUTPAD(ctxt->c.b8[6]);
+	PUTPAD(ctxt->c.b8[5]);
+	PUTPAD(ctxt->c.b8[4]);
+	PUTPAD(ctxt->c.b8[3]);
+	PUTPAD(ctxt->c.b8[2]);
+	PUTPAD(ctxt->c.b8[1]);
+	PUTPAD(ctxt->c.b8[0]);
 #endif
 }
 
 void
 sha1_loop(ctxt, input0, len)
-	struct sha1_ctxt *ctxt;
-	const caddr_t input0;
-	size_t len;
+struct sha1_ctxt *ctxt;
+const caddr_t input0;
+size_t		len;
 {
 	const uint8 *input;
-	size_t gaplen;
-	size_t gapstart;
-	size_t off;
-	size_t copysiz;
+	size_t		gaplen;
+	size_t		gapstart;
+	size_t		off;
+	size_t		copysiz;
 
-	input = (const uint8 *)input0;
+	input = (const uint8 *) input0;
 	off = 0;
 
-	while (off < len) {
+	while (off < len)
+	{
 		gapstart = COUNT % 64;
 		gaplen = 64 - gapstart;
 
@@ -247,27 +319,37 @@ sha1_loop(ctxt, input0, len)
 
 void
 sha1_result(ctxt, digest0)
-	struct sha1_ctxt *ctxt;
-	caddr_t digest0;
+struct sha1_ctxt *ctxt;
+caddr_t		digest0;
 {
-	uint8 *digest;
+	uint8	   *digest;
 
-	digest = (uint8 *)digest0;
+	digest = (uint8 *) digest0;
 	sha1_pad(ctxt);
 #if BYTE_ORDER == BIG_ENDIAN
 	bcopy(&ctxt->h.b8[0], digest, 20);
 #else
-	digest[0] = ctxt->h.b8[3]; digest[1] = ctxt->h.b8[2];
-	digest[2] = ctxt->h.b8[1]; digest[3] = ctxt->h.b8[0];
-	digest[4] = ctxt->h.b8[7]; digest[5] = ctxt->h.b8[6];
-	digest[6] = ctxt->h.b8[5]; digest[7] = ctxt->h.b8[4];
-	digest[8] = ctxt->h.b8[11]; digest[9] = ctxt->h.b8[10];
-	digest[10] = ctxt->h.b8[9]; digest[11] = ctxt->h.b8[8];
-	digest[12] = ctxt->h.b8[15]; digest[13] = ctxt->h.b8[14];
-	digest[14] = ctxt->h.b8[13]; digest[15] = ctxt->h.b8[12];
-	digest[16] = ctxt->h.b8[19]; digest[17] = ctxt->h.b8[18];
-	digest[18] = ctxt->h.b8[17]; digest[19] = ctxt->h.b8[16];
+	digest[0] = ctxt->h.b8[3];
+	digest[1] = ctxt->h.b8[2];
+	digest[2] = ctxt->h.b8[1];
+	digest[3] = ctxt->h.b8[0];
+	digest[4] = ctxt->h.b8[7];
+	digest[5] = ctxt->h.b8[6];
+	digest[6] = ctxt->h.b8[5];
+	digest[7] = ctxt->h.b8[4];
+	digest[8] = ctxt->h.b8[11];
+	digest[9] = ctxt->h.b8[10];
+	digest[10] = ctxt->h.b8[9];
+	digest[11] = ctxt->h.b8[8];
+	digest[12] = ctxt->h.b8[15];
+	digest[13] = ctxt->h.b8[14];
+	digest[14] = ctxt->h.b8[13];
+	digest[15] = ctxt->h.b8[12];
+	digest[16] = ctxt->h.b8[19];
+	digest[17] = ctxt->h.b8[18];
+	digest[18] = ctxt->h.b8[17];
+	digest[19] = ctxt->h.b8[16];
 #endif
 }
 
-#endif /*unsupported*/
+#endif	 /* unsupported */
diff --git a/contrib/pgcrypto/sha1.h b/contrib/pgcrypto/sha1.h
index cb08a1af83..cddc8651e4 100644
--- a/contrib/pgcrypto/sha1.h
+++ b/contrib/pgcrypto/sha1.h
@@ -1,5 +1,5 @@
-/*	$Id: sha1.h,v 1.3 2001/01/09 16:07:13 momjian Exp $	*/
-/*     $KAME: sha1.h,v 1.4 2000/02/22 14:01:18 itojun Exp $    */
+/*	$Id: sha1.h,v 1.4 2001/03/22 03:59:10 momjian Exp $ */
+/*	   $KAME: sha1.h,v 1.4 2000/02/22 14:01:18 itojun Exp $    */
 
 /*
  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
@@ -9,18 +9,18 @@
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
+ *	  notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
+ *	  notice, this list of conditions and the following disclaimer in the
+ *	  documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the project nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
+ *	  may be used to endorse or promote products derived from this software
+ *	  without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
+ * ARE DISCLAIMED.	IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
@@ -38,33 +38,38 @@
 #ifndef _NETINET6_SHA1_H_
 #define _NETINET6_SHA1_H_
 
-struct sha1_ctxt {
-	union {
+struct sha1_ctxt
+{
+	union
+	{
 		uint8		b8[20];
 		uint32		b32[5];
-	} h;
-	union {
+	}			h;
+	union
+	{
 		uint8		b8[8];
 		uint64		b64[1];
-	} c;
-	union {
+	}			c;
+	union
+	{
 		uint8		b8[64];
 		uint32		b32[16];
-	} m;
-	uint8			count;
+	}			m;
+	uint8		count;
 };
 
-extern void sha1_init (struct sha1_ctxt *);
-extern void sha1_pad (struct sha1_ctxt *);
-extern void sha1_loop (struct sha1_ctxt *, const caddr_t, size_t);
-extern void sha1_result (struct sha1_ctxt *, caddr_t);
+extern void sha1_init(struct sha1_ctxt *);
+extern void sha1_pad(struct sha1_ctxt *);
+extern void sha1_loop(struct sha1_ctxt *, const caddr_t, size_t);
+extern void sha1_result(struct sha1_ctxt *, caddr_t);
 
 /* compatibilty with other SHA1 source codes */
 typedef struct sha1_ctxt SHA1_CTX;
+
 #define SHA1Init(x)		sha1_init((x))
-#define SHA1Update(x, y, z)	sha1_loop((x), (y), (z))
+#define SHA1Update(x, y, z) sha1_loop((x), (y), (z))
 #define SHA1Final(x, y)		sha1_result((y), (x))
 
-#define	SHA1_RESULTLEN	(160/8)
+#define SHA1_RESULTLEN	(160/8)
 
-#endif /*_NETINET6_SHA1_H_*/
+#endif	 /* _NETINET6_SHA1_H_ */
diff --git a/contrib/rserv/rserv.c b/contrib/rserv/rserv.c
index 518dd68a53..4a7d3aed35 100644
--- a/contrib/rserv/rserv.c
+++ b/contrib/rserv/rserv.c
@@ -16,18 +16,20 @@
 PG_FUNCTION_INFO_V1(_rserv_log_);
 PG_FUNCTION_INFO_V1(_rserv_sync_);
 PG_FUNCTION_INFO_V1(_rserv_debug_);
-Datum _rserv_log_(PG_FUNCTION_ARGS);
-Datum _rserv_sync_(PG_FUNCTION_ARGS);
-Datum _rserv_debug_(PG_FUNCTION_ARGS);
+Datum		_rserv_log_(PG_FUNCTION_ARGS);
+Datum		_rserv_sync_(PG_FUNCTION_ARGS);
+Datum		_rserv_debug_(PG_FUNCTION_ARGS);
+
 #else
 HeapTuple	_rserv_log_(void);
 int32		_rserv_sync_(int32);
 int32		_rserv_debug_(int32);
+
 #endif
 
 static int	debug = 0;
 
-static char* OutputValue(char *key, char *buf, int size);
+static char *OutputValue(char *key, char *buf, int size);
 
 #ifdef PG_FUNCTION_INFO_V1
 Datum
@@ -68,7 +70,7 @@ _rserv_log_()
 	nargs = trigger->tgnargs;
 	args = trigger->tgargs;
 
-	if (nargs != 1)			/* odd number of arguments! */
+	if (nargs != 1)				/* odd number of arguments! */
 		elog(ERROR, "_rserv_log_: need in *one* argument");
 
 	keynum = atoi(args[0]);
@@ -79,7 +81,7 @@ _rserv_log_()
 	rel = CurrentTriggerData->tg_relation;
 	tupdesc = rel->rd_att;
 
-	deleted = (TRIGGER_FIRED_BY_DELETE(CurrentTriggerData->tg_event)) ? 
+	deleted = (TRIGGER_FIRED_BY_DELETE(CurrentTriggerData->tg_event)) ?
 		1 : 0;
 
 	if (TRIGGER_FIRED_BY_UPDATE(CurrentTriggerData->tg_event))
@@ -115,7 +117,7 @@ _rserv_log_()
 		if (strcmp(newkey, key) == 0)
 			newkey = NULL;
 		else
-			deleted = 1;	/* old key was deleted */
+			deleted = 1;		/* old key was deleted */
 	}
 
 	if (strpbrk(key, "\\	\n'"))
@@ -124,7 +126,7 @@ _rserv_log_()
 		okey = key;
 
 	sprintf(sql, "update _RSERV_LOG_ set logid = %d, logtime = now(), "
-			"deleted = %d where reloid = %u and key = '%s'", 
+			"deleted = %d where reloid = %u and key = '%s'",
 			GetCurrentTransactionId(), deleted, rel->rd_id, okey);
 
 	if (debug)
@@ -145,7 +147,7 @@ _rserv_log_()
 		sprintf(sql, "insert into _RSERV_LOG_ "
 				"(reloid, logid, logtime, deleted, key) "
 				"values (%u, %d, now(), %d, '%s')",
-				rel->rd_id, GetCurrentTransactionId(), 
+				rel->rd_id, GetCurrentTransactionId(),
 				deleted, okey);
 
 		if (debug)
@@ -169,7 +171,7 @@ _rserv_log_()
 
 		sprintf(sql, "insert into _RSERV_LOG_ "
 				"(reloid, logid, logtime, deleted, key) "
-				"values (%u, %d, now(), 0, '%s')", 
+				"values (%u, %d, now(), 0, '%s')",
 				rel->rd_id, GetCurrentTransactionId(), okey);
 
 		if (debug)
@@ -202,13 +204,14 @@ _rserv_sync_(int32 server)
 #endif
 {
 #ifdef PG_FUNCTION_INFO_V1
-	int32 server = PG_GETARG_INT32(0);
+	int32		server = PG_GETARG_INT32(0);
+
 #endif
-	char	sql[8192];
-	char	buf[8192];
-	char   *active = buf;
-	uint32	xcnt;
-	int		ret;
+	char		sql[8192];
+	char		buf[8192];
+	char	   *active = buf;
+	uint32		xcnt;
+	int			ret;
 
 	if (SerializableSnapshot == NULL)
 		elog(ERROR, "_rserv_sync_: SerializableSnapshot is NULL");
@@ -217,7 +220,7 @@ _rserv_sync_(int32 server)
 	for (xcnt = 0; xcnt < SerializableSnapshot->xcnt; xcnt++)
 	{
 		sprintf(buf + strlen(buf), "%s%u", (xcnt) ? ", " : "",
-			SerializableSnapshot->xip[xcnt]);
+				SerializableSnapshot->xip[xcnt]);
 	}
 
 	if ((ret = SPI_connect()) < 0)
@@ -225,7 +228,7 @@ _rserv_sync_(int32 server)
 
 	sprintf(sql, "insert into _RSERV_SYNC_ "
 			"(server, syncid, synctime, status, minid, maxid, active) "
-			"values (%u, currval('_rserv_sync_seq_'), now(), 0, %d, %d, '%s')", 
+	  "values (%u, currval('_rserv_sync_seq_'), now(), 0, %d, %d, '%s')",
 			server, SerializableSnapshot->xmin, SerializableSnapshot->xmax, active);
 
 	ret = SPI_exec(sql, 0);
@@ -247,18 +250,19 @@ _rserv_debug_(int32 newval)
 #endif
 {
 #ifdef PG_FUNCTION_INFO_V1
-	int32	newval = PG_GETARG_INT32(0);
+	int32		newval = PG_GETARG_INT32(0);
+
 #endif
-	int32	oldval = debug;
+	int32		oldval = debug;
 
 	debug = newval;
 
 	return (oldval);
 }
 
-#define	ExtendBy	1024
+#define ExtendBy	1024
 
-static char*
+static char *
 OutputValue(char *key, char *buf, int size)
 {
 	int			i = 0;
@@ -267,39 +271,45 @@ OutputValue(char *key, char *buf, int size)
 	int			slen = 0;
 
 	size--;
-	for ( ; ; )
+	for (;;)
 	{
 		switch (*key)
 		{
-			case '\\':	subst ="\\\\";
-						slen = 2;
-						break;
-			case '	':	subst = "\\011";
-						slen = 4;
-						break;
-			case '\n':	subst = "\\012";
-						slen = 4;
-						break;
-			case '\'':	subst = "\\047";
-						slen = 4;
-						break;
-			case '\0':	out[i] = 0;
-						return(out);
-			default:	slen = 1;
-						break;
+			case '\\':
+				subst = "\\\\";
+				slen = 2;
+				break;
+			case '	':
+				subst = "\\011";
+				slen = 4;
+				break;
+			case '\n':
+				subst = "\\012";
+				slen = 4;
+				break;
+			case '\'':
+				subst = "\\047";
+				slen = 4;
+				break;
+			case '\0':
+				out[i] = 0;
+				return (out);
+			default:
+				slen = 1;
+				break;
 		}
 
 		if (i + slen >= size)
 		{
 			if (out == buf)
 			{
-				out = (char*) palloc(size + ExtendBy);
+				out = (char *) palloc(size + ExtendBy);
 				strncpy(out, buf, i);
 				size += ExtendBy;
 			}
 			else
 			{
-				out = (char*) repalloc(out, size + ExtendBy);
+				out = (char *) repalloc(out, size + ExtendBy);
 				size += ExtendBy;
 			}
 		}
@@ -314,6 +324,6 @@ OutputValue(char *key, char *buf, int size)
 		key++;
 	}
 
-	return(out);
+	return (out);
 
 }
diff --git a/contrib/seg/buffer.c b/contrib/seg/buffer.c
index f4dfc1edcd..baeba5e515 100644
--- a/contrib/seg/buffer.c
+++ b/contrib/seg/buffer.c
@@ -4,76 +4,81 @@
 
 #include "utils/elog.h"
 
-static char *       PARSE_BUFFER;
-static char *       PARSE_BUFFER_PTR; 
-static unsigned int PARSE_BUFFER_SIZE; 
+static char *PARSE_BUFFER;
+static char *PARSE_BUFFER_PTR;
+static unsigned int PARSE_BUFFER_SIZE;
 static unsigned int SCANNER_POS;
 
-void         set_parse_buffer( char* s );
-void         reset_parse_buffer( void );
-int          read_parse_buffer( void );
-char *       parse_buffer( void );
-char *       parse_buffer_ptr( void );
-unsigned int parse_buffer_curr_char( void );
-unsigned int parse_buffer_size( void );
-unsigned int parse_buffer_pos( void );
+void		set_parse_buffer(char *s);
+void		reset_parse_buffer(void);
+int			read_parse_buffer(void);
+char	   *parse_buffer(void);
+char	   *parse_buffer_ptr(void);
+unsigned int parse_buffer_curr_char(void);
+unsigned int parse_buffer_size(void);
+unsigned int parse_buffer_pos(void);
 
-extern void seg_flush_scanner_buffer(void); /* defined in segscan.l */
+extern void seg_flush_scanner_buffer(void);		/* defined in segscan.l */
 
-void set_parse_buffer( char* s )
+void
+set_parse_buffer(char *s)
 {
-  PARSE_BUFFER = s;
-  PARSE_BUFFER_SIZE = strlen(s);
-  if ( PARSE_BUFFER_SIZE == 0 ) {
-    elog(ERROR, "seg_in: can't parse an empty string");
-  }
-  PARSE_BUFFER_PTR = PARSE_BUFFER;
-  SCANNER_POS = 0;
+	PARSE_BUFFER = s;
+	PARSE_BUFFER_SIZE = strlen(s);
+	if (PARSE_BUFFER_SIZE == 0)
+		elog(ERROR, "seg_in: can't parse an empty string");
+	PARSE_BUFFER_PTR = PARSE_BUFFER;
+	SCANNER_POS = 0;
 }
 
-void reset_parse_buffer( void )
+void
+reset_parse_buffer(void)
 {
-  PARSE_BUFFER_PTR = PARSE_BUFFER;
-  SCANNER_POS = 0;
-  seg_flush_scanner_buffer();
+	PARSE_BUFFER_PTR = PARSE_BUFFER;
+	SCANNER_POS = 0;
+	seg_flush_scanner_buffer();
 }
 
-int read_parse_buffer( void )
+int
+read_parse_buffer(void)
 {
-  int c;
-  /*
-  c = *PARSE_BUFFER_PTR++;
-  SCANNER_POS++;
-  */
-  c = PARSE_BUFFER[SCANNER_POS];
-  if(SCANNER_POS < PARSE_BUFFER_SIZE)
-    SCANNER_POS++;
-  return c;
+	int			c;
+
+	/*
+	 * c = *PARSE_BUFFER_PTR++; SCANNER_POS++;
+	 */
+	c = PARSE_BUFFER[SCANNER_POS];
+	if (SCANNER_POS < PARSE_BUFFER_SIZE)
+		SCANNER_POS++;
+	return c;
 }
 
-char * parse_buffer( void )
+char *
+parse_buffer(void)
 {
-  return PARSE_BUFFER;
+	return PARSE_BUFFER;
 }
 
-unsigned int parse_buffer_curr_char( void )
+unsigned int
+parse_buffer_curr_char(void)
 {
-  return PARSE_BUFFER[SCANNER_POS];
+	return PARSE_BUFFER[SCANNER_POS];
 }
 
-char * parse_buffer_ptr( void )
+char *
+parse_buffer_ptr(void)
 {
-  return PARSE_BUFFER_PTR;
+	return PARSE_BUFFER_PTR;
 }
 
-unsigned int parse_buffer_pos( void )
+unsigned int
+parse_buffer_pos(void)
 {
-  return SCANNER_POS;
+	return SCANNER_POS;
 }
 
-unsigned int parse_buffer_size( void )
+unsigned int
+parse_buffer_size(void)
 {
-  return PARSE_BUFFER_SIZE;
+	return PARSE_BUFFER_SIZE;
 }
-
-
diff --git a/contrib/seg/buffer.h b/contrib/seg/buffer.h
index fd41a7b69b..eef9124dac 100644
--- a/contrib/seg/buffer.h
+++ b/contrib/seg/buffer.h
@@ -1,8 +1,8 @@
-extern void set_parse_buffer( char* s );
-extern void reset_parse_buffer( void );
-extern int read_parse_buffer( void );
-extern char * parse_buffer( void );
-extern char * parse_buffer_ptr( void );
-extern unsigned int parse_buffer_curr_char( void );
-extern unsigned int parse_buffer_pos( void );
-extern unsigned int parse_buffer_size( void );
+extern void set_parse_buffer(char *s);
+extern void reset_parse_buffer(void);
+extern int	read_parse_buffer(void);
+extern char *parse_buffer(void);
+extern char *parse_buffer_ptr(void);
+extern unsigned int parse_buffer_curr_char(void);
+extern unsigned int parse_buffer_pos(void);
+extern unsigned int parse_buffer_size(void);
diff --git a/contrib/seg/seg.c b/contrib/seg/seg.c
index 1609b42b1e..3ed7926389 100644
--- a/contrib/seg/seg.c
+++ b/contrib/seg/seg.c
@@ -16,79 +16,80 @@
 
 #include "segdata.h"
 
-#define max(a,b)        ((a) >  (b) ? (a) : (b))
-#define min(a,b)        ((a) <= (b) ? (a) : (b))
-#define abs(a)          ((a) <  (0) ? (-a) : (a))
+#define max(a,b)		((a) >	(b) ? (a) : (b))
+#define min(a,b)		((a) <= (b) ? (a) : (b))
+#define abs(a)			((a) <	(0) ? (-a) : (a))
 
-/* 
+/*
 #define GIST_DEBUG
-#define GIST_QUERY_DEBUG 
+#define GIST_QUERY_DEBUG
 */
 
-extern void  set_parse_buffer(char *str);
-extern int   seg_yyparse();
+extern void set_parse_buffer(char *str);
+extern int	seg_yyparse();
+
 /*
-extern int   seg_yydebug;
+extern int	 seg_yydebug;
 */
 
 /*
 ** Input/Output routines
 */
-SEG *        seg_in(char *str);
-char *       seg_out(SEG *seg);
-float32      seg_lower(SEG *seg);
-float32      seg_upper(SEG *seg);
-float32      seg_center(SEG *seg);
+SEG		   *seg_in(char *str);
+char	   *seg_out(SEG * seg);
+float32		seg_lower(SEG * seg);
+float32		seg_upper(SEG * seg);
+float32		seg_center(SEG * seg);
 
-/* 
+/*
 ** GiST support methods
 */
-bool             gseg_consistent(GISTENTRY *entry, SEG *query, StrategyNumber strategy);
-GISTENTRY *      gseg_compress(GISTENTRY *entry);
-GISTENTRY *      gseg_decompress(GISTENTRY *entry);
-float *          gseg_penalty(GISTENTRY *origentry, GISTENTRY *newentry, float *result);
-GIST_SPLITVEC *  gseg_picksplit(bytea *entryvec, GIST_SPLITVEC *v);
-bool             gseg_leaf_consistent(SEG *key, SEG *query, StrategyNumber strategy);
-bool             gseg_internal_consistent(SEG *key, SEG *query, StrategyNumber strategy);
-SEG *            gseg_union(bytea *entryvec, int *sizep);
-SEG *            gseg_binary_union(SEG *r1, SEG *r2, int *sizep);
-bool *           gseg_same(SEG *b1, SEG *b2, bool *result);
+bool		gseg_consistent(GISTENTRY *entry, SEG * query, StrategyNumber strategy);
+GISTENTRY  *gseg_compress(GISTENTRY *entry);
+GISTENTRY  *gseg_decompress(GISTENTRY *entry);
+float	   *gseg_penalty(GISTENTRY *origentry, GISTENTRY *newentry, float *result);
+GIST_SPLITVEC *gseg_picksplit(bytea *entryvec, GIST_SPLITVEC *v);
+bool		gseg_leaf_consistent(SEG * key, SEG * query, StrategyNumber strategy);
+bool		gseg_internal_consistent(SEG * key, SEG * query, StrategyNumber strategy);
+SEG		   *gseg_union(bytea *entryvec, int *sizep);
+SEG		   *gseg_binary_union(SEG * r1, SEG * r2, int *sizep);
+bool	   *gseg_same(SEG * b1, SEG * b2, bool *result);
 
 
 /*
 ** R-tree suport functions
 */
-bool     seg_same(SEG *a, SEG *b);
-bool     seg_contains_int(SEG *a, int *b);
-bool     seg_contains_float4(SEG *a, float4 *b);
-bool     seg_contains_float8(SEG *a, float8 *b);
-bool     seg_contains(SEG *a, SEG *b);
-bool     seg_contained(SEG *a, SEG *b);
-bool     seg_overlap(SEG *a, SEG *b);
-bool     seg_left(SEG *a, SEG *b);
-bool     seg_over_left(SEG *a, SEG *b);
-bool     seg_right(SEG *a, SEG *b);
-bool     seg_over_right(SEG *a, SEG *b);
-SEG *    seg_union(SEG *a, SEG *b);
-SEG *    seg_inter(SEG *a, SEG *b);
-void     rt_seg_size(SEG *a, float* sz);
-float *  seg_size(SEG *a);
+bool		seg_same(SEG * a, SEG * b);
+bool		seg_contains_int(SEG * a, int *b);
+bool		seg_contains_float4(SEG * a, float4 *b);
+bool		seg_contains_float8(SEG * a, float8 *b);
+bool		seg_contains(SEG * a, SEG * b);
+bool		seg_contained(SEG * a, SEG * b);
+bool		seg_overlap(SEG * a, SEG * b);
+bool		seg_left(SEG * a, SEG * b);
+bool		seg_over_left(SEG * a, SEG * b);
+bool		seg_right(SEG * a, SEG * b);
+bool		seg_over_right(SEG * a, SEG * b);
+SEG		   *seg_union(SEG * a, SEG * b);
+SEG		   *seg_inter(SEG * a, SEG * b);
+void		rt_seg_size(SEG * a, float *sz);
+float	   *seg_size(SEG * a);
 
 /*
 ** Various operators
 */
-int32    seg_cmp(SEG *a, SEG *b);
-bool     seg_lt(SEG *a, SEG *b);
-bool     seg_le(SEG *a, SEG *b);
-bool     seg_gt(SEG *a, SEG *b);
-bool     seg_ge(SEG *a, SEG *b);
-bool     seg_different(SEG *a, SEG *b);
-
-/* 
+int32		seg_cmp(SEG * a, SEG * b);
+bool		seg_lt(SEG * a, SEG * b);
+bool		seg_le(SEG * a, SEG * b);
+bool		seg_gt(SEG * a, SEG * b);
+bool		seg_ge(SEG * a, SEG * b);
+bool		seg_different(SEG * a, SEG * b);
+
+/*
 ** Auxiliary funxtions
 */
-static int    restore(char *s, float val, int n);
-int    significant_digits (char* s);
+static int	restore(char *s, float val, int n);
+int			significant_digits(char *s);
 
 
 /*****************************************************************************
@@ -98,104 +99,113 @@ int    significant_digits (char* s);
 SEG *
 seg_in(char *str)
 {
-  SEG * result = palloc(sizeof(SEG));
-  set_parse_buffer( str );
-  
-  /*
-  seg_yydebug = 1;
-  */
-  if ( seg_yyparse(result) != 0 ) {
-    pfree ( result );
-    return NULL;
-  }  
-  return ( result );
+	SEG		   *result = palloc(sizeof(SEG));
+
+	set_parse_buffer(str);
+
+	/*
+	 * seg_yydebug = 1;
+	 */
+	if (seg_yyparse(result) != 0)
+	{
+		pfree(result);
+		return NULL;
+	}
+	return (result);
 }
 
 /*
  * You might have noticed a slight inconsistency between the following
  * declaration and the SQL definition:
- *     CREATE FUNCTION seg_out(opaque) RETURNS opaque ...
+ *	   CREATE FUNCTION seg_out(opaque) RETURNS opaque ...
  * The reason is that the argument passed into seg_out is really just a
  * pointer. POSTGRES thinks all output functions are:
- *     char *out_func(char *);
+ *	   char *out_func(char *);
  */
 char *
-seg_out(SEG *seg)
+seg_out(SEG * seg)
 {
-    char *result;
-    char *p;
-
-    if (seg == NULL) return(NULL);
-
-    p = result = (char *) palloc(40);
-
-    if ( seg->l_ext == '>' || seg->l_ext == '<' || seg->l_ext == '~' ) {
-      p += sprintf(p, "%c", seg->l_ext);
-    }
-      
-    if ( seg->lower == seg->upper && seg->l_ext == seg->u_ext ) {
-      /* indicates that this interval was built by seg_in off a single point */
-      p += restore(p, seg->lower, seg->l_sigd);
-    }
-    else {
-      if ( seg->l_ext != '-' ) {
-	/* print the lower boudary if exists */
-	p += restore(p, seg->lower, seg->l_sigd);
-	p += sprintf(p, " ");
-      }
-      p += sprintf(p, "..");
-      if ( seg->u_ext != '-' ) {
-	/* print the upper boudary if exists */
-	p += sprintf(p, " ");
-	if ( seg->u_ext == '>' || seg->u_ext == '<' || seg->l_ext == '~' ) {
-	  p += sprintf(p, "%c", seg->u_ext);
+	char	   *result;
+	char	   *p;
+
+	if (seg == NULL)
+		return (NULL);
+
+	p = result = (char *) palloc(40);
+
+	if (seg->l_ext == '>' || seg->l_ext == '<' || seg->l_ext == '~')
+		p += sprintf(p, "%c", seg->l_ext);
+
+	if (seg->lower == seg->upper && seg->l_ext == seg->u_ext)
+	{
+
+		/*
+		 * indicates that this interval was built by seg_in off a single
+		 * point
+		 */
+		p += restore(p, seg->lower, seg->l_sigd);
+	}
+	else
+	{
+		if (seg->l_ext != '-')
+		{
+			/* print the lower boudary if exists */
+			p += restore(p, seg->lower, seg->l_sigd);
+			p += sprintf(p, " ");
+		}
+		p += sprintf(p, "..");
+		if (seg->u_ext != '-')
+		{
+			/* print the upper boudary if exists */
+			p += sprintf(p, " ");
+			if (seg->u_ext == '>' || seg->u_ext == '<' || seg->l_ext == '~')
+				p += sprintf(p, "%c", seg->u_ext);
+			p += restore(p, seg->upper, seg->u_sigd);
+		}
 	}
-	p += restore(p, seg->upper, seg->u_sigd);
-      }
-    }
 
-    return(result);
+	return (result);
 }
 
 float32
-seg_center(SEG *seg)
+seg_center(SEG * seg)
 {
-        float32 result = (float32) palloc(sizeof(float32data));
+	float32		result = (float32) palloc(sizeof(float32data));
 
-        if (!seg)
-                return (float32) NULL;
+	if (!seg)
+		return (float32) NULL;
 
-        *result = ((float)seg->lower + (float)seg->upper)/2.0;
-        return (result);
+	*result = ((float) seg->lower + (float) seg->upper) / 2.0;
+	return (result);
 }
 
 float32
-seg_lower(SEG *seg)
+seg_lower(SEG * seg)
 {
-        float32 result = (float32) palloc(sizeof(float32data));
+	float32		result = (float32) palloc(sizeof(float32data));
 
-        if (!seg)
-                return (float32) NULL;
+	if (!seg)
+		return (float32) NULL;
 
-        *result = (float)seg->lower;
-        return (result);
+	*result = (float) seg->lower;
+	return (result);
 }
 
 float32
-seg_upper(SEG *seg)
+seg_upper(SEG * seg)
 {
-        float32 result = (float32) palloc(sizeof(float32data));
+	float32		result = (float32) palloc(sizeof(float32data));
 
-        if (!seg)
-                return (float32) NULL;
+	if (!seg)
+		return (float32) NULL;
 
-        *result = (float)seg->upper;
-        return (result);
+	*result = (float) seg->upper;
+	return (result);
 }
 
 
 /*****************************************************************************
- *                         GiST functions
+ *						   GiST functions
  *****************************************************************************/
 
 /*
@@ -204,19 +214,20 @@ seg_upper(SEG *seg)
 ** the predicate x op query == FALSE, where op is the oper
 ** corresponding to strategy in the pg_amop table.
 */
-bool 
+bool
 gseg_consistent(GISTENTRY *entry,
-	       SEG *query,
-	       StrategyNumber strategy)
+				SEG * query,
+				StrategyNumber strategy)
 {
-    /*
-    ** if entry is not leaf, use gseg_internal_consistent,
-    ** else use gseg_leaf_consistent
-    */
-    if (GIST_LEAF(entry))
-      return(gseg_leaf_consistent((SEG *)(entry->pred), query, strategy));
-    else
-      return(gseg_internal_consistent((SEG *)(entry->pred), query, strategy));
+
+	/*
+	 * * if entry is not leaf, use gseg_internal_consistent, * else use
+	 * gseg_leaf_consistent
+	 */
+	if (GIST_LEAF(entry))
+		return (gseg_leaf_consistent((SEG *) (entry->pred), query, strategy));
+	else
+		return (gseg_internal_consistent((SEG *) (entry->pred), query, strategy));
 }
 
 /*
@@ -226,49 +237,54 @@ gseg_consistent(GISTENTRY *entry,
 SEG *
 gseg_union(bytea *entryvec, int *sizep)
 {
-    int numranges, i;
-    SEG *out = (SEG *)NULL;
-    SEG *tmp;
+	int			numranges,
+				i;
+	SEG		   *out = (SEG *) NULL;
+	SEG		   *tmp;
 
 #ifdef GIST_DEBUG
-    fprintf(stderr, "union\n");
+	fprintf(stderr, "union\n");
 #endif
 
-    numranges = (VARSIZE(entryvec) - VARHDRSZ)/sizeof(GISTENTRY); 
-    tmp = (SEG *)(((GISTENTRY *)(VARDATA(entryvec)))[0]).pred;
-    *sizep = sizeof(SEG);
+	numranges = (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY);
+	tmp = (SEG *) (((GISTENTRY *) (VARDATA(entryvec)))[0]).pred;
+	*sizep = sizeof(SEG);
 
-    for (i = 1; i < numranges; i++) {
-	out = gseg_binary_union(tmp, (SEG *)
-				 (((GISTENTRY *)(VARDATA(entryvec)))[i]).pred,
-				 sizep);
+	for (i = 1; i < numranges; i++)
+	{
+		out = gseg_binary_union(tmp, (SEG *)
+						   (((GISTENTRY *) (VARDATA(entryvec)))[i]).pred,
+								sizep);
 #ifdef GIST_DEBUG
-	/*
-	fprintf(stderr, "\t%s ^ %s -> %s\n", seg_out(tmp), seg_out((SEG *)(((GISTENTRY *)(VARDATA(entryvec)))[i]).pred), seg_out(out));
-	*/
+
+		/*
+		 * fprintf(stderr, "\t%s ^ %s -> %s\n", seg_out(tmp), seg_out((SEG
+		 * *)(((GISTENTRY *)(VARDATA(entryvec)))[i]).pred), seg_out(out));
+		 */
 #endif
 
-	if (i > 1) pfree(tmp);
-	tmp = out;
-    }
+		if (i > 1)
+			pfree(tmp);
+		tmp = out;
+	}
 
-    return(out);
+	return (out);
 }
 
 /*
 ** GiST Compress and Decompress methods for segments
 ** do not do anything.
 */
-GISTENTRY *
+GISTENTRY  *
 gseg_compress(GISTENTRY *entry)
 {
-    return(entry);
+	return (entry);
 }
 
-GISTENTRY *
+GISTENTRY  *
 gseg_decompress(GISTENTRY *entry)
 {
-    return(entry);
+	return (entry);
 }
 
 /*
@@ -278,287 +294,312 @@ gseg_decompress(GISTENTRY *entry)
 float *
 gseg_penalty(GISTENTRY *origentry, GISTENTRY *newentry, float *result)
 {
-    Datum ud;
-    float tmp1, tmp2;
-    
-    ud = (Datum)seg_union((SEG *)(origentry->pred), (SEG *)(newentry->pred));
-    rt_seg_size((SEG *)ud, &tmp1);
-    rt_seg_size((SEG *)(origentry->pred), &tmp2);
-    *result = tmp1 - tmp2;
-    pfree((char *)ud);
+	Datum		ud;
+	float		tmp1,
+				tmp2;
+
+	ud = (Datum) seg_union((SEG *) (origentry->pred), (SEG *) (newentry->pred));
+	rt_seg_size((SEG *) ud, &tmp1);
+	rt_seg_size((SEG *) (origentry->pred), &tmp2);
+	*result = tmp1 - tmp2;
+	pfree((char *) ud);
 
 #ifdef GIST_DEBUG
-    fprintf(stderr, "penalty\n");
-    fprintf(stderr, "\t%g\n", *result);
+	fprintf(stderr, "penalty\n");
+	fprintf(stderr, "\t%g\n", *result);
 #endif
 
-    return(result);
+	return (result);
 }
 
 
 
 /*
 ** The GiST PickSplit method for segments
-** We use Guttman's poly time split algorithm 
+** We use Guttman's poly time split algorithm
 */
 GIST_SPLITVEC *
 gseg_picksplit(bytea *entryvec,
-	      GIST_SPLITVEC *v)
+			   GIST_SPLITVEC *v)
 {
-    OffsetNumber i, j;
-    SEG *datum_alpha, *datum_beta;
-    SEG *datum_l, *datum_r;
-    SEG *union_d, *union_dl, *union_dr;
-    SEG *inter_d;
-    bool firsttime;
-    float size_alpha, size_beta, size_union, size_inter;
-    float size_waste, waste;
-    float size_l, size_r;
-    int nbytes;
-    OffsetNumber seed_1 = 0, seed_2 = 0;
-    OffsetNumber *left, *right;
-    OffsetNumber maxoff;
+	OffsetNumber i,
+				j;
+	SEG		   *datum_alpha,
+			   *datum_beta;
+	SEG		   *datum_l,
+			   *datum_r;
+	SEG		   *union_d,
+			   *union_dl,
+			   *union_dr;
+	SEG		   *inter_d;
+	bool		firsttime;
+	float		size_alpha,
+				size_beta,
+				size_union,
+				size_inter;
+	float		size_waste,
+				waste;
+	float		size_l,
+				size_r;
+	int			nbytes;
+	OffsetNumber seed_1 = 0,
+				seed_2 = 0;
+	OffsetNumber *left,
+			   *right;
+	OffsetNumber maxoff;
 
 #ifdef GIST_DEBUG
-    fprintf(stderr, "picksplit\n");
+	fprintf(stderr, "picksplit\n");
 #endif
 
-    maxoff = ((VARSIZE(entryvec) - VARHDRSZ)/sizeof(GISTENTRY)) - 2;
-    nbytes =  (maxoff + 2) * sizeof(OffsetNumber);
-    v->spl_left = (OffsetNumber *) palloc(nbytes);
-    v->spl_right = (OffsetNumber *) palloc(nbytes);
-    
-    firsttime = true;
-    waste = 0.0;
-    
-    for (i = FirstOffsetNumber; i < maxoff; i = OffsetNumberNext(i)) {
-	datum_alpha = (SEG *)(((GISTENTRY *)(VARDATA(entryvec)))[i].pred);
-	for (j = OffsetNumberNext(i); j <= maxoff; j = OffsetNumberNext(j)) {
-	    datum_beta = (SEG *)(((GISTENTRY *)(VARDATA(entryvec)))[j].pred);
-	    
-	    /* compute the wasted space by unioning these guys */
-	    /* size_waste = size_union - size_inter; */
-	    union_d = (SEG *)seg_union(datum_alpha, datum_beta);
-	    rt_seg_size(union_d, &size_union);
-	    inter_d = (SEG *)seg_inter(datum_alpha, datum_beta);
-	    rt_seg_size(inter_d, &size_inter);
-	    size_waste = size_union - size_inter;
-	    
-	    pfree(union_d);
-	    
-	    if (inter_d != (SEG *) NULL)
-		pfree(inter_d);
-	    
-	    /*
-	     *  are these a more promising split that what we've
-	     *  already seen?
-	     */
-	    
-	    if (size_waste > waste || firsttime) {
-		waste = size_waste;
-		seed_1 = i;
-		seed_2 = j;
-		firsttime = false;
-	    }
+	maxoff = ((VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY)) - 2;
+	nbytes = (maxoff + 2) * sizeof(OffsetNumber);
+	v->spl_left = (OffsetNumber *) palloc(nbytes);
+	v->spl_right = (OffsetNumber *) palloc(nbytes);
+
+	firsttime = true;
+	waste = 0.0;
+
+	for (i = FirstOffsetNumber; i < maxoff; i = OffsetNumberNext(i))
+	{
+		datum_alpha = (SEG *) (((GISTENTRY *) (VARDATA(entryvec)))[i].pred);
+		for (j = OffsetNumberNext(i); j <= maxoff; j = OffsetNumberNext(j))
+		{
+			datum_beta = (SEG *) (((GISTENTRY *) (VARDATA(entryvec)))[j].pred);
+
+			/* compute the wasted space by unioning these guys */
+			/* size_waste = size_union - size_inter; */
+			union_d = (SEG *) seg_union(datum_alpha, datum_beta);
+			rt_seg_size(union_d, &size_union);
+			inter_d = (SEG *) seg_inter(datum_alpha, datum_beta);
+			rt_seg_size(inter_d, &size_inter);
+			size_waste = size_union - size_inter;
+
+			pfree(union_d);
+
+			if (inter_d != (SEG *) NULL)
+				pfree(inter_d);
+
+			/*
+			 * are these a more promising split that what we've already
+			 * seen?
+			 */
+
+			if (size_waste > waste || firsttime)
+			{
+				waste = size_waste;
+				seed_1 = i;
+				seed_2 = j;
+				firsttime = false;
+			}
+		}
 	}
-    }
-    
-    left = v->spl_left;
-    v->spl_nleft = 0;
-    right = v->spl_right;
-    v->spl_nright = 0;
-    
-    datum_alpha = (SEG *)(((GISTENTRY *)(VARDATA(entryvec)))[seed_1].pred);
-    datum_l = (SEG *)seg_union(datum_alpha, datum_alpha);
-    rt_seg_size((SEG *)datum_l, &size_l);
-    datum_beta = (SEG *)(((GISTENTRY *)(VARDATA(entryvec)))[seed_2].pred);;
-    datum_r = (SEG *)seg_union(datum_beta, datum_beta);
-    rt_seg_size((SEG *)datum_r, &size_r);
-    
-    /*
-     *  Now split up the regions between the two seeds.  An important
-     *  property of this split algorithm is that the split vector v
-     *  has the indices of items to be split in order in its left and
-     *  right vectors.  We exploit this property by doing a merge in
-     *  the code that actually splits the page.
-     *
-     *  For efficiency, we also place the new index tuple in this loop.
-     *  This is handled at the very end, when we have placed all the
-     *  existing tuples and i == maxoff + 1.
-     */
-    
-    maxoff = OffsetNumberNext(maxoff);
-    for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) {
-	
+
+	left = v->spl_left;
+	v->spl_nleft = 0;
+	right = v->spl_right;
+	v->spl_nright = 0;
+
+	datum_alpha = (SEG *) (((GISTENTRY *) (VARDATA(entryvec)))[seed_1].pred);
+	datum_l = (SEG *) seg_union(datum_alpha, datum_alpha);
+	rt_seg_size((SEG *) datum_l, &size_l);
+	datum_beta = (SEG *) (((GISTENTRY *) (VARDATA(entryvec)))[seed_2].pred);;
+	datum_r = (SEG *) seg_union(datum_beta, datum_beta);
+	rt_seg_size((SEG *) datum_r, &size_r);
+
 	/*
-	 *  If we've already decided where to place this item, just
-	 *  put it on the right list.  Otherwise, we need to figure
-	 *  out which page needs the least enlargement in order to
-	 *  store the item.
+	 * Now split up the regions between the two seeds.	An important
+	 * property of this split algorithm is that the split vector v has the
+	 * indices of items to be split in order in its left and right
+	 * vectors.  We exploit this property by doing a merge in the code
+	 * that actually splits the page.
+	 *
+	 * For efficiency, we also place the new index tuple in this loop. This
+	 * is handled at the very end, when we have placed all the existing
+	 * tuples and i == maxoff + 1.
 	 */
-	
-	if (i == seed_1) {
-	    *left++ = i;
-	    v->spl_nleft++;
-	    continue;
-	} else if (i == seed_2) {
-	    *right++ = i;
-	    v->spl_nright++;
-	    continue;
-	}
-	
-	/* okay, which page needs least enlargement? */ 
-	datum_alpha = (SEG *)(((GISTENTRY *)(VARDATA(entryvec)))[i].pred);
-	union_dl = (SEG *)seg_union(datum_l, datum_alpha);
-	union_dr = (SEG *)seg_union(datum_r, datum_alpha);
-	rt_seg_size((SEG *)union_dl, &size_alpha);
-	rt_seg_size((SEG *)union_dr, &size_beta);
-	
-	/* pick which page to add it to */
-	if (size_alpha - size_l < size_beta - size_r) {
-	    pfree(datum_l);
-	    pfree(union_dr);
-	    datum_l = union_dl;
-	    size_l = size_alpha;
-	    *left++ = i;
-	    v->spl_nleft++;
-	} else {
-	    pfree(datum_r);
-	    pfree(union_dl);
-	    datum_r = union_dr;
-	    size_r = size_alpha;
-	    *right++ = i;
-	    v->spl_nright++;
+
+	maxoff = OffsetNumberNext(maxoff);
+	for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
+	{
+
+		/*
+		 * If we've already decided where to place this item, just put it
+		 * on the right list.  Otherwise, we need to figure out which page
+		 * needs the least enlargement in order to store the item.
+		 */
+
+		if (i == seed_1)
+		{
+			*left++ = i;
+			v->spl_nleft++;
+			continue;
+		}
+		else if (i == seed_2)
+		{
+			*right++ = i;
+			v->spl_nright++;
+			continue;
+		}
+
+		/* okay, which page needs least enlargement? */
+		datum_alpha = (SEG *) (((GISTENTRY *) (VARDATA(entryvec)))[i].pred);
+		union_dl = (SEG *) seg_union(datum_l, datum_alpha);
+		union_dr = (SEG *) seg_union(datum_r, datum_alpha);
+		rt_seg_size((SEG *) union_dl, &size_alpha);
+		rt_seg_size((SEG *) union_dr, &size_beta);
+
+		/* pick which page to add it to */
+		if (size_alpha - size_l < size_beta - size_r)
+		{
+			pfree(datum_l);
+			pfree(union_dr);
+			datum_l = union_dl;
+			size_l = size_alpha;
+			*left++ = i;
+			v->spl_nleft++;
+		}
+		else
+		{
+			pfree(datum_r);
+			pfree(union_dl);
+			datum_r = union_dr;
+			size_r = size_alpha;
+			*right++ = i;
+			v->spl_nright++;
+		}
 	}
-    }
-    *left = *right = FirstOffsetNumber;	/* sentinel value, see dosplit() */
-    
-    v->spl_ldatum = (char *)datum_l;
-    v->spl_rdatum = (char *)datum_r;
+	*left = *right = FirstOffsetNumber; /* sentinel value, see dosplit() */
+
+	v->spl_ldatum = (char *) datum_l;
+	v->spl_rdatum = (char *) datum_r;
 
-    return v;
+	return v;
 }
 
 /*
 ** Equality methods
 */
 bool *
-gseg_same(SEG *b1, SEG *b2, bool *result)
+gseg_same(SEG * b1, SEG * b2, bool *result)
 {
-  if (seg_same(b1, b2))
-    *result = TRUE;
-  else *result = FALSE;
+	if (seg_same(b1, b2))
+		*result = TRUE;
+	else
+		*result = FALSE;
 
 #ifdef GIST_DEBUG
-  fprintf(stderr, "same: %s\n", (*result ? "TRUE" : "FALSE" ));
+	fprintf(stderr, "same: %s\n", (*result ? "TRUE" : "FALSE"));
 #endif
 
-  return(result);
+	return (result);
 }
 
-/* 
+/*
 ** SUPPORT ROUTINES
 */
-bool 
-gseg_leaf_consistent(SEG *key,
-		     SEG *query,
-		     StrategyNumber strategy)
+bool
+gseg_leaf_consistent(SEG * key,
+					 SEG * query,
+					 StrategyNumber strategy)
 {
-    bool retval;
+	bool		retval;
 
 #ifdef GIST_QUERY_DEBUG
-  fprintf(stderr, "leaf_consistent, %d\n", strategy);
+	fprintf(stderr, "leaf_consistent, %d\n", strategy);
 #endif
 
-    switch(strategy) {
-    case RTLeftStrategyNumber:
-      retval = (bool)seg_left(key, query);
-      break;
-    case RTOverLeftStrategyNumber:
-      retval = (bool)seg_over_left(key,query);
-      break;
-    case RTOverlapStrategyNumber:
-      retval = (bool)seg_overlap(key, query);
-      break;
-    case RTOverRightStrategyNumber:
-      retval = (bool)seg_over_right(key, query);
-      break;
-    case RTRightStrategyNumber:
-      retval = (bool)seg_right(key, query);
-      break;
-    case RTSameStrategyNumber:
-      retval = (bool)seg_same(key, query);
-      break;
-    case RTContainsStrategyNumber:
-      retval = (bool)seg_contains(key, query);
-      break;
-    case RTContainedByStrategyNumber:
-      retval = (bool)seg_contained(key,query);
-      break;
-    default:
-      retval = FALSE;
-    }
-    return(retval);
+	switch (strategy)
+	{
+		case RTLeftStrategyNumber:
+			retval = (bool) seg_left(key, query);
+			break;
+		case RTOverLeftStrategyNumber:
+			retval = (bool) seg_over_left(key, query);
+			break;
+		case RTOverlapStrategyNumber:
+			retval = (bool) seg_overlap(key, query);
+			break;
+		case RTOverRightStrategyNumber:
+			retval = (bool) seg_over_right(key, query);
+			break;
+		case RTRightStrategyNumber:
+			retval = (bool) seg_right(key, query);
+			break;
+		case RTSameStrategyNumber:
+			retval = (bool) seg_same(key, query);
+			break;
+		case RTContainsStrategyNumber:
+			retval = (bool) seg_contains(key, query);
+			break;
+		case RTContainedByStrategyNumber:
+			retval = (bool) seg_contained(key, query);
+			break;
+		default:
+			retval = FALSE;
+	}
+	return (retval);
 }
 
-bool 
-gseg_internal_consistent(SEG *key,
-			SEG *query,
-			StrategyNumber strategy)
+bool
+gseg_internal_consistent(SEG * key,
+						 SEG * query,
+						 StrategyNumber strategy)
 {
-    bool retval;
+	bool		retval;
 
 #ifdef GIST_QUERY_DEBUG
-  fprintf(stderr, "internal_consistent, %d\n", strategy);
+	fprintf(stderr, "internal_consistent, %d\n", strategy);
 #endif
 
-    switch(strategy) {
-    case RTLeftStrategyNumber:
-    case RTOverLeftStrategyNumber:
-      retval = (bool)seg_over_left(key,query);
-      break;
-    case RTOverlapStrategyNumber:
-      retval = (bool)seg_overlap(key, query);
-      break;
-    case RTOverRightStrategyNumber:
-    case RTRightStrategyNumber:
-      retval = (bool)seg_right(key, query);
-      break;
-    case RTSameStrategyNumber:
-    case RTContainsStrategyNumber:
-      retval = (bool)seg_contains(key, query);
-      break;
-    case RTContainedByStrategyNumber:
-      retval = (bool)seg_overlap(key, query);
-      break;
-    default:
-      retval = FALSE;
-    }
-    return(retval);
+	switch (strategy)
+	{
+		case RTLeftStrategyNumber:
+		case RTOverLeftStrategyNumber:
+			retval = (bool) seg_over_left(key, query);
+			break;
+		case RTOverlapStrategyNumber:
+			retval = (bool) seg_overlap(key, query);
+			break;
+		case RTOverRightStrategyNumber:
+		case RTRightStrategyNumber:
+			retval = (bool) seg_right(key, query);
+			break;
+		case RTSameStrategyNumber:
+		case RTContainsStrategyNumber:
+			retval = (bool) seg_contains(key, query);
+			break;
+		case RTContainedByStrategyNumber:
+			retval = (bool) seg_overlap(key, query);
+			break;
+		default:
+			retval = FALSE;
+	}
+	return (retval);
 }
 
 SEG *
-gseg_binary_union(SEG *r1, SEG *r2, int *sizep)
+gseg_binary_union(SEG * r1, SEG * r2, int *sizep)
 {
-    SEG *retval;
+	SEG		   *retval;
 
-    retval = seg_union(r1, r2);
-    *sizep = sizeof(SEG);
+	retval = seg_union(r1, r2);
+	*sizep = sizeof(SEG);
 
-    return (retval);
+	return (retval);
 }
 
 
 bool
-seg_contains(SEG *a, SEG *b)
+seg_contains(SEG * a, SEG * b)
 {
-  return ( (a->lower <= b->lower) && (a->upper >= b->upper) );
+	return ((a->lower <= b->lower) && (a->upper >= b->upper));
 }
 
 bool
-seg_contained(SEG *a, SEG *b)
+seg_contained(SEG * a, SEG * b)
 {
-  return ( seg_contains(b, a) );
+	return (seg_contains(b, a));
 }
 
 /*****************************************************************************
@@ -566,209 +607,214 @@ seg_contained(SEG *a, SEG *b)
  *****************************************************************************/
 
 bool
-seg_same(SEG *a, SEG *b)
+seg_same(SEG * a, SEG * b)
 {
-  return seg_cmp(a, b) == 0;
+	return seg_cmp(a, b) == 0;
 }
 
-/*  seg_overlap -- does a overlap b?
+/*	seg_overlap -- does a overlap b?
  */
 bool
-seg_overlap(SEG *a, SEG *b)
+seg_overlap(SEG * a, SEG * b)
 {
-  return (
-	  ((a->upper >= b->upper) && (a->lower <= b->upper)) 
-	  ||
-	  ((b->upper >= a->upper) && (b->lower <= a->upper))
-	  );
+	return (
+			((a->upper >= b->upper) && (a->lower <= b->upper))
+			||
+			((b->upper >= a->upper) && (b->lower <= a->upper))
+	);
 }
 
-/*  seg_overleft -- is the right edge of (a) located to the left of the right edge of (b)?
+/*	seg_overleft -- is the right edge of (a) located to the left of the right edge of (b)?
  */
 bool
-seg_over_left(SEG *a, SEG *b)
+seg_over_left(SEG * a, SEG * b)
 {
-        return ( a->upper <= b->upper && !seg_left(a, b) && !seg_right(a, b));
+	return (a->upper <= b->upper && !seg_left(a, b) && !seg_right(a, b));
 }
 
-/*  seg_left -- is (a) entirely on the left of (b)?
+/*	seg_left -- is (a) entirely on the left of (b)?
  */
 bool
-seg_left(SEG *a, SEG *b)
+seg_left(SEG * a, SEG * b)
 {
-        return ( a->upper < b->lower );
+	return (a->upper < b->lower);
 }
 
-/*  seg_right -- is (a) entirely on the right of (b)?
+/*	seg_right -- is (a) entirely on the right of (b)?
  */
 bool
-seg_right(SEG *a, SEG *b)
+seg_right(SEG * a, SEG * b)
 {
-        return ( a->lower > b->upper );
+	return (a->lower > b->upper);
 }
 
-/*  seg_overright -- is the left edge of (a) located to the right of the left edge of (b)?
+/*	seg_overright -- is the left edge of (a) located to the right of the left edge of (b)?
  */
 bool
-seg_over_right(SEG *a, SEG *b)
+seg_over_right(SEG * a, SEG * b)
 {
-        return (a->lower >= b->lower && !seg_left(a, b) && !seg_right(a, b));
+	return (a->lower >= b->lower && !seg_left(a, b) && !seg_right(a, b));
 }
 
 
 SEG *
-seg_union(SEG *a, SEG *b)
+seg_union(SEG * a, SEG * b)
 {
-  SEG *n;
-  
-  n = (SEG *) palloc(sizeof(*n));
-
-  /* take max of upper endpoints */
-  if (a->upper > b->upper)
-  {
-	  n->upper = a->upper;
-	  n->u_sigd = a->u_sigd;
-	  n->u_ext = a->u_ext;
-  }
-  else
-  {
-	  n->upper = b->upper;
-	  n->u_sigd = b->u_sigd;
-	  n->u_ext = b->u_ext;
-  }
-
-  /* take min of lower endpoints */
-  if (a->lower < b->lower)
-  {
-	  n->lower = a->lower;
-	  n->l_sigd = a->l_sigd;
-	  n->l_ext = a->l_ext;
-  }
-  else
-  {
-	  n->lower = b->lower;
-	  n->l_sigd = b->l_sigd;
-	  n->l_ext = b->l_ext;
-  }
-
-  return (n);
+	SEG		   *n;
+
+	n = (SEG *) palloc(sizeof(*n));
+
+	/* take max of upper endpoints */
+	if (a->upper > b->upper)
+	{
+		n->upper = a->upper;
+		n->u_sigd = a->u_sigd;
+		n->u_ext = a->u_ext;
+	}
+	else
+	{
+		n->upper = b->upper;
+		n->u_sigd = b->u_sigd;
+		n->u_ext = b->u_ext;
+	}
+
+	/* take min of lower endpoints */
+	if (a->lower < b->lower)
+	{
+		n->lower = a->lower;
+		n->l_sigd = a->l_sigd;
+		n->l_ext = a->l_ext;
+	}
+	else
+	{
+		n->lower = b->lower;
+		n->l_sigd = b->l_sigd;
+		n->l_ext = b->l_ext;
+	}
+
+	return (n);
 }
 
 
 SEG *
-seg_inter(SEG *a, SEG *b)
+seg_inter(SEG * a, SEG * b)
 {
-  SEG *n;
-  
-  n = (SEG *) palloc(sizeof(*n));
-
-  /* take min of upper endpoints */
-  if (a->upper < b->upper)
-  {
-	  n->upper = a->upper;
-	  n->u_sigd = a->u_sigd;
-	  n->u_ext = a->u_ext;
-  }
-  else
-  {
-	  n->upper = b->upper;
-	  n->u_sigd = b->u_sigd;
-	  n->u_ext = b->u_ext;
-  }
-
-  /* take max of lower endpoints */
-  if (a->lower > b->lower)
-  {
-	  n->lower = a->lower;
-	  n->l_sigd = a->l_sigd;
-	  n->l_ext = a->l_ext;
-  }
-  else
-  {
-	  n->lower = b->lower;
-	  n->l_sigd = b->l_sigd;
-	  n->l_ext = b->l_ext;
-  }
-
-  return (n);
+	SEG		   *n;
+
+	n = (SEG *) palloc(sizeof(*n));
+
+	/* take min of upper endpoints */
+	if (a->upper < b->upper)
+	{
+		n->upper = a->upper;
+		n->u_sigd = a->u_sigd;
+		n->u_ext = a->u_ext;
+	}
+	else
+	{
+		n->upper = b->upper;
+		n->u_sigd = b->u_sigd;
+		n->u_ext = b->u_ext;
+	}
+
+	/* take max of lower endpoints */
+	if (a->lower > b->lower)
+	{
+		n->lower = a->lower;
+		n->l_sigd = a->l_sigd;
+		n->l_ext = a->l_ext;
+	}
+	else
+	{
+		n->lower = b->lower;
+		n->l_sigd = b->l_sigd;
+		n->l_ext = b->l_ext;
+	}
+
+	return (n);
 }
 
 void
-rt_seg_size(SEG *a, float *size)
+rt_seg_size(SEG * a, float *size)
 {
-  if (a == (SEG *) NULL || a->upper <= a->lower)
-    *size = 0.0;
-  else
-    *size = (float) abs(a->upper - a->lower);
-  
-  return;
+	if (a == (SEG *) NULL || a->upper <= a->lower)
+		*size = 0.0;
+	else
+		*size = (float) abs(a->upper - a->lower);
+
+	return;
 }
 
 float *
-seg_size(SEG *a)
+seg_size(SEG * a)
 {
-  float *result;
+	float	   *result;
+
+	result = (float *) palloc(sizeof(float));
 
-  result = (float *) palloc(sizeof(float));
-  
-  *result = (float) abs(a->upper - a->lower);
+	*result = (float) abs(a->upper - a->lower);
 
-  return(result);
+	return (result);
 }
 
 
 /*****************************************************************************
- *                 Miscellaneous operators
+ *				   Miscellaneous operators
  *****************************************************************************/
 int32
-seg_cmp(SEG *a, SEG *b)
+seg_cmp(SEG * a, SEG * b)
 {
+
 	/*
 	 * First compare on lower boundary position
 	 */
-	if ( a->lower < b->lower )
+	if (a->lower < b->lower)
 		return -1;
-	if ( a->lower > b->lower )
+	if (a->lower > b->lower)
 		return 1;
+
 	/*
 	 * a->lower == b->lower, so consider type of boundary.
 	 *
-	 * A '-' lower bound is < any other kind (this could only be relevant
-	 * if -HUGE is used as a regular data value).
-	 * A '<' lower bound is < any other kind except '-'.
-	 * A '>' lower bound is > any other kind.
+	 * A '-' lower bound is < any other kind (this could only be relevant if
+	 * -HUGE is used as a regular data value). A '<' lower bound is < any
+	 * other kind except '-'. A '>' lower bound is > any other kind.
 	 */
-	if ( a->l_ext != b->l_ext )
+	if (a->l_ext != b->l_ext)
 	{
-		if ( a->l_ext == '-')
+		if (a->l_ext == '-')
 			return -1;
-		if ( b->l_ext == '-')
+		if (b->l_ext == '-')
 			return 1;
-		if ( a->l_ext == '<')
+		if (a->l_ext == '<')
 			return -1;
-		if ( b->l_ext == '<')
+		if (b->l_ext == '<')
 			return 1;
-		if ( a->l_ext == '>')
+		if (a->l_ext == '>')
 			return 1;
-		if ( b->l_ext == '>')
+		if (b->l_ext == '>')
 			return -1;
 	}
+
 	/*
 	 * For other boundary types, consider # of significant digits first.
 	 */
-	if ( a->l_sigd < b->l_sigd ) /* (a) is blurred and is likely to include (b) */
+	if (a->l_sigd < b->l_sigd)	/* (a) is blurred and is likely to include
+								 * (b) */
 		return -1;
-	if ( a->l_sigd > b->l_sigd ) /* (a) is less blurred and is likely to be included in (b) */
+	if (a->l_sigd > b->l_sigd)	/* (a) is less blurred and is likely to be
+								 * included in (b) */
 		return 1;
+
 	/*
 	 * For same # of digits, an approximate boundary is more blurred than
 	 * exact.
 	 */
-	if ( a->l_ext != b->l_ext )
+	if (a->l_ext != b->l_ext)
 	{
-		if ( a->l_ext == '~' ) /* (a) is approximate, while (b) is exact */
+		if (a->l_ext == '~')	/* (a) is approximate, while (b) is exact */
 			return -1;
-		if ( b->l_ext == '~' )
+		if (b->l_ext == '~')
 			return 1;
 		/* can't get here unless data is corrupt */
 		elog(ERROR, "seg_cmp: bogus lower boundary types %d %d",
@@ -780,50 +826,54 @@ seg_cmp(SEG *a, SEG *b)
 	/*
 	 * First compare on upper boundary position
 	 */
-	if ( a->upper < b->upper )
+	if (a->upper < b->upper)
 		return -1;
-	if ( a->upper > b->upper )
+	if (a->upper > b->upper)
 		return 1;
+
 	/*
 	 * a->upper == b->upper, so consider type of boundary.
 	 *
-	 * A '-' upper bound is > any other kind (this could only be relevant
-	 * if HUGE is used as a regular data value).
-	 * A '<' upper bound is < any other kind.
-	 * A '>' upper bound is > any other kind except '-'.
+	 * A '-' upper bound is > any other kind (this could only be relevant if
+	 * HUGE is used as a regular data value). A '<' upper bound is < any
+	 * other kind. A '>' upper bound is > any other kind except '-'.
 	 */
-	if ( a->u_ext != b->u_ext )
+	if (a->u_ext != b->u_ext)
 	{
-		if ( a->u_ext == '-')
+		if (a->u_ext == '-')
 			return 1;
-		if ( b->u_ext == '-')
+		if (b->u_ext == '-')
 			return -1;
-		if ( a->u_ext == '<')
+		if (a->u_ext == '<')
 			return -1;
-		if ( b->u_ext == '<')
+		if (b->u_ext == '<')
 			return 1;
-		if ( a->u_ext == '>')
+		if (a->u_ext == '>')
 			return 1;
-		if ( b->u_ext == '>')
+		if (b->u_ext == '>')
 			return -1;
 	}
+
 	/*
 	 * For other boundary types, consider # of significant digits first.
 	 * Note result here is converse of the lower-boundary case.
 	 */
-	if ( a->u_sigd < b->u_sigd ) /* (a) is blurred and is likely to include (b) */
+	if (a->u_sigd < b->u_sigd)	/* (a) is blurred and is likely to include
+								 * (b) */
 		return 1;
-	if ( a->u_sigd > b->u_sigd ) /* (a) is less blurred and is likely to be included in (b) */
+	if (a->u_sigd > b->u_sigd)	/* (a) is less blurred and is likely to be
+								 * included in (b) */
 		return -1;
+
 	/*
 	 * For same # of digits, an approximate boundary is more blurred than
 	 * exact.  Again, result is converse of lower-boundary case.
 	 */
-	if ( a->u_ext != b->u_ext )
+	if (a->u_ext != b->u_ext)
 	{
-		if ( a->u_ext == '~' ) /* (a) is approximate, while (b) is exact */
+		if (a->u_ext == '~')	/* (a) is approximate, while (b) is exact */
 			return 1;
-		if ( b->u_ext == '~' )
+		if (b->u_ext == '~')
 			return -1;
 		/* can't get here unless data is corrupt */
 		elog(ERROR, "seg_cmp: bogus upper boundary types %d %d",
@@ -834,40 +884,40 @@ seg_cmp(SEG *a, SEG *b)
 }
 
 bool
-seg_lt(SEG *a, SEG *b)
+seg_lt(SEG * a, SEG * b)
 {
-  return seg_cmp(a, b) < 0;
+	return seg_cmp(a, b) < 0;
 }
 
 bool
-seg_le(SEG *a, SEG *b)
+seg_le(SEG * a, SEG * b)
 {
-  return seg_cmp(a, b) <= 0;
+	return seg_cmp(a, b) <= 0;
 }
 
 bool
-seg_gt(SEG *a, SEG *b)
+seg_gt(SEG * a, SEG * b)
 {
-  return seg_cmp(a, b) > 0;
+	return seg_cmp(a, b) > 0;
 }
 
 
 bool
-seg_ge(SEG *a, SEG *b)
+seg_ge(SEG * a, SEG * b)
 {
-  return seg_cmp(a, b) >= 0;
+	return seg_cmp(a, b) >= 0;
 }
 
 bool
-seg_different(SEG *a, SEG *b)
+seg_different(SEG * a, SEG * b)
 {
-  return seg_cmp(a, b) != 0;
+	return seg_cmp(a, b) != 0;
 }
 
 
 
 /*****************************************************************************
- *                 Auxiliary functions
+ *				   Auxiliary functions
  *****************************************************************************/
 
 /* The purpose of this routine is to print the floating point
@@ -875,126 +925,150 @@ seg_different(SEG *a, SEG *b)
  * is similar to %.ng except it prints 8.00 where %.ng would
  * print 8
  */
-static int restore ( char * result, float val, int n )
+static int
+restore(char *result, float val, int n)
 {
-  static char efmt[8] = {'%', '-', '1', '5', '.', '#', 'e', 0};
-  char buf[25] = {
-    '0', '0', '0', '0', '0',
-    '0', '0', '0', '0', '0',
-    '0', '0', '0', '0', '0',
-    '0', '0', '0', '0', '0',
-    '0', '0', '0', '0', '\0'
-  };
-  char *p;
-  char *mant;
-  int exp;
-  int i, dp, sign;
- 
-  /* put a cap on the number of siugnificant digits to avoid
-     nonsense in the output */
-  n = min(n, FLT_DIG);
-
-  /* remember the sign */
-  sign = ( val < 0 ? 1 : 0 );
-
-  efmt[5] = '0' + (n-1)%10; /* makes %-15.(n-1)e -- this format guarantees that 
-			     the exponent is always present */
-
-  sprintf(result, efmt, val);
-
-  /* trim the spaces left by the %e */
-  for( p = result; *p != ' '; p++ ); *p = '\0';
-
-  /* get the exponent */
-  mant = (char *)strtok( strdup(result), "e" );
-  exp = atoi(strtok( NULL, "e" ));
-
-  if ( exp == 0 ) {
-    /* use the supplied mantyssa with sign */
-    strcpy((char *)index(result, 'e'), "");
-  }
-  else {
-    if ( abs( exp ) <= 4 ) {
-      /* remove the decimal point from the mantyssa and write the digits to the buf array */
-      for( p = result + sign, i = 10, dp = 0; *p != 'e'; p++, i++ ) {
-	buf[i] = *p;
-	if( *p == '.' ) {
-	  dp = i--; /* skip the decimal point */
-	}
-      }
-      if (dp == 0) dp = i--; /* no decimal point was found in the above for() loop */
-  
-      if ( exp > 0 ) {
-	if ( dp - 10 + exp >= n ) { 
-	  /* 
-	     the decimal point is behind the last significant digit;
-	     the digits in between must be converted to the exponent
-	     and the decimal point placed after the first digit
-	   */
-	  exp = dp - 10 + exp - n;
-	  buf[10+n] = '\0'; 
-	  
-	  /* insert the decimal point */
-	  if ( n > 1 ) {
-	    dp = 11;
-	    for ( i = 23; i > dp; i-- ) {
-	      buf[i] = buf[i-1];
-	    }
-	    buf[dp] = '.';
-	  }
-	  
-	  /* adjust the exponent by the number of digits after the decimal point */
-	  if ( n > 1 ) {
-	    sprintf(&buf[11+n], "e%d", exp + n - 1);
-	  }
-	  else {
-	    sprintf(&buf[11], "e%d", exp + n - 1);
-	  }
-	  
-	  if ( sign ) {
-	    buf[9] = '-'; 
-	    strcpy(result, &buf[9]);
-	  }
-	  else {
-	    strcpy(result, &buf[10]);
-	  }
-	}
-	else { /* insert the decimal point */
-	  dp += exp;
-	  for ( i = 23; i > dp; i-- ) {
-	    buf[i] = buf[i-1];
-	  }
-	  buf[11+n] = '\0';
-	  buf[dp] = '.';
-	  if ( sign ) {
-	    buf[9] = '-';
-	    strcpy(result, &buf[9]);
-	  }
-	  else {
-	    strcpy(result, &buf[10]);
-	  }
+	static char efmt[8] = {'%', '-', '1', '5', '.', '#', 'e', 0};
+	char		buf[25] = {
+		'0', '0', '0', '0', '0',
+		'0', '0', '0', '0', '0',
+		'0', '0', '0', '0', '0',
+		'0', '0', '0', '0', '0',
+		'0', '0', '0', '0', '\0'
+	};
+	char	   *p;
+	char	   *mant;
+	int			exp;
+	int			i,
+				dp,
+				sign;
+
+	/*
+	 * put a cap on the number of siugnificant digits to avoid nonsense in
+	 * the output
+	 */
+	n = min(n, FLT_DIG);
+
+	/* remember the sign */
+	sign = (val < 0 ? 1 : 0);
+
+	efmt[5] = '0' + (n - 1) % 10;		/* makes %-15.(n-1)e -- this
+										 * format guarantees that the
+										 * exponent is always present */
+
+	sprintf(result, efmt, val);
+
+	/* trim the spaces left by the %e */
+	for (p = result; *p != ' '; p++);
+	*p = '\0';
+
+	/* get the exponent */
+	mant = (char *) strtok(strdup(result), "e");
+	exp = atoi(strtok(NULL, "e"));
+
+	if (exp == 0)
+	{
+		/* use the supplied mantyssa with sign */
+		strcpy((char *) index(result, 'e'), "");
 	}
-      }
-      else { /* exp <= 0 */
-	dp += exp - 1;
-	buf[10+n] = '\0'; 
-	buf[dp] = '.'; 
-	if ( sign ) {
-	  buf[dp-2] = '-'; 
-	  strcpy(result, &buf[dp-2]);
+	else
+	{
+		if (abs(exp) <= 4)
+		{
+
+			/*
+			 * remove the decimal point from the mantyssa and write the
+			 * digits to the buf array
+			 */
+			for (p = result + sign, i = 10, dp = 0; *p != 'e'; p++, i++)
+			{
+				buf[i] = *p;
+				if (*p == '.')
+				{
+					dp = i--;	/* skip the decimal point */
+				}
+			}
+			if (dp == 0)
+				dp = i--;		/* no decimal point was found in the above
+								 * for() loop */
+
+			if (exp > 0)
+			{
+				if (dp - 10 + exp >= n)
+				{
+
+					/*
+					 * the decimal point is behind the last significant
+					 * digit; the digits in between must be converted to
+					 * the exponent and the decimal point placed after the
+					 * first digit
+					 */
+					exp = dp - 10 + exp - n;
+					buf[10 + n] = '\0';
+
+					/* insert the decimal point */
+					if (n > 1)
+					{
+						dp = 11;
+						for (i = 23; i > dp; i--)
+							buf[i] = buf[i - 1];
+						buf[dp] = '.';
+					}
+
+					/*
+					 * adjust the exponent by the number of digits after
+					 * the decimal point
+					 */
+					if (n > 1)
+						sprintf(&buf[11 + n], "e%d", exp + n - 1);
+					else
+						sprintf(&buf[11], "e%d", exp + n - 1);
+
+					if (sign)
+					{
+						buf[9] = '-';
+						strcpy(result, &buf[9]);
+					}
+					else
+						strcpy(result, &buf[10]);
+				}
+				else
+				{				/* insert the decimal point */
+					dp += exp;
+					for (i = 23; i > dp; i--)
+						buf[i] = buf[i - 1];
+					buf[11 + n] = '\0';
+					buf[dp] = '.';
+					if (sign)
+					{
+						buf[9] = '-';
+						strcpy(result, &buf[9]);
+					}
+					else
+						strcpy(result, &buf[10]);
+				}
+			}
+			else
+			{					/* exp <= 0 */
+				dp += exp - 1;
+				buf[10 + n] = '\0';
+				buf[dp] = '.';
+				if (sign)
+				{
+					buf[dp - 2] = '-';
+					strcpy(result, &buf[dp - 2]);
+				}
+				else
+					strcpy(result, &buf[dp - 1]);
+			}
+		}
+
+		/* do nothing for abs(exp) > 4; %e must be OK */
+		/* just get rid of zeroes after [eE]- and +zeroes after [Ee]. */
+
+		/* ... this is not done yet. */
 	}
-	else {
-	  strcpy(result, &buf[dp-1]);
-	}   
-      }
-    }
-
-    /* do nothing for abs(exp) > 4; %e must be OK */
-    /* just get rid of zeroes after [eE]- and +zeroes after [Ee]. */
-    
-    /* ... this is not done yet. */
-  }
-  return ( strlen ( result ) );
+	return (strlen(result));
 }
 
 
@@ -1003,47 +1077,56 @@ static int restore ( char * result, float val, int n )
 */
 
 bool
-seg_contains_int(SEG *a, int *b)
+seg_contains_int(SEG * a, int *b)
 {
-  return ( (a->lower <= *b) && (a->upper >= *b) );
+	return ((a->lower <= *b) && (a->upper >= *b));
 }
 
 bool
-seg_contains_float4(SEG *a, float4 *b)
+seg_contains_float4(SEG * a, float4 *b)
 {
-  return ( (a->lower <= *b) && (a->upper >= *b) );
+	return ((a->lower <= *b) && (a->upper >= *b));
 }
 
 bool
-seg_contains_float8(SEG *a, float8 *b)
+seg_contains_float8(SEG * a, float8 *b)
 {
-  return ( (a->lower <= *b) && (a->upper >= *b) );
+	return ((a->lower <= *b) && (a->upper >= *b));
 }
 
-/* find out the number of significant digits in a string representing 
+/* find out the number of significant digits in a string representing
  * a floating point number
  */
-int significant_digits ( char* s )
+int
+significant_digits(char *s)
 {
-  char * p = s;
-  int n, c, zeroes;
+	char	   *p = s;
+	int			n,
+				c,
+				zeroes;
 
-  zeroes = 1;
-  /* skip leading zeroes and sign */
-  for ( c = *p; (c == '0' || c == '+' || c == '-') && c != 0; c = *(++p) );
+	zeroes = 1;
+	/* skip leading zeroes and sign */
+	for (c = *p; (c == '0' || c == '+' || c == '-') && c != 0; c = *(++p));
 
-  /* skip decimal point and following zeroes */
-  for ( c = *p; (c == '0' || c == '.' ) && c != 0; c = *(++p) ) {
-    if ( c != '.') zeroes++;
-  }
+	/* skip decimal point and following zeroes */
+	for (c = *p; (c == '0' || c == '.') && c != 0; c = *(++p))
+	{
+		if (c != '.')
+			zeroes++;
+	}
 
-  /* count significant digits (n) */
-  for ( c = *p, n = 0; c != 0; c = *(++p) ) {
-    if ( !( (c >= '0' && c <= '9') || (c == '.') ) ) break;
-    if ( c != '.') n++;
-  }
+	/* count significant digits (n) */
+	for (c = *p, n = 0; c != 0; c = *(++p))
+	{
+		if (!((c >= '0' && c <= '9') || (c == '.')))
+			break;
+		if (c != '.')
+			n++;
+	}
 
-  if (!n) return ( zeroes );
+	if (!n)
+		return (zeroes);
 
-  return( n );
+	return (n);
 }
diff --git a/contrib/seg/segdata.h b/contrib/seg/segdata.h
index 709f576340..773883bbb7 100644
--- a/contrib/seg/segdata.h
+++ b/contrib/seg/segdata.h
@@ -1,8 +1,9 @@
-typedef struct SEG {
-  float lower;
-  float upper;
-  char  l_sigd;
-  char  u_sigd;  
-  char  l_ext;
-  char  u_ext;  
-} SEG;
+typedef struct SEG
+{
+	float		lower;
+	float		upper;
+	char		l_sigd;
+	char		u_sigd;
+	char		l_ext;
+	char		u_ext;
+}			SEG;
diff --git a/contrib/soundex/soundex.c b/contrib/soundex/soundex.c
index 5a7e238e38..ff1b0f7aec 100644
--- a/contrib/soundex/soundex.c
+++ b/contrib/soundex/soundex.c
@@ -1,4 +1,4 @@
-/* $Header: /cvsroot/pgsql/contrib/soundex/Attic/soundex.c,v 1.10 2001/02/10 02:31:26 tgl Exp $ */
+/* $Header: /cvsroot/pgsql/contrib/soundex/Attic/soundex.c,v 1.11 2001/03/22 03:59:10 momjian Exp $ */
 #include "postgres.h"
 
 #include <ctype.h>
@@ -7,7 +7,7 @@
 #include "utils/builtins.h"
 
 
-Datum text_soundex(PG_FUNCTION_ARGS);
+Datum		text_soundex(PG_FUNCTION_ARGS);
 
 static void soundex(const char *instr, char *outstr);
 
@@ -37,11 +37,12 @@ text_soundex(PG_FUNCTION_ARGS)
 	PG_RETURN_TEXT_P(_textin(outstr));
 }
 
-#endif /* not SOUNDEX_TEST */
+#endif	 /* not SOUNDEX_TEST */
 
 
-/*                                  ABCDEFGHIJKLMNOPQRSTUVWXYZ */
+/*									ABCDEFGHIJKLMNOPQRSTUVWXYZ */
 static const char *soundex_table = "01230120022455012623010202";
+
 #define soundex_code(letter) soundex_table[toupper((unsigned char) (letter)) - 'A']
 
 
@@ -98,7 +99,7 @@ soundex(const char *instr, char *outstr)
 
 #ifdef SOUNDEX_TEST
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
 	if (argc < 2)
 	{
@@ -107,11 +108,12 @@ main (int argc, char *argv[])
 	}
 	else
 	{
-		char output[SOUNDEX_LEN + 1];
+		char		output[SOUNDEX_LEN + 1];
 
 		soundex(argv[1], output);
 		printf("soundex(%s) = %s\n", argv[1], output);
 		return 0;
 	}
 }
-#endif /* SOUNDEX_TEST */
+
+#endif	 /* SOUNDEX_TEST */
diff --git a/contrib/spi/insert_username.c b/contrib/spi/insert_username.c
index 3d083bf2f0..0bedaa98ae 100644
--- a/contrib/spi/insert_username.c
+++ b/contrib/spi/insert_username.c
@@ -10,7 +10,7 @@
 #include "commands/trigger.h"	/* -"- and triggers */
 #include "miscadmin.h"			/* for GetUserName() */
 
-extern Datum	insert_username(PG_FUNCTION_ARGS);
+extern Datum insert_username(PG_FUNCTION_ARGS);
 
 PG_FUNCTION_INFO_V1(insert_username);
 
@@ -65,7 +65,7 @@ insert_username(PG_FUNCTION_ARGS)
 
 	/* create fields containing name */
 	newval = DirectFunctionCall1(textin,
-								 CStringGetDatum(GetUserName(GetUserId())));
+							  CStringGetDatum(GetUserName(GetUserId())));
 
 	/* construct new tuple */
 	rettuple = SPI_modifytuple(rel, rettuple, 1, &attnum, &newval, NULL);
diff --git a/contrib/spi/moddatetime.c b/contrib/spi/moddatetime.c
index 73b1518518..bd45dc72b3 100644
--- a/contrib/spi/moddatetime.c
+++ b/contrib/spi/moddatetime.c
@@ -15,7 +15,7 @@ OH, me, I'm Terry Mackintosh <[email protected]>
 #include "executor/spi.h"		/* this is what you need to work with SPI */
 #include "commands/trigger.h"	/* -"- and triggers */
 
-extern Datum	moddatetime(PG_FUNCTION_ARGS);
+extern Datum moddatetime(PG_FUNCTION_ARGS);
 
 PG_FUNCTION_INFO_V1(moddatetime);
 
diff --git a/contrib/spi/timetravel.c b/contrib/spi/timetravel.c
index 90341e208d..bc8a1112f4 100644
--- a/contrib/spi/timetravel.c
+++ b/contrib/spi/timetravel.c
@@ -373,7 +373,7 @@ set_timetravel(PG_FUNCTION_ARGS)
 	else
 		TTOff = realloc(TTOff, (nTTOff + 1) * sizeof(char *));
 	s = rname = DatumGetCString(DirectFunctionCall1(nameout,
-													NameGetDatum(relname)));
+												 NameGetDatum(relname)));
 	d = TTOff[nTTOff] = malloc(strlen(rname) + 1);
 	while (*s)
 		*d++ = tolower((unsigned char) *s++);
diff --git a/contrib/vacuumlo/vacuumlo.c b/contrib/vacuumlo/vacuumlo.c
index 4fdad73e09..002c77fb61 100644
--- a/contrib/vacuumlo/vacuumlo.c
+++ b/contrib/vacuumlo/vacuumlo.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/contrib/vacuumlo/vacuumlo.c,v 1.8 2001/01/24 19:42:45 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/contrib/vacuumlo/vacuumlo.c,v 1.9 2001/03/22 03:59:11 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -76,6 +76,7 @@ vacuumlo(char *database, int verbose)
 		return -1;
 	}
 	PQclear(res);
+
 	/*
 	 * Vacuum the temp table so that planner will generate decent plans
 	 * for the DELETEs below.
@@ -96,13 +97,13 @@ vacuumlo(char *database, int verbose)
 	/*
 	 * Now find any candidate tables who have columns of type oid.
 	 *
-	 * NOTE: the temp table formed above is ignored, because its real
-	 * table name will be pg_something.  Also, pg_largeobject will be
-	 * ignored.  If either of these were scanned, obviously we'd end up
-	 * with nothing to delete...
+	 * NOTE: the temp table formed above is ignored, because its real table
+	 * name will be pg_something.  Also, pg_largeobject will be ignored.
+	 * If either of these were scanned, obviously we'd end up with nothing
+	 * to delete...
 	 *
-	 * NOTE: the system oid column is ignored, as it has attnum < 1.
-	 * This shouldn't matter for correctness, but it saves time.
+	 * NOTE: the system oid column is ignored, as it has attnum < 1. This
+	 * shouldn't matter for correctness, but it saves time.
 	 */
 	buf[0] = '\0';
 	strcat(buf, "SELECT c.relname, a.attname ");
@@ -135,9 +136,9 @@ vacuumlo(char *database, int verbose)
 			fprintf(stdout, "Checking %s in %s\n", field, table);
 
 		/*
-		 * We use a DELETE with implicit join for efficiency.  This
-		 * is a Postgres-ism and not portable to other DBMSs, but
-		 * then this whole program is a Postgres-ism.
+		 * We use a DELETE with implicit join for efficiency.  This is a
+		 * Postgres-ism and not portable to other DBMSs, but then this
+		 * whole program is a Postgres-ism.
 		 */
 		sprintf(buf, "DELETE FROM vacuum_l WHERE lo = \"%s\".\"%s\" ",
 				table, field);
@@ -157,10 +158,10 @@ vacuumlo(char *database, int verbose)
 	PQclear(res);
 
 	/*
-	 * Run the actual deletes in a single transaction.  Note that this
+	 * Run the actual deletes in a single transaction.	Note that this
 	 * would be a bad idea in pre-7.1 Postgres releases (since rolling
-	 * back a table delete used to cause problems), but it should
-	 * be safe now.
+	 * back a table delete used to cause problems), but it should be safe
+	 * now.
 	 */
 	res = PQexec(conn, "begin");
 	PQclear(res);
diff --git a/src/backend/access/common/heaptuple.c b/src/backend/access/common/heaptuple.c
index 03d180e36f..9bb0805494 100644
--- a/src/backend/access/common/heaptuple.c
+++ b/src/backend/access/common/heaptuple.c
@@ -9,7 +9,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/common/heaptuple.c,v 1.69 2001/01/24 19:42:46 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/common/heaptuple.c,v 1.70 2001/03/22 03:59:11 momjian Exp $
  *
  * NOTES
  *	  The old interface functions have been converted to macros
@@ -306,8 +306,8 @@ nocachegetattr(HeapTuple tuple,
 			int			j;
 
 			/*
-			 * In for(), we test <= and not < because we want to see
-			 * if we can go past it in initializing offsets.
+			 * In for(), we test <= and not < because we want to see if we
+			 * can go past it in initializing offsets.
 			 */
 			for (j = 0; j <= attnum; j++)
 			{
@@ -321,9 +321,9 @@ nocachegetattr(HeapTuple tuple,
 	}
 
 	/*
-	 * If slow is false, and we got here, we know that we have a tuple with
-	 * no nulls or varlenas before the target attribute. If possible, we
-	 * also want to initialize the remainder of the attribute cached
+	 * If slow is false, and we got here, we know that we have a tuple
+	 * with no nulls or varlenas before the target attribute. If possible,
+	 * we also want to initialize the remainder of the attribute cached
 	 * offset values.
 	 */
 	if (!slow)
diff --git a/src/backend/access/common/indextuple.c b/src/backend/access/common/indextuple.c
index e503d9b888..da8129f307 100644
--- a/src/backend/access/common/indextuple.c
+++ b/src/backend/access/common/indextuple.c
@@ -9,7 +9,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/common/indextuple.c,v 1.52 2001/02/22 21:48:48 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/common/indextuple.c,v 1.53 2001/03/22 03:59:11 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -45,9 +45,11 @@ index_formtuple(TupleDesc tupleDescriptor,
 	bool		hasnull = false;
 	uint16		tupmask = 0;
 	int			numberOfAttributes = tupleDescriptor->natts;
+
 #ifdef TOAST_INDEX_HACK
 	Datum		untoasted_value[INDEX_MAX_KEYS];
 	bool		untoasted_free[INDEX_MAX_KEYS];
+
 #endif
 
 	if (numberOfAttributes > INDEX_MAX_KEYS)
@@ -57,7 +59,7 @@ index_formtuple(TupleDesc tupleDescriptor,
 #ifdef TOAST_INDEX_HACK
 	for (i = 0; i < numberOfAttributes; i++)
 	{
-		Form_pg_attribute  att = tupleDescriptor->attrs[i];
+		Form_pg_attribute att = tupleDescriptor->attrs[i];
 
 		untoasted_value[i] = value[i];
 		untoasted_free[i] = false;
@@ -73,20 +75,20 @@ index_formtuple(TupleDesc tupleDescriptor,
 		if (VARATT_IS_EXTERNAL(value[i]))
 		{
 			untoasted_value[i] = PointerGetDatum(
-				heap_tuple_fetch_attr(
-					(varattrib *) DatumGetPointer(value[i])));
+												 heap_tuple_fetch_attr(
+							   (varattrib *) DatumGetPointer(value[i])));
 			untoasted_free[i] = true;
 		}
 
 		/*
-		 * If value is above size target, and is of a compressible datatype,
-		 * try to compress it in-line.
+		 * If value is above size target, and is of a compressible
+		 * datatype, try to compress it in-line.
 		 */
 		if (VARATT_SIZE(untoasted_value[i]) > TOAST_INDEX_TARGET &&
 			!VARATT_IS_EXTENDED(untoasted_value[i]) &&
 			(att->attstorage == 'x' || att->attstorage == 'm'))
 		{
-			Datum	cvalue = toast_compress_datum(untoasted_value[i]);
+			Datum		cvalue = toast_compress_datum(untoasted_value[i]);
 
 			if (DatumGetPointer(cvalue) != NULL)
 			{
@@ -146,8 +148,8 @@ index_formtuple(TupleDesc tupleDescriptor,
 	/*
 	 * We do this because DataFill wants to initialize a "tupmask" which
 	 * is used for HeapTuples, but we want an indextuple infomask.	The
-	 * only relevant info is the "has variable attributes" field.
-	 * We have already set the hasnull bit above.
+	 * only relevant info is the "has variable attributes" field. We have
+	 * already set the hasnull bit above.
 	 */
 
 	if (tupmask & HEAP_HASVARLENA)
@@ -315,9 +317,9 @@ nocache_index_getattr(IndexTuple tup,
 	}
 
 	/*
-	 * If slow is false, and we got here, we know that we have a tuple with
-	 * no nulls or varlenas before the target attribute. If possible, we
-	 * also want to initialize the remainder of the attribute cached
+	 * If slow is false, and we got here, we know that we have a tuple
+	 * with no nulls or varlenas before the target attribute. If possible,
+	 * we also want to initialize the remainder of the attribute cached
 	 * offset values.
 	 */
 	if (!slow)
@@ -391,9 +393,7 @@ nocache_index_getattr(IndexTuple tup,
 				usecache = false;
 			}
 			else
-			{
 				off += att[i]->attlen;
-			}
 		}
 
 		off = att_align(off, att[attnum]->attlen, att[attnum]->attalign);
diff --git a/src/backend/access/common/printtup.c b/src/backend/access/common/printtup.c
index 4f47ef0d45..d44bfe973e 100644
--- a/src/backend/access/common/printtup.c
+++ b/src/backend/access/common/printtup.c
@@ -9,7 +9,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/common/printtup.c,v 1.57 2001/01/24 19:42:47 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/common/printtup.c,v 1.58 2001/03/22 03:59:11 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -51,7 +51,7 @@ getTypeOutputInfo(Oid type, Oid *typOutput, Oid *typElem,
 
 	*typOutput = pt->typoutput;
 	*typElem = pt->typelem;
-	*typIsVarlena = (! pt->typbyval) && (pt->typlen == -1);
+	*typIsVarlena = (!pt->typbyval) && (pt->typlen == -1);
 	ReleaseSysCache(typeTuple);
 	return OidIsValid(*typOutput);
 }
@@ -200,9 +200,10 @@ printtup(HeapTuple tuple, TupleDesc typeinfo, DestReceiver *self)
 			continue;
 		if (OidIsValid(thisState->typoutput))
 		{
+
 			/*
-			 * If we have a toasted datum, forcibly detoast it here to avoid
-			 * memory leakage inside the type's output routine.
+			 * If we have a toasted datum, forcibly detoast it here to
+			 * avoid memory leakage inside the type's output routine.
 			 */
 			if (thisState->typisvarlena)
 				attr = PointerGetDatum(PG_DETOAST_DATUM(origattr));
@@ -210,9 +211,9 @@ printtup(HeapTuple tuple, TupleDesc typeinfo, DestReceiver *self)
 				attr = origattr;
 
 			outputstr = DatumGetCString(FunctionCall3(&thisState->finfo,
-										attr,
-										ObjectIdGetDatum(thisState->typelem),
-										Int32GetDatum(typeinfo->attrs[i]->atttypmod)));
+													  attr,
+									ObjectIdGetDatum(thisState->typelem),
+						  Int32GetDatum(typeinfo->attrs[i]->atttypmod)));
 
 			pq_sendcountedtext(&buf, outputstr, strlen(outputstr));
 
@@ -308,9 +309,10 @@ debugtup(HeapTuple tuple, TupleDesc typeinfo, DestReceiver *self)
 		if (getTypeOutputInfo(typeinfo->attrs[i]->atttypid,
 							  &typoutput, &typelem, &typisvarlena))
 		{
+
 			/*
-			 * If we have a toasted datum, forcibly detoast it here to avoid
-			 * memory leakage inside the type's output routine.
+			 * If we have a toasted datum, forcibly detoast it here to
+			 * avoid memory leakage inside the type's output routine.
 			 */
 			if (typisvarlena)
 				attr = PointerGetDatum(PG_DETOAST_DATUM(origattr));
@@ -318,9 +320,9 @@ debugtup(HeapTuple tuple, TupleDesc typeinfo, DestReceiver *self)
 				attr = origattr;
 
 			value = DatumGetCString(OidFunctionCall3(typoutput,
-									attr,
-									ObjectIdGetDatum(typelem),
-									Int32GetDatum(typeinfo->attrs[i]->atttypmod)));
+													 attr,
+											   ObjectIdGetDatum(typelem),
+						  Int32GetDatum(typeinfo->attrs[i]->atttypmod)));
 
 			printatt((unsigned) i + 1, typeinfo->attrs[i], value);
 
@@ -405,6 +407,7 @@ printtup_internal(HeapTuple tuple, TupleDesc typeinfo, DestReceiver *self)
 		/* send # of bytes, and opaque data */
 		if (thisState->typisvarlena)
 		{
+
 			/*
 			 * If we have a toasted datum, must detoast before sending.
 			 */
diff --git a/src/backend/access/common/tupdesc.c b/src/backend/access/common/tupdesc.c
index 86bc1a56f8..e07c6296d1 100644
--- a/src/backend/access/common/tupdesc.c
+++ b/src/backend/access/common/tupdesc.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/common/tupdesc.c,v 1.71 2001/01/24 19:42:47 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/common/tupdesc.c,v 1.72 2001/03/22 03:59:11 momjian Exp $
  *
  * NOTES
  *	  some of the executor utility code such as "ExecTypeFromTL" should be
@@ -242,9 +242,9 @@ equalTupleDescs(TupleDesc tupdesc1, TupleDesc tupdesc2)
 		/*
 		 * We do not need to check every single field here, and in fact
 		 * some fields such as attdispersion probably shouldn't be
-		 * compared.  We can also disregard attnum (it was used to
-		 * place the row in the attrs array) and everything derived
-		 * from the column datatype.
+		 * compared.  We can also disregard attnum (it was used to place
+		 * the row in the attrs array) and everything derived from the
+		 * column datatype.
 		 */
 		if (strcmp(NameStr(attr1->attname), NameStr(attr2->attname)) != 0)
 			return false;
@@ -276,8 +276,8 @@ equalTupleDescs(TupleDesc tupdesc1, TupleDesc tupdesc2)
 
 			/*
 			 * We can't assume that the items are always read from the
-			 * system catalogs in the same order; so use the adnum field to
-			 * identify the matching item to compare.
+			 * system catalogs in the same order; so use the adnum field
+			 * to identify the matching item to compare.
 			 */
 			for (j = 0; j < n; defval2++, j++)
 			{
@@ -298,9 +298,9 @@ equalTupleDescs(TupleDesc tupdesc1, TupleDesc tupdesc2)
 			ConstrCheck *check2 = constr2->check;
 
 			/*
-			 * Similarly, don't assume that the checks are always read
-			 * in the same order; match them up by name and contents.
-			 * (The name *should* be unique, but...)
+			 * Similarly, don't assume that the checks are always read in
+			 * the same order; match them up by name and contents. (The
+			 * name *should* be unique, but...)
 			 */
 			for (j = 0; j < n; check2++, j++)
 			{
diff --git a/src/backend/access/gist/gist.c b/src/backend/access/gist/gist.c
index 9e3f935bd6..1c5577b88a 100644
--- a/src/backend/access/gist/gist.c
+++ b/src/backend/access/gist/gist.c
@@ -6,7 +6,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/gist/gist.c,v 1.71 2001/03/07 21:20:26 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/gist/gist.c,v 1.72 2001/03/22 03:59:12 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -25,61 +25,62 @@
 
 #include "access/xlogutils.h"
 
-/* result's status */ 
+/* result's status */
 #define INSERTED	0x01
 #define SPLITED		0x02
 
 /* non-export function prototypes */
-static void gistdoinsert(Relation r, 
-			IndexTuple itup,
-			InsertIndexResult *res,
-			GISTSTATE *GISTstate);
-static int gistlayerinsert( Relation r, BlockNumber blkno,
-			IndexTuple **itup,
-			int *len,
-			InsertIndexResult *res,
-			GISTSTATE *giststate );
-static OffsetNumber gistwritebuffer( Relation r, 
-			Page page, 
-			IndexTuple *itup, 
-			int len, 
-			OffsetNumber off,
-			GISTSTATE *giststate );
-static int gistnospace( Page page,
-			IndexTuple *itvec, int len );
-static IndexTuple * gistreadbuffer( Relation r, 
-			Buffer buffer, int *len );
-static IndexTuple * gistjoinvector( 
-			IndexTuple *itvec, int *len, 
-			IndexTuple *additvec, int addlen );
-static IndexTuple gistunion( Relation r, IndexTuple *itvec, 
-			int len, GISTSTATE *giststate );
-static IndexTuple gistgetadjusted( Relation r, 
-			IndexTuple oldtup, 
-			IndexTuple addtup, 
-			GISTSTATE *giststate );
-static IndexTuple * gistSplit(Relation r,
-			Buffer buffer,
-			IndexTuple *itup,
-			int *len,
-			GISTSTATE *giststate,
-			InsertIndexResult *res);
-static void gistnewroot(GISTSTATE *giststate, Relation r, 
+static void gistdoinsert(Relation r,
+			 IndexTuple itup,
+			 InsertIndexResult *res,
+			 GISTSTATE *GISTstate);
+static int gistlayerinsert(Relation r, BlockNumber blkno,
+				IndexTuple **itup,
+				int *len,
+				InsertIndexResult *res,
+				GISTSTATE *giststate);
+static OffsetNumber gistwritebuffer(Relation r,
+				Page page,
+				IndexTuple *itup,
+				int len,
+				OffsetNumber off,
+				GISTSTATE *giststate);
+static int gistnospace(Page page,
+			IndexTuple *itvec, int len);
+static IndexTuple *gistreadbuffer(Relation r,
+			   Buffer buffer, int *len);
+static IndexTuple *gistjoinvector(
+			   IndexTuple *itvec, int *len,
+			   IndexTuple *additvec, int addlen);
+static IndexTuple gistunion(Relation r, IndexTuple *itvec,
+		  int len, GISTSTATE *giststate);
+static IndexTuple gistgetadjusted(Relation r,
+				IndexTuple oldtup,
+				IndexTuple addtup,
+				GISTSTATE *giststate);
+static IndexTuple *gistSplit(Relation r,
+		  Buffer buffer,
+		  IndexTuple *itup,
+		  int *len,
+		  GISTSTATE *giststate,
+		  InsertIndexResult *res);
+static void gistnewroot(GISTSTATE *giststate, Relation r,
 			IndexTuple *itup, int len);
 static void GISTInitBuffer(Buffer b, uint32 f);
-static OffsetNumber gistchoose(Relation r, Page p, 
-			IndexTuple it,
-			GISTSTATE *giststate);
-static IndexTuple gist_tuple_replacekey(Relation r, 
-			GISTENTRY entry, IndexTuple t);
-static void gistcentryinit(GISTSTATE *giststate, 
-			GISTENTRY *e, char *pr,
-			Relation r, Page pg, 
-			OffsetNumber o, int b, bool l);
+static OffsetNumber gistchoose(Relation r, Page p,
+		   IndexTuple it,
+		   GISTSTATE *giststate);
+static IndexTuple gist_tuple_replacekey(Relation r,
+					  GISTENTRY entry, IndexTuple t);
+static void gistcentryinit(GISTSTATE *giststate,
+			   GISTENTRY *e, char *pr,
+			   Relation r, Page pg,
+			   OffsetNumber o, int b, bool l);
 
 #undef GISTDEBUG
 #ifdef GISTDEBUG
 static void gist_dumptree(Relation r, int level, BlockNumber blk, OffsetNumber coff);
+
 #endif
 
 /*
@@ -88,12 +89,14 @@ static void gist_dumptree(Relation r, int level, BlockNumber blk, OffsetNumber c
 Datum
 gistbuild(PG_FUNCTION_ARGS)
 {
-	Relation		heap = (Relation) PG_GETARG_POINTER(0);
-	Relation		index = (Relation) PG_GETARG_POINTER(1);
-	IndexInfo	   *indexInfo = (IndexInfo *) PG_GETARG_POINTER(2);
-	Node		   *oldPred = (Node *) PG_GETARG_POINTER(3);
+	Relation	heap = (Relation) PG_GETARG_POINTER(0);
+	Relation	index = (Relation) PG_GETARG_POINTER(1);
+	IndexInfo  *indexInfo = (IndexInfo *) PG_GETARG_POINTER(2);
+	Node	   *oldPred = (Node *) PG_GETARG_POINTER(3);
+
 #ifdef NOT_USED
-	IndexStrategy	istrat = (IndexStrategy) PG_GETARG_POINTER(4);
+	IndexStrategy istrat = (IndexStrategy) PG_GETARG_POINTER(4);
+
 #endif
 	HeapScanDesc hscan;
 	HeapTuple	htup;
@@ -105,9 +108,11 @@ gistbuild(PG_FUNCTION_ARGS)
 	int			nhtups,
 				nitups;
 	Node	   *pred = indexInfo->ii_Predicate;
+
 #ifndef OMIT_PARTIAL_INDEX
 	TupleTable	tupleTable;
 	TupleTableSlot *slot;
+
 #endif
 	ExprContext *econtext;
 	GISTSTATE	giststate;
@@ -181,6 +186,7 @@ gistbuild(PG_FUNCTION_ARGS)
 		nhtups++;
 
 #ifndef OMIT_PARTIAL_INDEX
+
 		/*
 		 * If oldPred != NULL, this is an EXTEND INDEX command, so skip
 		 * this tuple if it was already in the existing partial index
@@ -262,9 +268,7 @@ gistbuild(PG_FUNCTION_ARGS)
 
 #ifndef OMIT_PARTIAL_INDEX
 	if (pred != NULL || oldPred != NULL)
-	{
 		ExecDropTupleTable(tupleTable, true);
-	}
 #endif	 /* OMIT_PARTIAL_INDEX */
 	FreeExprContext(econtext);
 
@@ -297,7 +301,7 @@ gistbuild(PG_FUNCTION_ARGS)
 	}
 
 #ifdef GISTDEBUG
-gist_dumptree(index, 0, GISTP_ROOT, 0);
+	gist_dumptree(index, 0, GISTP_ROOT, 0);
 #endif
 
 	PG_RETURN_VOID();
@@ -312,12 +316,14 @@ gist_dumptree(index, 0, GISTP_ROOT, 0);
 Datum
 gistinsert(PG_FUNCTION_ARGS)
 {
-	Relation		r = (Relation) PG_GETARG_POINTER(0);
-	Datum		   *datum = (Datum *) PG_GETARG_POINTER(1);
-	char		   *nulls = (char *) PG_GETARG_POINTER(2);
-	ItemPointer		ht_ctid = (ItemPointer) PG_GETARG_POINTER(3);
+	Relation	r = (Relation) PG_GETARG_POINTER(0);
+	Datum	   *datum = (Datum *) PG_GETARG_POINTER(1);
+	char	   *nulls = (char *) PG_GETARG_POINTER(2);
+	ItemPointer ht_ctid = (ItemPointer) PG_GETARG_POINTER(3);
+
 #ifdef NOT_USED
-	Relation		heapRel = (Relation) PG_GETARG_POINTER(4);
+	Relation	heapRel = (Relation) PG_GETARG_POINTER(4);
+
 #endif
 	InsertIndexResult res;
 	IndexTuple	itup;
@@ -380,7 +386,7 @@ gistPageAddItem(GISTSTATE *giststate,
 {
 	GISTENTRY	tmpcentry;
 	IndexTuple	itup = (IndexTuple) item;
-	OffsetNumber    retval;
+	OffsetNumber retval;
 
 	/*
 	 * recompress the item given that we now know the exact page and
@@ -394,7 +400,7 @@ gistPageAddItem(GISTSTATE *giststate,
 				   offsetNumber, dentry->bytes, FALSE);
 	*newtup = gist_tuple_replacekey(r, tmpcentry, itup);
 	retval = PageAddItem(page, (Item) *newtup, IndexTupleSize(*newtup),
-						offsetNumber, flags);
+						 offsetNumber, flags);
 	if (retval == InvalidOffsetNumber)
 		elog(ERROR, "gist: failed to add index item to %s",
 			 RelationGetRelationName(r));
@@ -405,189 +411,213 @@ gistPageAddItem(GISTSTATE *giststate,
 	return (retval);
 }
 
-static void 
-gistdoinsert( Relation r, 
-		IndexTuple itup, 
-		InsertIndexResult *res, 
-		GISTSTATE *giststate ) {
+static void
+gistdoinsert(Relation r,
+			 IndexTuple itup,
+			 InsertIndexResult *res,
+			 GISTSTATE *giststate)
+{
 	IndexTuple *instup;
-	int i,ret,len = 1;
+	int			i,
+				ret,
+				len = 1;
+
+	instup = (IndexTuple *) palloc(sizeof(IndexTuple));
+	instup[0] = (IndexTuple) palloc(IndexTupleSize(itup));
+	memcpy(instup[0], itup, IndexTupleSize(itup));
 
-	instup = ( IndexTuple* ) palloc( sizeof(IndexTuple) );
-	instup[0] = ( IndexTuple ) palloc( IndexTupleSize( itup ) );
-	memcpy( instup[0], itup, IndexTupleSize( itup ) );
- 
 	ret = gistlayerinsert(r, GISTP_ROOT, &instup, &len, res, giststate);
-	if ( ret & SPLITED )
-		gistnewroot( giststate, r, instup, len );
+	if (ret & SPLITED)
+		gistnewroot(giststate, r, instup, len);
 
-	for(i=0;i<len;i++)
-		pfree( instup[i] );
-	pfree( instup );
+	for (i = 0; i < len; i++)
+		pfree(instup[i]);
+	pfree(instup);
 }
 
 static int
-gistlayerinsert( Relation r, BlockNumber blkno, 
-			 IndexTuple **itup,       /* in - out, has compressed entry */
-			 int *len    ,           /* in - out */
-			 InsertIndexResult *res, /* out */
-			 GISTSTATE *giststate ) {
-	Buffer	buffer;
-	Page	page;
-	OffsetNumber    child;
-	int ret;
+gistlayerinsert(Relation r, BlockNumber blkno,
+				IndexTuple **itup,		/* in - out, has compressed entry */
+				int *len,		/* in - out */
+				InsertIndexResult *res, /* out */
+				GISTSTATE *giststate)
+{
+	Buffer		buffer;
+	Page		page;
+	OffsetNumber child;
+	int			ret;
 	GISTPageOpaque opaque;
 
 	buffer = ReadBuffer(r, blkno);
 	page = (Page) BufferGetPage(buffer);
 	opaque = (GISTPageOpaque) PageGetSpecialPointer(page);
 
-	if (!(opaque->flags & F_LEAF)) {
+	if (!(opaque->flags & F_LEAF))
+	{
 		/* internal page, so we must walk on tree */
 		/* len IS equial 1 */
-		ItemId iid;
+		ItemId		iid;
 		BlockNumber nblkno;
 		ItemPointerData oldtid;
-		IndexTuple oldtup;
-	
-		child = gistchoose( r, page, *(*itup), giststate );
+		IndexTuple	oldtup;
+
+		child = gistchoose(r, page, *(*itup), giststate);
 		iid = PageGetItemId(page, child);
 		oldtup = (IndexTuple) PageGetItem(page, iid);
 		nblkno = ItemPointerGetBlockNumber(&(oldtup->t_tid));
 
-		/* 
-		 * After this call:
-		 * 1. if child page was splited, then itup contains
-		 * keys for each page
-		 * 2. if  child page wasn't splited, then itup contains
-		 * additional for adjustement of current key 
+		/*
+		 * After this call: 1. if child page was splited, then itup
+		 * contains keys for each page 2. if  child page wasn't splited,
+		 * then itup contains additional for adjustement of current key
 		 */
-		ret = gistlayerinsert( r, nblkno, itup, len, res, giststate );
+		ret = gistlayerinsert(r, nblkno, itup, len, res, giststate);
 
 		/* nothing inserted in child */
-		if ( ! (ret & INSERTED) ) {
+		if (!(ret & INSERTED))
+		{
 			ReleaseBuffer(buffer);
-			return 0x00;	
+			return 0x00;
 		}
 
-		/* child does not splited */ 
-		if ( ! (ret & SPLITED) ) {
-			IndexTuple newtup = gistgetadjusted( r, oldtup, (*itup)[0], giststate ); 
-			if ( ! newtup ) {
+		/* child does not splited */
+		if (!(ret & SPLITED))
+		{
+			IndexTuple	newtup = gistgetadjusted(r, oldtup, (*itup)[0], giststate);
+
+			if (!newtup)
+			{
 				/* not need to update key */
 				ReleaseBuffer(buffer);
 				return 0x00;
 			}
 
-			pfree( (*itup)[0] ); /* !!! */
+			pfree((*itup)[0]);	/* !!! */
 			(*itup)[0] = newtup;
 		}
 
-		/* key is modified, so old version must be deleted */ 
+		/* key is modified, so old version must be deleted */
 		ItemPointerSet(&oldtid, blkno, child);
 		DirectFunctionCall2(gistdelete,
-			PointerGetDatum(r),
-			PointerGetDatum(&oldtid));
+							PointerGetDatum(r),
+							PointerGetDatum(&oldtid));
 	}
 
-	ret = INSERTED; 
+	ret = INSERTED;
 
-	if (  gistnospace(page, (*itup), *len) ) {
+	if (gistnospace(page, (*itup), *len))
+	{
 		/* no space for insertion */
 		IndexTuple *itvec;
-		int tlen;
+		int			tlen;
 
 		ret |= SPLITED;
-		itvec = gistreadbuffer( r, buffer, &tlen );
-		itvec = gistjoinvector( itvec, &tlen, (*itup), *len ); 
-		pfree( (*itup) );
-		(*itup) = gistSplit( r, buffer, itvec, &tlen, giststate, 
-			(opaque->flags & F_LEAF) ? res : NULL ); /*res only for inserting in leaf*/
-		ReleaseBuffer( buffer );
-		pfree( itvec );
-		*len = tlen;   /* now tlen >= 2 */
-	} else {
+		itvec = gistreadbuffer(r, buffer, &tlen);
+		itvec = gistjoinvector(itvec, &tlen, (*itup), *len);
+		pfree((*itup));
+		(*itup) = gistSplit(r, buffer, itvec, &tlen, giststate,
+							(opaque->flags & F_LEAF) ? res : NULL);		/* res only for
+																		 * inserting in leaf */
+		ReleaseBuffer(buffer);
+		pfree(itvec);
+		*len = tlen;			/* now tlen >= 2 */
+	}
+	else
+	{
 		/* enogth space */
-		OffsetNumber off, l;
+		OffsetNumber off,
+					l;
 
-		off = ( PageIsEmpty(page) ) ? 
-				FirstOffsetNumber
+		off = (PageIsEmpty(page)) ?
+			FirstOffsetNumber
 			:
-				OffsetNumberNext(PageGetMaxOffsetNumber(page));
-		l = gistwritebuffer( r, page, (*itup), *len, off, giststate );
+			OffsetNumberNext(PageGetMaxOffsetNumber(page));
+		l = gistwritebuffer(r, page, (*itup), *len, off, giststate);
 		WriteBuffer(buffer);
 
-		/* set res if insert into leaf page, in
-                this case, len = 1 always */
-		if ( res && (opaque->flags & F_LEAF) )
+		/*
+		 * set res if insert into leaf page, in this case, len = 1 always
+		 */
+		if (res && (opaque->flags & F_LEAF))
 			ItemPointerSet(&((*res)->pointerData), blkno, l);
 
-		if ( *len > 1 ) { /* previos insert ret & SPLITED != 0 */ 
-			int i;
-			/* child was splited, so we must form union
-			 * for insertion in parent */
-			IndexTuple newtup = gistunion(r, (*itup), *len, giststate);
-			for(i=0; i<*len; i++)
-				pfree( (*itup)[i] );
+		if (*len > 1)
+		{						/* previos insert ret & SPLITED != 0 */
+			int			i;
+
+			/*
+			 * child was splited, so we must form union for insertion in
+			 * parent
+			 */
+			IndexTuple	newtup = gistunion(r, (*itup), *len, giststate);
+
+			for (i = 0; i < *len; i++)
+				pfree((*itup)[i]);
 			(*itup)[0] = newtup;
 			*len = 1;
 		}
 	}
-	
-	return ret; 
-}    
 
-/* 
+	return ret;
+}
+
+/*
  * Write itup vector to page, has no control of free space
  */
 static OffsetNumber
-gistwritebuffer( Relation r, Page page, IndexTuple *itup, 
-		int len, OffsetNumber off, GISTSTATE *giststate) {
+gistwritebuffer(Relation r, Page page, IndexTuple *itup,
+				int len, OffsetNumber off, GISTSTATE *giststate)
+{
 	OffsetNumber l = InvalidOffsetNumber;
-	int i;
-	GISTENTRY       tmpdentry;
-	IndexTuple newtup;
-		
-	for(i=0; i<len; i++) { 
-		l = gistPageAddItem(giststate, r, page, 
-			(Item) itup[i], IndexTupleSize(itup[i]),   
-			off, LP_USED, &tmpdentry, &newtup);
-		off = OffsetNumberNext( off );
+	int			i;
+	GISTENTRY	tmpdentry;
+	IndexTuple	newtup;
+
+	for (i = 0; i < len; i++)
+	{
+		l = gistPageAddItem(giststate, r, page,
+							(Item) itup[i], IndexTupleSize(itup[i]),
+							off, LP_USED, &tmpdentry, &newtup);
+		off = OffsetNumberNext(off);
 		if (tmpdentry.pred != (((char *) itup[i]) + sizeof(IndexTupleData)) && tmpdentry.pred)
 			pfree(tmpdentry.pred);
 		if (itup[i] != newtup)
 			pfree(newtup);
 	}
-	return l; 
+	return l;
 }
 
 /*
  * Check space for itup vector on page
  */
-static int 
-gistnospace( Page page, IndexTuple *itvec, int len ) {
-	int size = 0;
-	int i;
-	for(i=0; i<len; i++) 
-		size += IndexTupleSize( itvec[i] )+4; /* ??? */
+static int
+gistnospace(Page page, IndexTuple *itvec, int len)
+{
+	int			size = 0;
+	int			i;
 
-	return  (PageGetFreeSpace(page) < size);
-} 
+	for (i = 0; i < len; i++)
+		size += IndexTupleSize(itvec[i]) + 4;	/* ??? */
+
+	return (PageGetFreeSpace(page) < size);
+}
 
 /*
  * Read buffer into itup vector
  */
 static IndexTuple *
-gistreadbuffer( Relation r, Buffer buffer, int *len /*out*/) {
-	OffsetNumber i, maxoff;
-	IndexTuple   *itvec;
-	Page p = (Page) BufferGetPage(buffer);
+gistreadbuffer(Relation r, Buffer buffer, int *len /* out */ )
+{
+	OffsetNumber i,
+				maxoff;
+	IndexTuple *itvec;
+	Page		p = (Page) BufferGetPage(buffer);
 
-	*len=0;
+	*len = 0;
 	maxoff = PageGetMaxOffsetNumber(p);
-	itvec = palloc( sizeof(IndexTuple) * maxoff );
-	for(i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
-		itvec[ (*len)++ ] = (IndexTuple) PageGetItem(p, PageGetItemId(p, i));
+	itvec = palloc(sizeof(IndexTuple) * maxoff);
+	for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
+		itvec[(*len)++] = (IndexTuple) PageGetItem(p, PageGetItemId(p, i));
 
 	return itvec;
 }
@@ -596,9 +626,10 @@ gistreadbuffer( Relation r, Buffer buffer, int *len /*out*/) {
  * join two vectors into one
  */
 static IndexTuple *
-gistjoinvector( IndexTuple *itvec, int *len, IndexTuple *additvec, int addlen ) {
-	itvec = (IndexTuple*) repalloc( (void*)itvec, sizeof(IndexTuple) * ( (*len) + addlen ) );
-	memmove( &itvec[*len], additvec, sizeof(IndexTuple) * addlen );
+gistjoinvector(IndexTuple *itvec, int *len, IndexTuple *additvec, int addlen)
+{
+	itvec = (IndexTuple *) repalloc((void *) itvec, sizeof(IndexTuple) * ((*len) + addlen));
+	memmove(&itvec[*len], additvec, sizeof(IndexTuple) * addlen);
 	*len += addlen;
 	return itvec;
 }
@@ -607,115 +638,124 @@ gistjoinvector( IndexTuple *itvec, int *len, IndexTuple *additvec, int addlen )
  * return union of itup vector
  */
 static IndexTuple
-gistunion( Relation r, IndexTuple *itvec, int len, GISTSTATE *giststate ) {
-	bytea   *evec;
-	char 	*datum;
-	int 	datumsize, i;
-	GISTENTRY centry;
-	char isnull;
-	IndexTuple newtup;
+gistunion(Relation r, IndexTuple *itvec, int len, GISTSTATE *giststate)
+{
+	bytea	   *evec;
+	char	   *datum;
+	int			datumsize,
+				i;
+	GISTENTRY	centry;
+	char		isnull;
+	IndexTuple	newtup;
 
 	evec = (bytea *) palloc(len * sizeof(GISTENTRY) + VARHDRSZ);
 	VARATT_SIZEP(evec) = len * sizeof(GISTENTRY) + VARHDRSZ;
 
-	for ( i = 0 ; i< len ; i++ ) 
+	for (i = 0; i < len; i++)
 		gistdentryinit(giststate, &((GISTENTRY *) VARDATA(evec))[i],
-			(char*) itvec[i] + sizeof(IndexTupleData), 
-			(Relation)NULL, (Page)NULL, (OffsetNumber)NULL,
-			IndexTupleSize((IndexTuple)itvec[i]) - sizeof(IndexTupleData), FALSE);
+					   (char *) itvec[i] + sizeof(IndexTupleData),
+					   (Relation) NULL, (Page) NULL, (OffsetNumber) NULL,
+					   IndexTupleSize((IndexTuple) itvec[i]) - sizeof(IndexTupleData), FALSE);
 
 	datum = (char *)
 		DatumGetPointer(FunctionCall2(&giststate->unionFn,
-			PointerGetDatum(evec),
-			PointerGetDatum(&datumsize)));
+									  PointerGetDatum(evec),
+									  PointerGetDatum(&datumsize)));
+
+	for (i = 0; i < len; i++)
+		if (((GISTENTRY *) VARDATA(evec))[i].pred &&
+			((GISTENTRY *) VARDATA(evec))[i].pred !=
+			((char *) (itvec[i]) + sizeof(IndexTupleData)))
+			pfree(((GISTENTRY *) VARDATA(evec))[i].pred);
 
-	for ( i = 0 ; i< len ; i++ )
-		if ( ((GISTENTRY *) VARDATA(evec))[i].pred &&
-		   ((GISTENTRY *) VARDATA(evec))[i].pred != 
-		   ((char*)( itvec[i] )+ sizeof(IndexTupleData)) )
-			pfree( ((GISTENTRY *) VARDATA(evec))[i].pred ); 
-	     
-	pfree( evec );
+	pfree(evec);
 
-	gistcentryinit(giststate, &centry, datum, 
-		(Relation)NULL, (Page)NULL, (OffsetNumber)NULL,
-		datumsize, FALSE);
+	gistcentryinit(giststate, &centry, datum,
+				   (Relation) NULL, (Page) NULL, (OffsetNumber) NULL,
+				   datumsize, FALSE);
 
 	isnull = (centry.pred) ? ' ' : 'n';
-	newtup = (IndexTuple) index_formtuple( r->rd_att, (Datum *) &centry.pred, &isnull );
+	newtup = (IndexTuple) index_formtuple(r->rd_att, (Datum *) &centry.pred, &isnull);
 	if (centry.pred != datum)
-		pfree( datum );
+		pfree(datum);
 
 	return newtup;
-} 
+}
 
 /*
  * Forms union of oldtup and addtup, if union == oldtup then return NULL
  */
 static IndexTuple
-gistgetadjusted( Relation r, IndexTuple oldtup, IndexTuple addtup, GISTSTATE *giststate ) {
-	bytea   *evec;
-	char 	*datum;
-	int 	datumsize;
-	bool    result;
-	char 	isnull;
-	GISTENTRY centry, *ev0p, *ev1p;
-	IndexTuple newtup = NULL;
-	
+gistgetadjusted(Relation r, IndexTuple oldtup, IndexTuple addtup, GISTSTATE *giststate)
+{
+	bytea	   *evec;
+	char	   *datum;
+	int			datumsize;
+	bool		result;
+	char		isnull;
+	GISTENTRY	centry,
+			   *ev0p,
+			   *ev1p;
+	IndexTuple	newtup = NULL;
+
 	evec = (bytea *) palloc(2 * sizeof(GISTENTRY) + VARHDRSZ);
 	VARATT_SIZEP(evec) = 2 * sizeof(GISTENTRY) + VARHDRSZ;
 
 	gistdentryinit(giststate, &((GISTENTRY *) VARDATA(evec))[0],
-		(char*) oldtup + sizeof(IndexTupleData), (Relation) NULL, 
-		(Page) NULL, (OffsetNumber) 0,
-		IndexTupleSize((IndexTuple)oldtup) - sizeof(IndexTupleData), FALSE);
+			   (char *) oldtup + sizeof(IndexTupleData), (Relation) NULL,
+				   (Page) NULL, (OffsetNumber) 0,
+	IndexTupleSize((IndexTuple) oldtup) - sizeof(IndexTupleData), FALSE);
 	ev0p = &((GISTENTRY *) VARDATA(evec))[0];
 
 	gistdentryinit(giststate, &((GISTENTRY *) VARDATA(evec))[1],
-		(char*) addtup + sizeof(IndexTupleData), (Relation) NULL,
-		(Page) NULL, (OffsetNumber) 0,
-		IndexTupleSize((IndexTuple)addtup) - sizeof(IndexTupleData), FALSE);
+			   (char *) addtup + sizeof(IndexTupleData), (Relation) NULL,
+				   (Page) NULL, (OffsetNumber) 0,
+	IndexTupleSize((IndexTuple) addtup) - sizeof(IndexTupleData), FALSE);
 	ev1p = &((GISTENTRY *) VARDATA(evec))[1];
 
 	datum = (char *)
 		DatumGetPointer(FunctionCall2(&giststate->unionFn,
-			PointerGetDatum(evec),
-			PointerGetDatum(&datumsize)));
+									  PointerGetDatum(evec),
+									  PointerGetDatum(&datumsize)));
 
-	if ( ! ( ev0p->pred && ev1p->pred ) ) {
-		result = ( ev0p->pred == NULL && ev1p->pred == NULL );
-	} else {
+	if (!(ev0p->pred && ev1p->pred))
+		result = (ev0p->pred == NULL && ev1p->pred == NULL);
+	else
+	{
 		FunctionCall3(&giststate->equalFn,
-			PointerGetDatum(ev0p->pred),
-			PointerGetDatum(datum),
-			PointerGetDatum(&result));
+					  PointerGetDatum(ev0p->pred),
+					  PointerGetDatum(datum),
+					  PointerGetDatum(&result));
 	}
 
-	if ( result ) {
+	if (result)
+	{
 		/* not need to update key */
-		pfree( datum );
-	} else {
+		pfree(datum);
+	}
+	else
+	{
 		gistcentryinit(giststate, &centry, datum, ev0p->rel, ev0p->page,
-			ev0p->offset, datumsize, FALSE);
+					   ev0p->offset, datumsize, FALSE);
 
 		isnull = (centry.pred) ? ' ' : 'n';
-		newtup = (IndexTuple) index_formtuple( r->rd_att, (Datum *) &centry.pred, &isnull );
-		newtup->t_tid = oldtup->t_tid; 
+		newtup = (IndexTuple) index_formtuple(r->rd_att, (Datum *) &centry.pred, &isnull);
+		newtup->t_tid = oldtup->t_tid;
 		if (centry.pred != datum)
-			pfree( datum );
+			pfree(datum);
 	}
 
-	if ( ev0p->pred && 
-	     ev0p->pred != (char*) oldtup + sizeof(IndexTupleData)  ) 
-		pfree( ev0p->pred ); 
-	if ( ev1p->pred && 
-	     ev1p->pred != (char*) addtup + sizeof(IndexTupleData)  ) 
-		pfree( ev1p->pred ); 
-	pfree( evec );
+	if (ev0p->pred &&
+		ev0p->pred != (char *) oldtup + sizeof(IndexTupleData))
+		pfree(ev0p->pred);
+	if (ev1p->pred &&
+		ev1p->pred != (char *) addtup + sizeof(IndexTupleData))
+		pfree(ev1p->pred);
+	pfree(evec);
 
-	return newtup;	
+	return newtup;
 }
- 
+
 /*
  *	gistSplit -- split a page in the tree.
  */
@@ -728,19 +768,27 @@ gistSplit(Relation r,
 		  InsertIndexResult *res)
 {
 	Page		p;
-	Buffer		leftbuf, rightbuf;
-	Page		left, right;
-	OffsetNumber 	*spl_left, *spl_right;
-	IndexTuple	*lvectup, *rvectup, *newtup;
-	int leftoff, rightoff;
-	BlockNumber lbknum, rbknum;
+	Buffer		leftbuf,
+				rightbuf;
+	Page		left,
+				right;
+	OffsetNumber *spl_left,
+			   *spl_right;
+	IndexTuple *lvectup,
+			   *rvectup,
+			   *newtup;
+	int			leftoff,
+				rightoff;
+	BlockNumber lbknum,
+				rbknum;
 	GISTPageOpaque opaque;
-	char	   isnull;
+	char		isnull;
 	GIST_SPLITVEC v;
 	bytea	   *entryvec;
 	bool	   *decompvec;
 	GISTENTRY	tmpentry;
-	int i, nlen;
+	int			i,
+				nlen;
 
 	p = (Page) BufferGetPage(buffer);
 	opaque = (GISTPageOpaque) PageGetSpecialPointer(p);
@@ -773,17 +821,17 @@ gistSplit(Relation r,
 	right = (Page) BufferGetPage(rightbuf);
 
 	/* generate the item array */
-	entryvec = (bytea *) palloc(VARHDRSZ + (*len+1) * sizeof(GISTENTRY));
-	decompvec = (bool *) palloc(VARHDRSZ + (*len+1) * sizeof(bool));
-	VARATT_SIZEP(entryvec) = (*len+1) * sizeof(GISTENTRY) + VARHDRSZ;
+	entryvec = (bytea *) palloc(VARHDRSZ + (*len + 1) * sizeof(GISTENTRY));
+	decompvec = (bool *) palloc(VARHDRSZ + (*len + 1) * sizeof(bool));
+	VARATT_SIZEP(entryvec) = (*len + 1) * sizeof(GISTENTRY) + VARHDRSZ;
 	for (i = 1; i <= *len; i++)
 	{
 		gistdentryinit(giststate, &((GISTENTRY *) VARDATA(entryvec))[i],
-					   (((char *) itup[i-1]) + sizeof(IndexTupleData)),
+					   (((char *) itup[i - 1]) + sizeof(IndexTupleData)),
 					   r, p, i,
-				 IndexTupleSize(itup[i-1]) - sizeof(IndexTupleData), FALSE);
+			IndexTupleSize(itup[i - 1]) - sizeof(IndexTupleData), FALSE);
 		if ((char *) (((GISTENTRY *) VARDATA(entryvec))[i].pred)
-			== (((char *) itup[i-1]) + sizeof(IndexTupleData)))
+			== (((char *) itup[i - 1]) + sizeof(IndexTupleData)))
 			decompvec[i] = FALSE;
 		else
 			decompvec[i] = TRUE;
@@ -791,8 +839,8 @@ gistSplit(Relation r,
 
 	/* now let the user-defined picksplit function set up the split vector */
 	FunctionCall2(&giststate->picksplitFn,
-		PointerGetDatum(entryvec),
-		PointerGetDatum(&v));
+				  PointerGetDatum(entryvec),
+				  PointerGetDatum(&v));
 
 	/* clean up the entry vector: its preds need to be deleted, too */
 	for (i = 1; i <= *len; i++)
@@ -801,35 +849,43 @@ gistSplit(Relation r,
 	pfree(entryvec);
 	pfree(decompvec);
 
-	spl_left = v.spl_left; spl_right = v.spl_right;
-	
+	spl_left = v.spl_left;
+	spl_right = v.spl_right;
+
 	/* form left and right vector */
-	lvectup = (IndexTuple*) palloc( sizeof( IndexTuple )*v.spl_nleft );
-	rvectup = (IndexTuple*) palloc( sizeof( IndexTuple )*v.spl_nright );
+	lvectup = (IndexTuple *) palloc(sizeof(IndexTuple) * v.spl_nleft);
+	rvectup = (IndexTuple *) palloc(sizeof(IndexTuple) * v.spl_nright);
 	leftoff = rightoff = 0;
-	for( i=1; i <= *len; i++ ) {
-		if (i == *(spl_left) || ( i==*len && *(spl_left) != FirstOffsetNumber ) ) {
-			lvectup[ leftoff++ ] = itup[ i-1 ];
+	for (i = 1; i <= *len; i++)
+	{
+		if (i == *(spl_left) || (i == *len && *(spl_left) != FirstOffsetNumber))
+		{
+			lvectup[leftoff++] = itup[i - 1];
 			spl_left++;
-		} else { 
-			rvectup[ rightoff++ ] = itup[ i-1 ];
+		}
+		else
+		{
+			rvectup[rightoff++] = itup[i - 1];
 			spl_right++;
 		}
 	}
 
 	/* write on disk (may be need another split) */
-	if ( gistnospace(right, rvectup, v.spl_nright) ) {
+	if (gistnospace(right, rvectup, v.spl_nright))
+	{
 		nlen = v.spl_nright;
-		newtup = gistSplit(r, rightbuf, rvectup, &nlen, giststate, 
-			( res && rvectup[ nlen-1 ] == itup[ *len - 1 ] ) ? res : NULL );
-		ReleaseBuffer( rightbuf );
-	} else {
+		newtup = gistSplit(r, rightbuf, rvectup, &nlen, giststate,
+			  (res && rvectup[nlen - 1] == itup[*len - 1]) ? res : NULL);
+		ReleaseBuffer(rightbuf);
+	}
+	else
+	{
 		OffsetNumber l;
-	
-		l = gistwritebuffer( r, right, rvectup, v.spl_nright, FirstOffsetNumber, giststate );
+
+		l = gistwritebuffer(r, right, rvectup, v.spl_nright, FirstOffsetNumber, giststate);
 		WriteBuffer(rightbuf);
 
-		if ( res )
+		if (res)
 			ItemPointerSet(&((*res)->pointerData), rbknum, l);
 		gistcentryinit(giststate, &tmpentry, v.spl_rdatum, (Relation) NULL,
 					   (Page) NULL, (OffsetNumber) 0,
@@ -839,32 +895,35 @@ gistSplit(Relation r,
 		v.spl_rdatum = tmpentry.pred;
 
 		nlen = 1;
-		newtup = (IndexTuple*) palloc( sizeof(IndexTuple) * 1);
-		isnull = ( v.spl_rdatum ) ? ' ' : 'n';
+		newtup = (IndexTuple *) palloc(sizeof(IndexTuple) * 1);
+		isnull = (v.spl_rdatum) ? ' ' : 'n';
 		newtup[0] = (IndexTuple) index_formtuple(r->rd_att, (Datum *) &(v.spl_rdatum), &isnull);
 		ItemPointerSet(&(newtup[0]->t_tid), rbknum, 1);
 	}
 
-	if ( gistnospace(left, lvectup, v.spl_nleft) ) {
-		int llen = v.spl_nleft;
+	if (gistnospace(left, lvectup, v.spl_nleft))
+	{
+		int			llen = v.spl_nleft;
 		IndexTuple *lntup;
 
-		lntup = gistSplit(r, leftbuf, lvectup, &llen, giststate, 
-			( res && lvectup[ llen-1 ] == itup[ *len - 1 ] ) ? res : NULL );
-		ReleaseBuffer( leftbuf );
+		lntup = gistSplit(r, leftbuf, lvectup, &llen, giststate,
+			  (res && lvectup[llen - 1] == itup[*len - 1]) ? res : NULL);
+		ReleaseBuffer(leftbuf);
 
-		newtup = gistjoinvector( newtup, &nlen, lntup, llen );
-		pfree( lntup ); 
-	} else {
+		newtup = gistjoinvector(newtup, &nlen, lntup, llen);
+		pfree(lntup);
+	}
+	else
+	{
 		OffsetNumber l;
-	
-		l = gistwritebuffer( r, left, lvectup, v.spl_nleft, FirstOffsetNumber, giststate );
-		if ( BufferGetBlockNumber(buffer) != GISTP_ROOT)
+
+		l = gistwritebuffer(r, left, lvectup, v.spl_nleft, FirstOffsetNumber, giststate);
+		if (BufferGetBlockNumber(buffer) != GISTP_ROOT)
 			PageRestoreTempPage(left, p);
 
 		WriteBuffer(leftbuf);
 
-		if ( res )
+		if (res)
 			ItemPointerSet(&((*res)->pointerData), lbknum, l);
 		gistcentryinit(giststate, &tmpentry, v.spl_ldatum, (Relation) NULL,
 					   (Page) NULL, (OffsetNumber) 0,
@@ -874,10 +933,10 @@ gistSplit(Relation r,
 		v.spl_ldatum = tmpentry.pred;
 
 		nlen += 1;
-		newtup = (IndexTuple*) repalloc( (void*)newtup, sizeof(IndexTuple) * nlen);
-		isnull = ( v.spl_ldatum ) ? ' ' : 'n';
-		newtup[nlen-1] = (IndexTuple) index_formtuple(r->rd_att, (Datum *) &(v.spl_ldatum), &isnull);
-		ItemPointerSet(&(newtup[nlen-1]->t_tid), lbknum, 1);
+		newtup = (IndexTuple *) repalloc((void *) newtup, sizeof(IndexTuple) * nlen);
+		isnull = (v.spl_ldatum) ? ' ' : 'n';
+		newtup[nlen - 1] = (IndexTuple) index_formtuple(r->rd_att, (Datum *) &(v.spl_ldatum), &isnull);
+		ItemPointerSet(&(newtup[nlen - 1]->t_tid), lbknum, 1);
 	}
 
 
@@ -885,10 +944,10 @@ gistSplit(Relation r,
 	gistadjscans(r, GISTOP_SPLIT, BufferGetBlockNumber(buffer), FirstOffsetNumber);
 
 	/* !!! pfree */
-	pfree( rvectup );
-	pfree( lvectup );
-	pfree( v.spl_left );
-	pfree( v.spl_right );
+	pfree(rvectup);
+	pfree(lvectup);
+	pfree(v.spl_left);
+	pfree(v.spl_right);
 
 	*len = nlen;
 	return newtup;
@@ -903,8 +962,8 @@ gistnewroot(GISTSTATE *giststate, Relation r, IndexTuple *itup, int len)
 	b = ReadBuffer(r, GISTP_ROOT);
 	GISTInitBuffer(b, 0);
 	p = BufferGetPage(b);
-	
-	gistwritebuffer( r, p, itup, len, FirstOffsetNumber, giststate );
+
+	gistwritebuffer(r, p, itup, len, FirstOffsetNumber, giststate);
 	WriteBuffer(b);
 }
 
@@ -1000,8 +1059,8 @@ gistfreestack(GISTSTACK *s)
 Datum
 gistdelete(PG_FUNCTION_ARGS)
 {
-	Relation		r = (Relation) PG_GETARG_POINTER(0);
-	ItemPointer		tid = (ItemPointer) PG_GETARG_POINTER(1);
+	Relation	r = (Relation) PG_GETARG_POINTER(0);
+	ItemPointer tid = (ItemPointer) PG_GETARG_POINTER(1);
 	BlockNumber blkno;
 	OffsetNumber offnum;
 	Buffer		buf;
@@ -1101,7 +1160,7 @@ gist_tuple_replacekey(Relation r, GISTENTRY entry, IndexTuple t)
 	char	   *datum = (((char *) t) + sizeof(IndexTupleData));
 
 	/* if new entry fits in index tuple, copy it in */
-	if ((Size) entry.bytes < IndexTupleSize(t) - sizeof(IndexTupleData) || (Size) entry.bytes == 0 )
+	if ((Size) entry.bytes < IndexTupleSize(t) - sizeof(IndexTupleData) || (Size) entry.bytes == 0)
 	{
 		memcpy(datum, entry.pred, entry.bytes);
 		/* clear out old size */
@@ -1116,9 +1175,9 @@ gist_tuple_replacekey(Relation r, GISTENTRY entry, IndexTuple t)
 		/* generate a new index tuple for the compressed entry */
 		TupleDesc	tupDesc = r->rd_att;
 		IndexTuple	newtup;
-		char	   isnull;
+		char		isnull;
 
-		isnull = ( entry.pred ) ? ' ' : 'n';
+		isnull = (entry.pred) ? ' ' : 'n';
 		newtup = (IndexTuple) index_formtuple(tupDesc,
 											  (Datum *) &(entry.pred),
 											  &isnull);
@@ -1181,38 +1240,40 @@ gist_dumptree(Relation r, int level, BlockNumber blk, OffsetNumber coff)
 	Page		page;
 	GISTPageOpaque opaque;
 	IndexTuple	which;
-	ItemId          iid;
-	OffsetNumber i,maxoff;
-	BlockNumber	cblk;
-	char	*pred;
+	ItemId		iid;
+	OffsetNumber i,
+				maxoff;
+	BlockNumber cblk;
+	char	   *pred;
 
-	pred  = (char*) palloc( sizeof(char)*level+1 );
+	pred = (char *) palloc(sizeof(char) * level + 1);
 	MemSet(pred, '\t', level);
-	pred[level]='\0';
+	pred[level] = '\0';
 
 	buffer = ReadBuffer(r, blk);
 	page = (Page) BufferGetPage(buffer);
 	opaque = (GISTPageOpaque) PageGetSpecialPointer(page);
-	
-	maxoff = PageGetMaxOffsetNumber( page );
-	
-	elog(NOTICE,"%sPage: %d %s blk: %d maxoff: %d free: %d", pred, coff, ( opaque->flags & F_LEAF ) ? "LEAF" : "INTE", (int)blk, (int)maxoff, PageGetFreeSpace(page));
-	
-	for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) {
+
+	maxoff = PageGetMaxOffsetNumber(page);
+
+	elog(NOTICE, "%sPage: %d %s blk: %d maxoff: %d free: %d", pred, coff, (opaque->flags & F_LEAF) ? "LEAF" : "INTE", (int) blk, (int) maxoff, PageGetFreeSpace(pa